scau：数据结构oj 实验一

已于 2024-06-17 01:23:55 修改
阅读量1.8k 收藏 24
点赞数 26
文章标签： 数据结构 c#
于 2024-03-13 00:44:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zero_019/article/details/136667072
版权

实验1

8576 顺序线性表的基本操作

时间限制:1000MS  代码长度限制:10KB
提交次数:9027 通过次数:2456

题型: 编程题   语言: G++;GCC

Description

 编写算法，创建初始化容量为LIST_INIT_SIZE的顺序表T，并实现插入、删除、遍历操作。本题目给出部分代码，请补全内容。

#include<stdio.h>
#include<malloc.h>
#define OK 1 
#define ERROR 0
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int

typedef struct
{
	int *elem;
	int length;
	int listsize;
}SqList;

int InitList_Sq(SqList &L)
{
// 算法2.3，构造一个空的线性表L，该线性表预定义大小为LIST_INIT_SIZE
// 请补全代码

}

int Load_Sq(SqList &L)
{
// 输出顺序表中的所有元素
	int i;
	if(_________________________) printf("The List is empty!");  // 请填空
	else
	{
		printf("The List is: ");
		for(_________________________) printf("%d ",_________________________);  // 请填空
	}
	printf("\n");
	return OK;
}

int ListInsert_Sq(SqList &L,int i,int e)
{
// 算法2.4，在顺序线性表L中第i个位置之前插入新的元素e
// i的合法值为1≤i≤L.length +1
// 请补全代码

}

int ListDelete_Sq(SqList &L,int i, int &e)
{
// 算法2.5,在顺序线性表L中删除第i个位置的元素，并用e返回其值
// i的合法值为1≤i≤L.length
// 请补全代码

}

int main()
{
	SqList T;
	int a, i;
	ElemType e, x;
	if(_________________________)    // 判断顺序表是否创建成功
	{
		printf("A Sequence List Has Created.\n");
	}
	while(1)
	{
		printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");
		scanf("%d",&a);
		switch(a)
		{
			case 1: scanf("%d%d",&i,&x);
					if(_________________________) printf("Insert Error!\n"); // 执行插入函数，根据返回值判断i值是否合法
					else printf("The Element %d is Successfully Inserted!\n", x); 
					break;
			case 2: scanf("%d",&i);
					if(_________________________) printf("Delete Error!\n"); // 执行删除函数，根据返回值判断i值是否合法
					else printf("The Element %d is Successfully Deleted!\n", e);
					break;
			case 3: Load_Sq(T);
					break;
			case 0: return 1;
		}
	}
}

输入格式

测试样例格式说明：
根据菜单操作：
1、输入1，表示要实现插入操作，紧跟着要输入插入的位置和元素，用空格分开
2、输入2，表示要实现删除操作，紧跟着要输入删除的位置
3、输入3，表示要输出顺序表的所有元素
4、输入0，表示程序结束

输入样例

1
1 2
1
1 3
2
1
3
0

输出样例

A Sequence List Has Created.
1:Insert element
2:Delete element
3:Load all elements
0:Exit
Please choose:
The Element 2 is Successfully Inserted!
1:Insert element
2:Delete element
3:Load all elements
0:Exit
Please choose:
The Element 3 is Successfully Inserted!
1:Insert element
2:Delete element
3:Load all elements
0:Exit
Please choose:
The Element 3 is Successfully Deleted!
1:Insert element
2:Delete element
3:Load all elements
0:Exit
Please choose:
The List is: 2 
1:Insert element
2:Delete element
3:Load all elements
0:Exit
Please choose:

代码

#include<stdio.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int

typedef struct
{
	int *elem;
	int length;
	int listsize;
}SqList;

int InitList_Sq(SqList &L)
{
// 算法2.3，构造一个空的线性表L，该线性表预定义大小为LIST_INIT_SIZE
// 请补全代码
    L.elem=new ElemType[LIST_INIT_SIZE];
    if(!L.elem)
    return(ERROR);
    L.length=0;
    L.listsize=LIST_INIT_SIZE;//!!!不要漏了
    return OK;
}

int Load_Sq(SqList &L)
{
// 输出顺序表中的所有元素
	int i;
	if(L.length==0) printf("The List is empty!");  // 请填空
	else
	{
		printf("The List is: ");
		for(i=0;i<L.length;i++) printf("%d ",L.elem[i]);  // 请填空
	}
	printf("\n");
	return OK;
}

int ListInsert_Sq(SqList &L,int i,int e)
{
// 算法2.4，在顺序线性表L中第i个位置之前插入新的元素e
// i的合法值为1≤i≤L.length +1
// 请补全代码
   if(i<1||i>L.length+1)
   return ERROR;
   if(L.length==LIST_INIT_SIZE)//！！！不要漏了
   return ERROR;

   for(int j=L.length;j>=i;j--)
   {
       L.elem[j]=L.elem[j-1];
   }
   L.elem[i-1]=e;//第i个元素位置是L.elem[i-1]
   ++L.length;
   return OK;
}

int ListDelete_Sq(SqList &L,int i, int &e)
{
// 算法2.5,在顺序线性表L中删除第i个位置的元素，并用e返回其值
// i的合法值为1≤i≤L.length
// 请补全代码
    if(i<1||i>L.length)
    return ERROR;
    e=L.elem[i-1];
    for(int j=i-1;j<L.length-1;j++)
    {
        L.elem[j]=L.elem[j+1];
    }
    L.length--;
    return e;
}

int main()
{
	SqList T;
	int a, i;
	ElemType e, x;
	if(InitList_Sq(T))    // 判断顺序表是否创建成功
	{
		printf("A Sequence List Has Created.\n");
	}
	while(1)
	{
		printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");
		scanf("%d",&a);
		switch(a)
		{
			case 1: scanf("%d%d",&i,&x);
					if(ListInsert_Sq(T,i,x)==ERROR) printf("Insert Error!\n"); 
// 执行插入函数，根据返回值判断i值是否合法
					else printf("The Element %d is Successfully Inserted!\n", x);
					break;
			case 2: scanf("%d",&i);
					if(ListDelete_Sq(T,i,e)==ERROR) printf("Delete Error!\n"); 
// 执行删除函数，根据返回值判断i值是否合法
					else printf("The Element %d is Successfully Deleted!\n", e);
					break;
			case 3: Load_Sq(T);
					break;
			case 0: return 1;
		}
	}
}

 注意点：

1.插入时和删除时的范围不同：插入时尾部可以插入，删除时尾部不能删除。

2.插入和删除循环的起点不同：插入时循环从尾部开始，删除则不是

3.要看清题目要求，删除时要求返回e，不要return ERROR/OK.

4.构造线性表时，看清题目给的是T，不要写成L。

5.插入和删除都需要先判断i是否合法。特别注意插入时若空间已满（不要漏掉这个判断），则不能插入。

6.不要漏掉L.listsize=LIST_INIT_SIZE;，，表示当前分配的存储空间大小（以元素数量计），这个空间是用于存储表中元素的。

8577 合并顺序表

时间限制:1000MS  代码长度限制:10KB
提交次数:5339 通过次数:2251

题型: 编程题   语言: G++

Description

若线性表中数据元素相互之间可以比较，且数据元素在表中按值递增或递减，则称该表为有序表。

编写算法，将两个非递减有序顺序表A和B合并成一个新的非递减有序顺序表C。

输入格式

第一行：顺序表A的元素个数
第二行：顺序表A的各元素（非递减），用空格分开
第三行：顺序表B的元素个数
第四行：顺序表B的各元素（非递减），用空格分开

输出格式

第一行：顺序表A的元素列表
第二行：顺序表B的元素列表
第三行：合并后顺序表C的元素列表

输入样例

5
1 3 5 7 9
5
2 4 6 8 10

输出样例

List A:1 3 5 7 9 
List B:2 4 6 8 10 
List C:1 2 3 4 5 6 7 8 9 10

提示

输出时注意大小写和标点。

 代码：

#include <iostream>
#define SIZE 100
#define ERROR 0
#define OK 1
#define  end1 '\n'
using namespace std;


typedef struct
{
    int *elem;
    int length;
    int listsize;
}Sqlist;



int InitSqlist(Sqlist &L)
{
    L.elem=new int[SIZE];
    if(!L.elem)
    return ERROR;
    L.length=0;
    L.listsize=SIZE;
    return OK;
}


int putinlist(Sqlist &L)
{
    int n,i;
    cin>>n;

    int a;

    for(i=0;i<n;i++)
    {
        cin>>a;
        L.elem[i]=a;
        L.length++;
    }
    if(L.length==n)
    return OK;
    else
    return ERROR;
}


void MergeList(Sqlist L1,Sqlist L2,Sqlist &L3)
{
    int *pa,*pb,*pc,*pa_last,*pb_last;

    L3.length=L2.length+L1.length;
    L3.elem=new int [L3.length];
    pc=L3.elem;
    pa=L1.elem;
    pb=L2.elem;
    pa_last=L1.elem+L1.length-1;
    pb_last=L2.elem+L2.length-1;
    while(pa<=pa_last&&pb<=pb_last)
    {
        if(*pa<=*pb)
        {
            *pc++=*pa++;
        }
        else
        *pc++=*pb++;
    }
    while(pa<=pa_last)
    {
        *pc++=*pa++;
    }
    while(pb<=pb_last)
    {
        *pc++=*pb++;
    }
}


int print(Sqlist &L)
{
    int i;
    for(i=0;i<L.length;i++)
    {
        cout<<L.elem[i]<<" ";
    }
    cout<<end1;
}


int main()
{
    Sqlist T1,T2,T3;
    InitSqlist(T1);
    InitSqlist(T2);
    int n1,n2;
    //cin>>n1;
    putinlist(T1);
    //cin>>n2;
    putinlist(T2);
    InitSqlist(T3);
    MergeList(T1,T2,T3);
    cout<<"List A:";
    print(T1);
    cout<<"List B:";
    print(T2);
    cout<<"List C:";
    print(T3);
    return 0;
}

8578 顺序表逆置

时间限制:1000MS  代码长度限制:10KB
提交次数:3660 通过次数:2149

题型: 编程题   语言: G++;GCC

Description

顺序表的基本操作代码如下：
#include<stdio.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int

typedef int Status;
typedef struct
{
    int *elem;
    int length;
    int listsize;
}SqList;

Status InitList_Sq(SqList &L) 
{  // 算法2.3
  // 构造一个空的线性表L。
  L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
  if (!L.elem) return OK;        // 存储分配失败
  L.length = 0;                  // 空表长度为0
  L.listsize = LIST_INIT_SIZE;   // 初始存储容量
  return OK;
} // InitList_Sq

Status ListInsert_Sq(SqList &L, int i, ElemType e) 
{  // 算法2.4
  // 在顺序线性表L的第i个元素之前插入新的元素e，
  // i的合法值为1≤i≤ListLength_Sq(L)+1
  ElemType *p;
  if (i < 1 || i > L.length+1) return ERROR;  // i值不合法
  if (L.length >= L.listsize) {   // 当前存储空间已满，增加容量
    ElemType *newbase = (ElemType *)realloc(L.elem,
                  (L.listsize+LISTINCREMENT)*sizeof (ElemType));
    if (!newbase) return ERROR;   // 存储分配失败
    L.elem = newbase;             // 新基址
    L.listsize += LISTINCREMENT;  // 增加存储容量
  }
  ElemType *q = &(L.elem[i-1]);   // q为插入位置
  for (p = &(L.elem[L.length-1]); p>=q; --p) *(p+1) = *p;
                                  // 插入位置及之后的元素右移
  *q = e;       // 插入e
  ++L.length;   // 表长增1
  return OK;
} // ListInsert_Sq

Status ListDelete_Sq(SqList &L, int i, ElemType &e) 
{  // 算法2.5
  // 在顺序线性表L中删除第i个元素，并用e返回其值。
  // i的合法值为1≤i≤ListLength_Sq(L)。
  ElemType *p, *q;
  if (i<1 || i>L.length) return ERROR;  // i值不合法
  p = &(L.elem[i-1]);                   // p为被删除元素的位置
  e = *p;                               // 被删除元素的值赋给e
  q = L.elem+L.length-1;                // 表尾元素的位置
  for (++p; p<=q; ++p) *(p-1) = *p;     // 被删除元素之后的元素左移
  --L.length;                           // 表长减1
  return OK;
} // ListDelete_Sq

设有一顺序表A=（a0,a1,..., ai,...an-1)，其逆顺序表定义为A'=( an-1,..., ai,...,a1, a0)。设计一个算法，将顺序表逆置，要求顺序表仍占用原顺序表的空间。

输入格式

第一行：输入顺序表的元素个数
第二行：输入顺序表的各元素，用空格分开

输出格式

第一行：逆置前的顺序表元素列表
第二行：逆置后的顺序表元素列表

输入样例

10
1 2 3 4 5 6 7 8 9 10

输出样例

The List is:1 2 3 4 5 6 7 8 9 10 
The turned List is:10 9 8 7 6 5 4 3 2 1

 代码：

#include<stdio.h>
#include<malloc.h>
#include<iostream>
#define OK 1
#define ERROR 0
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int
using namespace std;
typedef struct
{
	int *elem;
	int length;
	int listsize;
}SqList;

int InitList_Sq(SqList &L)
{
// 算法2.3，构造一个空的线性表L，该线性表预定义大小为LIST_INIT_SIZE
// 请补全代码
   L.elem=new ElemType[LIST_INIT_SIZE];
   if(!L.elem) return ERROR;
   L.length=0;
   L.listsize=LIST_INIT_SIZE;
   return OK;

}

int Load_Sq(SqList &L)
{
// 输出顺序表中的所有元素
	int i;
	if(L.length==0) printf("The List is empty!");  // 请填空
	else
	{
		//printf("The List is: ");
		for(i=0;i<L.length;i++) printf("%d ",L.elem[i]);  // 请填空
	}
	printf("\n");
	return OK;
}


int putin(SqList &L)
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>L.elem[i];
        L.length++;
    }
    if(L.length==n)return OK;
    else return ERROR;
}



int nizhi(SqList &L)
{
    int temp;
    for(int i=0;i<L.length/2;i++)
    {
        temp=L.elem[i];
        L.elem[i]=L.elem[L.length-i-1];
        L.elem[L.length-i-1]=temp;
    }
}




int main()
{
	SqList T;
	InitList_Sq(T);
	putin(T);
	cout<<"The List is:";
	Load_Sq(T);
    cout<<"The turned List is:";
    nizhi(T);
	Load_Sq(T);
	return 0;


}

8579 链式线性表的基本操作

时间限制:1000MS  代码长度限制:10KB
提交次数:5567 通过次数:2176

题型: 编程题   语言: G++;GCC

Description

 编写算法，创建一个含有n个元素的带头结点的单链表L并实现插入、删除、遍历操作。本题目提供部分代码，请补全内容。

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1 
#define ElemType int

typedef struct LNode
{
 int data;
 struct LNode *next;
}LNode,*LinkList;

int CreateLink_L(LinkList &L,int n){
// 创建含有n个元素的单链表
  LinkList p,q;
  int i;
  ElemType e;
  L = new LNode;
  L->next = NULL;              // 先建立一个带头结点的单链表
  q = L;
  for (i=0; i<n; i++) {
    scanf("%d", &e);
    p = new LNode;  // 生成新结点
    // 请补全代码

  }
  return OK;
}

int LoadLink_L(LinkList &L){
// 单链表遍历
 LinkList p = L->next;
 if(___________________________)printf("The List is empty!"); // 请填空
 else
 {
	 printf("The LinkList is:");
	 while(___________________________)    // 请填空
	 {
		printf("%d ",p->data); 
		___________________________    // 请填空
	 }
 }
 printf("\n");
 return OK;
}

int LinkInsert_L(LinkList &L,int i,ElemType e){
// 算法2.9
// 在带头结点的单链线性表L中第i个位置之前插入元素e
// 请补全代码

}

int LinkDelete_L(LinkList &L,int i, ElemType &e){
// 算法2.10
// 在带头结点的单链线性表L中，删除第i个元素，并用e返回其值
// 请补全代码

}

int main()
{
 LinkList T;
 int a,n,i;
 ElemType x, e;
 printf("Please input the init size of the linklist:\n");
 scanf("%d",&n);
 printf("Please input the %d element of the linklist:\n", n);
 if(___________________________)     // 判断链表是否创建成功，请填空
 {
	 printf("A Link List Has Created.\n");
	 LoadLink_L(T);
 }
 while(1)
	{
		printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");
		scanf("%d",&a);
		switch(a)
		{
			case 1: scanf("%d%d",&i,&x);
				  if(___________________________) printf("Insert Error!\n"); // 判断i值是否合法，请填空
				  else printf("The Element %d is Successfully Inserted!\n", x); 
				  break;
			case 2: scanf("%d",&i);
				  if(___________________________) printf("Delete Error!\n"); // 判断i值是否合法，请填空
				  else printf("The Element %d is Successfully Deleted!\n", e);
				  break;
			case 3: LoadLink_L(T);
				  break;
			case 0: return 1;
		}
	}
}

输入格式

测试样例格式说明：
根据菜单操作：
1、输入1，表示要实现插入操作，紧跟着要输入插入的位置和元素，用空格分开
2、输入2，表示要实现删除操作，紧跟着要输入删除的位置
3、输入3，表示要输出顺序表的所有元素
4、输入0，表示程序结束

输入样例

3
3 6 9
3
1
4 12
2
1
3
0

输出样例

Please input the init size of the linklist:
Please input the 3 element of the linklist:
A Link List Has Created.
The LinkList is:3 6 9 
1:Insert element
2:Delete element
3:Load all elements
0:Exit
Please choose:
The LinkList is:3 6 9 
1:Insert element
2:Delete element
3:Load all elements
0:Exit
Please choose:
The Element 12 is Successfully Inserted!
1:Insert element
2:Delete element
3:Load all elements
0:Exit
Please choose:
The Element 3 is Successfully Deleted!
1:Insert element
2:Delete element
3:Load all elements
0:Exit
Please choose:
The LinkList is:6 9 12 
1:Insert element
2:Delete element
3:Load all elements
0:Exit
Please choose:

代码：

#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define ElemType int


typedef struct LNode
{
    int data;
    struct LNode *next;
} LNode,*LinkList;

int CreateLink_L(LinkList &L,int n)
{
// 创建含有n个元素的单链表
    LinkList p,q;//两个指针
    int i;
    ElemType e;
    L = new LNode;
    L->next = NULL;// 先建立一个带头结点的单链表
    q = L;//将头指针L赋值给q，让q也指向头结点
    for (i=0; i<n; i++)
    {
        scanf("%d", &e);
        p = new LNode;  // 生成新结点
        p->data=e;// 将e赋值给p的数据域
        p->next=NULL;//指针域指向空
        q->next=p;//把q和p连起来
        q=p;//q指向新的尾结点
    }
    return OK;
}

int LoadLink_L(LinkList &L)
{
// 单链表遍历
    LinkList p = L->next;//p指向首元结点
    if(!p)printf("The List is empty!"); //首元结点为空
    else
    {
        printf("The LinkList is:");
        while(p!=NULL)
        {
            printf("%d ",p->data);
            p=p->next;
        }
    }
    printf("\n");
    return OK;
}

int LinkInsert_L(LinkList &L,int i,ElemType e)
{
// 算法2.9
// 在带头结点的单链线性表L中第i个位置之前插入元素e
// 请补全代码
    LinkList p=L;//p指向头结点
    LinkList s;
    int j=0;
    while(p&&(j<i-1))//当p指向的结点不为空且计数器j<i-1,即定位到第i个位置前
    {
        p=p->next;
        ++j;
    }
    if(!p||(j>i-1))
        return ERROR;
    s=new LNode;//找到插入位置前一个结点后，创建新结点s
    s->data=e;//e赋值给s的数据域
    s->next=p->next;//把p的next赋值给s, 即把p后面一个结点与s链接起来，s和p同时指向p的后一个结点
    p->next=s;//p的指针域指向s
    return OK;


}

int LinkDelete_L(LinkList &L,int i, ElemType &e)
{
// 算法2.10
// 在带头结点的单链线性表L中，删除第i个元素，并用e返回其值
// 请补全代码
    LinkList p=L,q;
    LinkList s;
    int j=0;
    while(p->next&&(j<i-1))
    {
        p=p->next;
        ++j;
    }
    if(!(p->next)||(j>i-1))
        return ERROR;
    q=p->next;//p定位到要删除的元素的前一个，q定位到要删除的元素
    e=q->data;//把要删除的结点的数据域保存到e中
    p->next=q->next;//使p的指针域指向q的next ，即p,q,同时指向q的后一个结点
    delete q;
    return OK;
}

int main()
{
    LinkList T;
    int a,n,i;
    ElemType x, e;
    printf("Please input the init size of the linklist:\n");
    scanf("%d",&n);
    printf("Please input the %d element of the linklist:\n", n);
    if(CreateLink_L(T,n))     // 判断链表是否创建成功，请填空
    {
        printf("A Link List Has Created.\n");
        LoadLink_L(T);
    }
    while(1)
    {
        printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");
        scanf("%d",&a);
        switch(a)
        {
        case 1:
            scanf("%d%d",&i,&x);
            if(LinkInsert_L(T,i,x)==0) printf("Insert Error!\n"); // 判断i值是否合法，请填空
            else printf("The Element %d is Successfully Inserted!\n", x);
            break;
        case 2:
            scanf("%d",&i);
            if(LinkDelete_L(T,i,e)==ERROR) printf("Delete Error!\n"); // 判断i值是否合法，请填空
            else printf("The Element %d is Successfully Deleted!\n", e);
            break;
        case 3:
            LoadLink_L(T);
            break;
        case 0:
            return 1;
        }
    }
}

8580 合并链表

代码：

#include <stdio.h>
#include <malloc.h>
#define OK 1
#define ERROR 0
#define ElemType int

typedef int Status;

typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;

Status CreateLink_L(LinkList &L,int n)
{
    LinkList p,s;
    int i;
    ElemType e;
    L=new LNode;
    L->next=NULL;
    p=L;
    for(i=0;i<n;i++)
    {
        scanf("%d",&e);
        s=new LNode;
        s->data=e;
        s->next=NULL;
        p->next=s;
        p=s;
    }
    return OK;
}

Status CreateEmptyLink_L(LinkList &L,int n)
{
    LinkList p,s;
    int i;
    L=new LNode;
    L->next=NULL;
    p=L;
    for(i=0;i<n;i++)
    {
        s=new LNode;
        s->data=0;
        s->next=NULL;
        p->next=s;
        p=s;
    }
    return OK;
}

Status ListInsert_L(LinkList &L,int i,ElemType e)
{
    LinkList p,s;
    int j=1;
    p=L;
    while(p&&j<i)
    {
        p=p->next;
        j++;
    }
    if(!p||j>i) return ERROR;
    s=new LNode;
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
}

Status ListDelete_L(LinkList &L,int i,ElemType &e)
{
    LinkList p,s;
    int j=1;
    p=L;
    while(p->next&&j<=i)
    {
        s=p;
        p=p->next;
        j++;
    }
    if(!(p->next)||j>i) return ERROR;
    e=p->data;
    s->next=p->next;
    delete p;
    return OK;
}

Status LoadLink_L(LinkList &L)
{
    LinkList p=L->next;
    if(p==NULL) printf("The List is empty!");
    else{
        while(p!=NULL)
        {
            printf("%d ",p->data);
            p=p->next;
        }
    }
    printf("\n");
    return OK;
}

Status MergeList_L(LinkList &LA, LinkList &LB,LinkList &LC)
{
    LinkList pa,pb,pc;
    pa=LA->next;
    pb=LB->next;
    LC=LA;
    pc=LC;
    while(pa&&pb)
    {
        if(pa->data<=pb->data)
        {
            pc->next=pa;
            pc=pa;
            pa=pa->next;
        }
        else
        {
            pc->next=pb;
            pc=pb;
            pb=pb->next;
        }
    }
    pc->next=pa?pa:pb;
    delete LB;
}

int main()
{
    LinkList A,B,C;
    int a,b;
    scanf("%d",&a);
    CreateLink_L(A,a);
    printf("List A:");
    LoadLink_L(A);
    scanf("%d",&b);
    CreateLink_L(B,b);
    printf("List B:");
    LoadLink_L(B);
    CreateEmptyLink_L(C,a+b);
    MergeList_L(A,B,C);
    printf("List C:");
    LoadLink_L(C);
}

19080 反转链表

时间限制:1000MS  代码长度限制:10KB
提交次数:0 通过次数:0

题型: 填空题   语言: 不限定

Description

一道经典的题目

给定一个单链表的头结点L，长度为n，反转该链表后，返回新链表的表头。

要求：空间复杂度 O(1) ，时间复杂度 O(n)。

如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。


#include <iostream>//C++
using namespace std;
struct LNode
{
    int data;
    LNode * next;
};
void createList(LNode * &L,int n)
{
    /**< 尾插法创建单链表 */
    LNode *r, *p;
    r=L=new LNode;/**< 创建头结点 */
    L->next=NULL;
    for(int i=1; i<=n; i++)
    {
        p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
void trv(LNode * L)
{
    /**< 一个简单的链表遍历函数，供编程过程中测试使用 */
    L=L->next;
    while(L)
    {
        cout<<L->data<<' ';
        L=L->next;
    }
}
void reverseList(LNode * &L) 
{

   
        _______________________
  
}
int main()
{
    int n;
    LNode *L;
    cin>>n;
    createList(L,n);
    reverseList(L);
    trv(L);
    return 0;
}

 

输入格式

第一行一个整数n，代表链表长度。
第二行n个整数。

输出格式

输出逆置后的单链表。

输入样例

5
1 2 3 4 5

输出样例

5 4 3 2 1

 代码：

#include <iostream>//C++
using namespace std;
struct LNode
{
    int data;
    LNode * next;
};
void createList(LNode * &L,int n)
{
    /**< 尾插法创建单链表 */
    LNode *r, *p;
    r=L=new LNode;/**< 创建头结点 */
    L->next=NULL;
    for(int i=1; i<=n; i++)
    {
        p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}

void trv(LNode * L)
{
    /**< 一个简单的链表遍历函数，供编程过程中测试使用 */
    L=L->next;
    while(L)
    {
        cout<<L->data<<' ';
        L=L->next;
    }
}
void reverseList(LNode * &L)
{
    LNode  *pre,*cur,*nex;
    pre=NULL;
    cur=L->next;
    nex=NULL;

    while(cur)
    {
     pre=cur;
     cur=cur->next;
     pre->next=nex;//最重要的
     nex=pre;
    }
     L->next=pre;

}
int main()
{
    int n;
    LNode *L;
    cin>>n;
    createList(L,n);
    reverseList(L);
    trv(L);
    return 0;
}

zero_019
关注
华南农业大学C语言oj第五章
黑兔子撒的博客
03-01 7304
18046字母分类统计 时间限制:1000MS 内存限制:65535K 提交次数:0 通过次数:0 题型: 编程题语言: G++;GCC;VC Description 输入一行以换行符结束的字符，统计并输出其中英文字母、数字、空格和其它字符的个数。 输入格式 一行字符，以换行符结束 输出格式 一行4个数字分别为：英文字母、数字、空格和其它字符的个数，两数据之间以一个空格分...
scau 数据结构实验一 8578 顺序表逆置
qq_61974198的博客
03-18 451
Description 顺序表的基本操作代码如下： #include<stdio.h> #include<malloc.h> #define OK 1 #define ERROR 0 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int typedef int Status; typedef struct { int *elem; int length; int
SCAU OJ综合性实验
LittleGuai的博客
01-10 1911
在当前目录中存在文件名为"case1.in"（其中case后为数字1，不是字母l，写错提交后会判错）的文本文件，其内容为一篇英文文章（以EOF作为结束标志）。现要求读取该文本文件内容，统计文章中每个单词出现的次数，并输出出现次数最多的前5个单词及其出现次数（按出现次数由多到少的顺序输出，次数相同时按字典顺序输出，不足5个单词时，按序输出全部单词）。程序中注意如下细节： （1） 空格、标点符号与回车符起到分隔单词的作用。 （2） 文章一行的末尾可能有连字符，出现连字符时，该行最末的字符串与下行最先出现的字符串
SCAUOJ——17235-Minecraft是个好游戏
GSilang's blog
10-06 371
17235 Minecraft是个好游戏 时间限制:1000MS  内存限制:65535K Description Minecraft是一个颠覆性的高自由度游戏，其中文译名叫“我的世界”。之所以会有如此译名，原因在于这个游戏就像一个沙盒世界，玩家就像是个创世神一般。其颠覆性在于它不同于以往那些游戏“要你做 去什么”，相反的，是由玩家去思考“我要做什么”。 说了这么一段，你们是不是很想上网
SCAU程序设计在线实训平台_实验_高级语言程序设计_实验12 文件操作_堂上练习
YelloooBlue's Blog
12-29 2784
1107 文本文件操作_单词的排序 Description 在当前目录有文件“case1.in”，文件里存放有多个（总个数不超过10000个）英文单词（每个英文单词不会超过10个字文字符）， 每行一个，单词未排序。现要求，将文件中的所有单词按字典顺序排序，然后将排序好的单词写入新建的文件answer.txt中（注：文件存放于当前目录）。 请完成程序，实现该功能，（注意，填空题，请不要使用return 0结束，否则会影响评判而判错）（如case1.in文件中原内容如下） hello bye yes （程序执
scau oj 10848 2021-11-06
Electric_W的博客
11-06 220
18048自由落体 时间限制:1000MS 代码长度限制:10KB 提交次数:0 通过次数:0 题型: 编程题语言: G++;GCC;VC Description 一个球从100米的高度自由落下，每次落地后弹起的原来高度的一半。计算并输出第n次落地时，共经过了多少米，第n次弹起的高度是多少?结果显示3位小数。 输入格式 从键盘输入一个数n（n>0） 输出格式 输出两个数，分别为共...
SCAU OJ 数据结构 综合性实验
最新发布
06-11
在SCAU OJ的综合性实验中，你会遇到各种复杂的数据结构问题，比如链表、树（如二叉搜索树、AVL树、红黑树等）、图、堆、队列、栈、哈希表、并查集、优先队列等。这些题目可能涉及基本操作（如查找、插入、删除），也...
scau归并排序 SCAU数据结构年期末复习
07-05
SCAU数据结构年期末复习 本资源摘要信息涵盖了SCAU数据结构年期末复习的主要知识点，包括数据结构的概念、时间复杂度、算法设计、表的顺序存储结构、链式存储结构、栈的实现、队列的实现等。 数据结构的概念： * ...
"SCAU: 深入了解STL中的数据结构与例题
STL（Standard Template Library）是C++标准程序库的核心之一，它包含了丰富的数据结构和算法，为C++程序员提供了强大的工具，使得程序开发变得更加高效和便捷。STL提供了各种容器、迭代器和算法，可以方便地对数据...
scau 数据结构实验一 8580合并链表
qq_61974198的博客
03-20 384
Description 线性链表的基本操作如下： #include<stdio.h> #include<malloc.h> #define ERROR 0 #define OK 1 #define ElemType int typedef int Status; typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; Status ListInsert_L(L..
8576 顺序线性 表的基本操作
06-04
8576 顺序线性 表的基本操作
SCAU OJ 实验三（堂上习题）
weixin_50862344的博客
01-29 976
SCAU OJ 实验三（堂上习题） 写在前面的话：大部分像我一样的都是第一次接触c语言，对于oj的一些题目觉得困难是非常非常正常的，所以参考和借鉴是不可避免的。但是呢，希望你们不只是完完全全地copy。原因有两点：①最后的期末考试基本上是这些题目，每一道题到最后考试时都是要自己独立完成的。②copy你还有理了!!!(过来挨打！！！ 下面是我觉得比较有效率的“借鉴”步骤： ①自己要先***独立思考***，能自己解决的问题尽量自己解决 ②实在是解决不了的或确确实实是没有思路的，就去网上找到对应题目，先理解思路，
SCAU 算法设计与分析 OJ复习
Maoxim的博客
12-14 2203
8594 有重复元素的排列问题（优先做） 时间限制:1000MS 代码长度限制:10KB 提交次数:1610 通过次数:656 题型: 编程题 语言: G++;GCC;VC;JAVA Description 设集合R={r1,r2,…,rn}是要进行排列的n个元素，其中r1,r2,…,rn可能相同。 试着设计一个算法，列出R的所有不同排列。 即，给定n以及待排的n个可能重复的元素。计算输出n个元素的所有不同排列。 输入格式 第1行是元素个数n，1<=n<=15。接下来的1行是待排列的n个元
scau_oj 10310 Valentine's Day （最大生成树、bfs）
程序人生
01-19 955
  10310 Valentine's Day 该题有题解 时间限制:1000MS 内存限制:65535K 提交次数:92 通过次数:27 题型: 编程题 语言: 无限制 Description February 14th every year is the Western Valentine's Day. Valentine's Day is called “qingrenji...
zoj 3278 & scau_oj 10273 8G Island （二分）
程序人生
01-18 1328
题意： 两个数组，元素个数分别为n和m。两两相乘可得n*m个数，求第k大的数。   思路： 本渣是听了别人二分的想法后才写出的。 两数组皆 非升序 排序。   首先，二分枚举第k大的数可能是多少。 假设当前枚举到mid，则计算大于等于mid的数有多少个。设之为tmp个。 若tmp &gt; k，说明 第k大的数比mid大 若tmp &lt; k，说明 第k大的数比mid小 若...
SCAU OJ 9715 相邻最大矩形面积
zhang434的专栏
03-31 2651
描述： 在X轴上水平放置着 N 个条形图，这 N 个条形图就组成了一个柱状图，每个条形图都是一个矩形，每个矩形都有相同的宽度，均为1单位长度，但是它们的高度并不相同。 例如下图，图1包含的矩形的高分别为2，1，4，5，1，3，3 单位长度，矩形的宽为1单位长度。 9715 相邻最大矩形面积 你的任务就是计算柱状图中以X轴为底边的最大矩形的面积。图2阴影部分就是上述例子的最大矩形面
scau oj 高精度加法
Electric_W的博客
11-06 520
1046计算高精度加法 时间限制:1000MS 代码长度限制:10KB 提交次数:4771 通过次数:1813 题型: 编程题语言: G++;GCC Description 由键盘输入两个位数很长的整数（一行一个，最多不超过80位），试计算并输出这两个数的和。 输入样例 1234567890123456789353534532453453453434534 987654321098765324534534534534532 输出样例 123...
SCAU_BestOj 训练实录
purple_bro的博客
07-05 451
戳戳_(:з)∠)_
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zero_019

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值