SCAU程序设计在线实训平台_实验_数据结构_实验1

最新推荐文章于 2023-06-08 16:41:19 发布
最新推荐文章于 2023-06-08 16:41:19 发布
阅读量3.1k 收藏 39
点赞数 8
分类专栏： SCAU SCAU数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23211951/article/details/115086249
版权

8576 顺序线性表的基本操作

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)
{
	L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));\
	L.listsize=LIST_INIT_SIZE;
    L.length=0;
    return 1;
}

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 0;
	for(int j=L.length-1;j>=i-1;j--)
	{
		L.elem[j+1]=L.elem[j];
	}
	L.elem[i-1]=e;
	L.length++;
	return 1;
}

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 0;
	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 1;

}

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)) 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)) 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;
		}
	}
}

8577 合并顺序表

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<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)
{
	L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));\
	L.listsize=LIST_INIT_SIZE;
    L.length=0;
    return 1;
}

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 0;
	for(int j=L.length-1;j>=i-1;j--)
	{
		L.elem[j+1]=L.elem[j];
	}
	L.elem[i-1]=e;
	L.length++;
	return 1;
}

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 0;
	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 1;

}

int main()
{
	SqList A,B,C;
	int a_len,b_len;
	ElemType x;
	InitList_Sq(A);
	InitList_Sq(B);
	InitList_Sq(C);   
	
	//A
	scanf("%d",&a_len);
	for(int i=1;i<=a_len;i++){
		scanf("%d",&x);
		ListInsert_Sq(A,i,x);
	}
	printf("List A:");
	Load_Sq(A);
	
	//B
	scanf("%d",&b_len);
	for(int i=1;i<=b_len;i++){
		scanf("%d",&x);
		ListInsert_Sq(B,i,x);
	}
	printf("List B:");
	Load_Sq(B);
	
	int ap=0,bp=0,cp=1,last=0;
	while(ap<A.length&&bp<B.length)
	{
		if(A.elem[ap]>=B.elem[bp]){
			ListInsert_Sq(C,cp++,B.elem[bp++]);
		}
		else{
			ListInsert_Sq(C,cp++,A.elem[ap++]);
		}
		
	}
	//剩余部分处理 
	while(ap<A.length){
		ListInsert_Sq(C,cp++,A.elem[ap++]);
	}
	while(bp<B.length){
		ListInsert_Sq(C,cp++,B.elem[bp++]);
	}
	printf("List C:");
	Load_Sq(C);
}

8578 顺序表逆置

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>
#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

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 main()
{
	SqList A,B;
	int a_len;
	ElemType x;
	InitList_Sq(A);
	InitList_Sq(B); 
	
	//A
	scanf("%d",&a_len);
	for(int i=1;i<=a_len;i++){
		scanf("%d",&x);
		ListInsert_Sq(A,i,x);
	}
	printf("The List is:");
	Load_Sq(A);
	int ap=A.length;
	while(ap>=0)
	{
		ListInsert_Sq(B,A.length-ap,A.elem[ap]);
		ap--;
	}
	printf("The turned List is:");
	Load_Sq(B);

}

8579 链式线性表的基本操作

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 = new LNode;
  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 node,pre;
    int i;
    ElemType e;
    L = new LNode;
    L->next = NULL;              // 先建立一个带头结点的单链表
    pre = L;
    for (i=0; i<n; i++) {
        scanf("%d", &e);
        node = new LNode;  // 生成新结点
        node->data=e;
        node->next=NULL;
        pre->next=node;
        pre=node;
        // 请补全代码
    }
    return OK;
}

int LoadLink_L(LinkList &L){
// 单链表遍历
    LinkList p = L->next;
    if(p==NULL)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 node = L,newp;
    int j=1;
    while(node && j< i){
        node=node->next;
        j++;
    }
    if(node==NULL)return ERROR;
    newp= new LNode;
    newp->data=e;
    newp->next=node->next;
    node->next=newp;
    return OK;
// 请补全代码

}

int LinkDelete_L(LinkList &L,int i, ElemType &e){
// 算法2.10
// 在带头结点的单链线性表L中，删除第i个元素，并用e返回其值
    LinkList p = L,pre;
    int j=1;
    while(p&&j<=i){
        pre=p;
        p=p->next;
        j++;
    }
    if(p==NULL)return ERROR;
    e=p->data;
    pre->next=p->next;
    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)) 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)) 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 合并链表

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(LinkList &L, int i, ElemType e) {  // 算法2.9
  // 在带头结点的单链线性表L的第i个元素之前插入元素e
  LinkList p,s;
  p = L;   
  int j = 0;
  while (p && j < i-1) {  // 寻找第i-1个结点
    p = p->next;
    ++j;
  } 
  if (!p || j > i-1) return ERROR;      // i小于1或者大于表长
  s = (LinkList)malloc(sizeof(LNode));  // 生成新结点
  s->data = e;  s->next = p->next;      // 插入L中
  p->next = s;
  return OK;
} // LinstInsert_L

Status ListDelete_L(LinkList &L, int i, ElemType &e) {  // 算法2.10
  // 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
  LinkList p,q;
  p = L;
  int j = 0;
  while (p->next && j < i-1) {  // 寻找第i个结点，并令p指向其前趋
    p = p->next;
    ++j;
  }
  if (!(p->next) || j > i-1) return ERROR;  // 删除位置不合理
  q = p->next;
  p->next = q->next;           // 删除并释放结点
  e = q->data;
  free(q);
  return OK;
} // ListDelete_L

设计一个算法将两个非递减有序链表A和B合并成一个新的非递减有序链表C。

输入格式

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

输出格式

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

输入样例

6
12 24 45 62 84 96
4
15 31 75 86

输出样例

List A:12 24 45 62 84 96
List B:15 31 75 86
List C:12 15 24 31 45 62 75 84 86 96

代码实现
#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 node,pre;
    int i;
    ElemType e;
    L = new LNode;
    L->next = NULL;              // 先建立一个带头结点的单链表
    pre = L;
    for (i=0; i<n; i++) {
        scanf("%d", &e);
        node = new LNode;  // 生成新结点
        node->data=e;
        node->next=NULL;
        pre->next=node;
        pre=node;
        // 请补全代码
    }
    return OK;
}

int LoadLink_L(LinkList &L){
// 单链表遍历
    LinkList p = L->next;
    if(p==NULL)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 CreateEmpLink_L(LinkList &L,int n){
// 创建含有n个元素的单链表
    LinkList node,pre;
    int i;
    ElemType e;
    L = new LNode;
    L->next = NULL;              // 先建立一个带头结点的单链表
    pre = L;
    for (i=0; i<n; i++) {
        node = new LNode;  // 生成新结点
        node->data=0;
        node->next=NULL;
        pre->next=node;
        pre=node;
    }
    return OK;
}

int LinkSort_L(LinkList &X,LinkList &Y,LinkList &C){
// 算法2.10
// 在带头结点的单链线性表L中，删除第i个元素，并用e返回其值
    LinkList pa = X->next,pb=Y->next,p=C->next;
    while(pa!=NULL&&pb!=NULL){
        if(pa->data>pb->data){
            p->data=pb->data;
            pb=pb->next;
            p=p->next;
        }else{
            p->data=pa->data;
            pa=pa->next;
            p=p->next;
        }
    }
    while(pb!=NULL) {
        p->data = pb->data;
        pb = pb->next;
        p = p->next;
    }
    while(pa!=NULL) {
        p->data = pa->data;
        pa = pa->next;
        p = p->next;
    }
    return OK;
// 请补全代码
}

int main()
{
    LinkList A,B,C;
    int a_len,b_len;
    //ElemType x, e;
    scanf("%d",&a_len);
    CreateLink_L(A,a_len);
    printf("List A:");
    LoadLink_L(A);

    scanf("%d",&b_len);
    CreateLink_L(B,b_len);
    printf("List B:");
    LoadLink_L(B);

    CreateEmpLink_L(C,a_len+b_len);
    LinkSort_L(A,B,C);
    printf("List C:");
    LoadLink_L(C);
}

8581 线性链表逆置

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(LinkList &L, int i, ElemType e) {  // 算法2.9
  // 在带头结点的单链线性表L的第i个元素之前插入元素e
  LinkList p,s;
  p = L;   
  int j = 0;
  while (p && j < i-1) {  // 寻找第i-1个结点
    p = p->next;
    ++j;
  } 
  if (!p || j > i-1) return ERROR;      // i小于1或者大于表长
  s = (LinkList)malloc(sizeof(LNode));  // 生成新结点
  s->data = e;  s->next = p->next;      // 插入L中
  p->next = s;
  return OK;
} // LinstInsert_L

Status ListDelete_L(LinkList &L, int i, ElemType &e) {  // 算法2.10
  // 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
  LinkList p,q;
  p = L;
  int j = 0;
  while (p->next && j < i-1) {  // 寻找第i个结点，并令p指向其前趋
    p = p->next;
    ++j;
  }
  if (!(p->next) || j > i-1) return ERROR;  // 删除位置不合理
  q = p->next;
  p->next = q->next;           // 删除并释放结点
  e = q->data;
  free(q);
  return OK;
} // ListDelete_L

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

输入格式

第一行：输入n，表示单链表的元素个数
第二行：输入单链表的各元素，用空格分开

输出格式

第一行：输出单链表逆置前的元素列表
第二行：输出单链表逆置后的元素列表

输入样例

8
32 97 54 65 35 84 61 75

输出样例

The List is:32 97 54 65 35 84 61 75
The turned List is:75 61 84 35 65 54 97 32

代码实现
#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 node,pre;
    int i;
    ElemType e;
    L = new LNode;
    L->next = NULL;              // 先建立一个带头结点的单链表
    pre = L;
    for (i=0; i<n; i++) {
        scanf("%d", &e);
        node = new LNode;  // 生成新结点
        node->data=e;
        node->next=NULL;
        pre->next=node;
        pre=node;
        // 请补全代码
    }
    return OK;
}

int LoadLink_L(LinkList &L){
// 单链表遍历
    LinkList p = L->next;
    if(p==NULL)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 LinkSwitch_L(LinkList &X){
// 算法2.10
// 在带头结点的单链线性表L中，删除第i个元素，并用e返回其值
    LinkList head=X,pre = NULL,node=X->next,after=X->next;

    while(after!=NULL){
        after=after->next;
        node->next=pre;
        pre=node;
        node=after;
        //after=after->next;
    }
    X->next=pre;

    return OK;
// 请补全代码
}

int main()
{
    LinkList A;
    int a_len;
    //ElemType x, e;
    scanf("%d",&a_len);
    CreateLink_L(A,a_len);
    printf("The List is:");
    LoadLink_L(A);
    LinkSwitch_L(A);
    printf("The turned List is:");
    LoadLink_L(A);



}

-END-

YelloooBlue
关注
  • 8
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
顺序表逆置
pipi_lovelygirl的博客
04-01 1311
速度慢到怀疑人生，在数组下标那里纠结很久 上题目巴拉巴拉，变变变 顺序表的基本操作代码如下： #include<stdio.h> #include<malloc.h> #define OK 1 #define ERROR 0 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int ty...
SCAU数据结构实训实验1
2301_80011650的博客
06-08 168
【代码】SCAU数据结构实训实验1。
8580 合并链表
Hunter_Kevin的博客
06-11 502
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(LinkList &L, int
scau数据结构实验
weixin_73094970的博客
06-08 5826
scau 数据结构实验
2021SCAU数据结构复习(实验1-实验3)
weixin_50340097的博客
06-02 4257
题1:8576 顺序线性表的基本操作 题目描述 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 typed
高级程序语言设计.期末综合性实验.rar
07-15
SCAU的高级程序语言设计，期末综合性实验。 题目是：文件操作与字符处理 资源是一个rar文件，因为里面有两个文件的，用WIN.rar解压了就好。 包括： 实验程序（运行程序，用DEV写的） 综合性实验报告（根据上面的代码...
scau.rar_scau\_培训微信_天气预报 _豆瓣电影_豆瓣电影推荐
09-23
【标题】"scau.rar_scau\_培训微信_天气预报 _豆瓣电影_豆瓣电影推荐" 提供的信息表明，这是一个与华南农业大学（Scau）相关的项目，重点涉及微信小程序的开发，特别是实现了天气预报功能和豆瓣电影推荐功能。...
scau归并排序 SCAU数据结构年期末复习
07-05
本资源摘要信息涵盖了SCAU数据结构年期末复习的主要知识点，包括数据结构的概念、时间复杂度、算法设计、表的顺序存储结构、链式存储结构、栈的实现、队列的实现等。 数据结构的概念： * 数据元素是数据的基本单位...
SCAU数电实验：自动售饮料机.rar
07-15
在SCAU（华南农业大学）的数字逻辑与电路设计课程中，学生们会遇到一项具有挑战性的期末综合性实验——设计并实现一个自动售饮料机。这个实验旨在检验学生对数字逻辑、电路设计以及相关软件应用的掌握程度，同时培养...
SCAU-YX-003_词汇表1
08-08
1. **DCI**：Data Continuity Interface，由康赛公司开发的数据继承平台系统，用于该项目作为支撑平台。 2. **安全性**：指的是系统保护数据免受未经授权访问或破坏的能力。 3. **班级注册**：指院系根据学生信息...
数据结构#include
01-05
#include #include #define ok 1 #define error 0 #define overflow -1 #define LIST_INIT_SIZE typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; #include #include #define ok 1 #define error 0 #define overflow -1 #define LIST_INIT_SIZE typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList;
SCAU程序设计在线实训平台_实验_数据结构_实验7
YelloooBlue's Blog
06-12 975
8647 实现图的存储结构【有手就行】 Description 实现有向图的邻接矩阵存储结构。 输入格式 第一行：输入图的顶点个数n（各个顶点的默认编号为1~n）， 边的条数m。 第二 ~ m+1行：每行输入两个顶点编号i、j，表示连接顶点i到顶点j的一条边。 输出格式 分n行输出n*n的邻接矩阵，表示所输入的图存储，顶点i和顶点j之间如果有边相连，则输出1，没边相连则输出0。 输入样例 4 4 1 2 1 3 3 4 4 1 输出样例 0 1 1 0 0 0 0 0 0 0 0 1 1
《数据结构》在线课程使用指南
m0_69745974的博客
05-04 1145
(一)思路： (二)成绩组成建议 六、提供服务 PTA平台注册 《数据结构》在线课程使用指南(2020) ==================== 一、简介 课程覆盖“绪论、线性表与队列、字符串、数组与广义表，树与二叉树、图、查找、排序”等几个章节。 开课平台为超星(学银在线)，学校与老师可以使用方式有：SPOC与MOOC。 课程链接：[https://www.xueyinonline.com/detail/214864236](() PTA在线平台：[https://pint..
SCAU程序设计在线实训平台_实验_数据结构_复习【技巧以及值得看】
YelloooBlue's Blog
06-18 1645
8591 计算next值 void get_next(SString T, int next[]) { next[1] = 0; int i = 1, j = 0; while (i < T[0]) { if (T[i] == T[j] || j == 0) //j=0时说明发生失配，从头开始，此时无论能匹配多少位，next[i]最少都为1 next[++i] = ++j;//如果相等，则同时进位 else j = nex
插入排序
qq_37560166的博客
09-12 70
void InsertSort(int* arr,int n) { int i, j; int tmp = 0; for (i = 1; i < n; i++) { tmp = arr[i]; j = i - 1; while (tmp < arr[j] && j >=0 ) { arr[j + 1] = arr[j]; j--...
C语言 数据结构 实验一 【自用】
LangYueMoon的博客
01-26 1135
C语言 数据结构 实验一 8576 - 顺序线性表的基本操作 #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...
数据结构 合并顺序表
weixin_46101782的博客
03-19 601
Description 若线性表中数据元素相互之间可以比较，且数据元素在表中按值递增或递减，则称该表为有序表。 编写算法，将两个非递减有序顺序表A和B合并成一个新的非递减有序顺序表C。 #include <stdio.h> #include <stdlib.h> #include<malloc.h> #define OK 1 #define ERROR 0 #define LIST_INIT_SIZE 100 #define ElemType int typedef i
数据结构线性表（1）
dbdjdjdkd的博客
07-22 104
线性表操作 1.建立顺序表 int sqlist[maxsize]; int length; int createlist(int sqlist[],int &length) { cin>>length; if(length>maxsize) return 0; for(i=0;i<length;i++) cin>>sqlist[i] return 1; } 1.1在顺序表p的位置插入元素e int sqlist[maxsize]={1,2,3,
SCAU OJ 数据结构 综合性实验
最新发布
06-11
SCAU OJ，全称为Shandong University of Architecture and Civil Engineering Online Judge，是中国山东建筑大学的在线编程竞赛平台。这个平台通常提供数据结构和算法相关的综合性实验题目，目的是帮助学生们提升编程技能，特别是对数据结构的理解和应用能力。 在SCAU OJ的综合性实验中，你会遇到各种复杂的数据结构问题，比如链表、树（如二叉搜索树、AVL树、红黑树等）、图、堆、队列、栈、哈希表、并查集、优先队列等。这些题目可能涉及基本操作（如查找、插入、删除），也可能包含高级数据结构的优化问题，或者是结合多种数据结构的综合应用。 实验可能会包括但不限于以下几个方面： 1. **基础操作**：理解如何高效地实现基本的数据结构的操作，如动态数组扩容、链表节点管理等。 2. **高级数据结构**：掌握如何设计和实现高级数据结构，如使用二分查找优化查找时间，或使用平衡树保证插入和删除的性能。 3. **算法与数据结构结合**：将特定算法（如排序、搜索）与数据结构相结合，解决实际问题。 4. **空间效率与时间复杂度**：关注内存管理，理解不同数据结构的空间效率，并分析算法的时间复杂度。 5. **递归和分治**：通过数据结构实现递归或分治算法，解决复杂问题。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值