标签：return 占用 i++ break sizeof desc 基本 switch bsp
时间限制:1000MS 内存限制:1000K
提交次数:9027 通过次数:2456
题型: 编程题 语言: G++;GCC
编写算法，创建初始化容量为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 #include<stdio.h> 2 #include<malloc.h> 3 #define OK 1 4 #define ERROR 0 5 #define LIST_INIT_SIZE 100 6 #define LISTINCREMENT 10 7 #define ElemType int 8 9 typedef struct 10 { 11 int *elem; 12 int length; 13 int listsize; 14 }SqList; 15 16 int InitList_Sq(SqList &L) 17 { 18 L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); 19 if(!L.elem) return 0; 20 L.length=0; 21 L.listsize=LIST_INIT_SIZE; 22 return OK; 23 24 } 25 26 int Load_Sq(SqList &L) 27 { 28 // 输出顺序表中的所有元素 29 int i; 30 if(L.length==0) printf("The List is empty!"); // 请填空 31 else 32 { 33 printf("The List is: "); 34 for(i=0;i<L.length;i++) printf("%d ",L.elem[i]); // 请填空 35 } 36 printf("\n"); 37 return OK; 38 } 39 40 int ListInsert_Sq(SqList &L,int i,int e) 41 { 42 43 // 算法2.4，在顺序线性表L中第i个位置之前插入新的元素e 44 // i的合法值为1≤i≤L.length +1 45 // 请补全代码 46 ElemType *q,*p,*newbase; 47 if(i<1||i>L.length+1) return ERROR; 48 if(L.length>L.listsize) 49 { 50 newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType)); 51 if(!L.elem) 52 return ERROR; 53 L.elem=newbase; 54 L.listsize+=LISTINCREMENT; 55 } 56 57 q=&(L.elem[i-1]); 58 for(p=&(L.elem[L.length-1]);p>=q;--p) 59 60 *(p+1)=*p; 61 *q=e; 62 ++L.length; 63 64 return OK; 65 66 } 67 68 int ListDelete_Sq(SqList &L,int i, int &e) 69 { 70 // 算法2.5,在顺序线性表L中删除第i个位置的元素，并用e返回其值 71 // i的合法值为1≤i≤L.length 72 // 请补全代码 73 ElemType *q,*p; 74 if(i<1||i>L.length) return ERROR; 75 p=&(L.elem[i-1]); 76 e=*p; 77 q=L.elem+L.length-1; 78 for(p++;p<=q;++p) 79 *(p-1)=*p; 80 --L.length; 81 return OK; 82 } 83 84 int main() 85 { 86 SqList T; 87 int a, i; 88 ElemType e, x; 89 if(InitList_Sq(T)) // 判断顺序表是否创建成功 90 { 91 printf("A Sequence List Has Created.\n"); 92 } 93 while(1) 94 { 95 printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n"); 96 scanf("%d",&a); 97 switch(a) 98 { 99 case 1: scanf("%d%d",&i,&x); 100 if(!ListInsert_Sq(T,i,x)) printf("Insert Error!\n"); // 判断i值是否合法，请填空 101 else printf("The Element %d is Successfully Inserted!\n",x); 102 break; 103 case 2: scanf("%d",&i); 104 if(!ListDelete_Sq(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法，请填空 105 else printf("The Element %d is Successfully Deleted!\n",e); 106 break; 107 case 3: Load_Sq(T); 108 break; 109 case 0: return 1; 110 } 111 } 112 }
时间限制:1000MS 内存限制:1000K
提交次数:5339 通过次数:2251
题型: 编程题 语言: G++;GCC
顺序表的基本操作代码如下：
#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和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
1 #include<stdio.h> 2 #include<malloc.h> 3 #define OK 1 4 #define ERROR 0 5 #define LIST_INIT_SIZE 100 6 #define LISTINCREMENT 10 7 #define ElemType int 8 9 typedef int Status; 10 typedef struct 11 { 12 int *elem; 13 int length; 14 int listsize; 15 }SqList; 16 17 Status InitList_Sq(SqList &L) 18 { // 算法2.3 19 // 构造一个空的线性表L。 20 L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType)); 21 if (!L.elem) return OK; // 存储分配失败 22 L.length = 0; // 空表长度为0 23 L.listsize = LIST_INIT_SIZE; // 初始存储容量 24 return OK; 25 } // InitList_Sq 26 int Load_Sq(SqList &L) 27 { 28 int i; 29 for(i=0;i<L.length;i++) 30 printf("%d ",L.elem[i]); 31 printf("\n"); 32 return 1; 33 } 34 int ListLength(SqList L) 35 { 36 return L.length; 37 } 38 int GetElem(SqList L,int i,ElemType &e) 39 { 40 e=L.elem[i-1]; 41 return OK; 42 } 43 Status ListInsert_Sq(SqList &L, int i, ElemType e) 44 { // 算法2.4 45 // 在顺序线性表L的第i个元素之前插入新的元素e， 46 // i的合法值为1≤i≤ListLength_Sq(L)+1 47 ElemType *p; 48 if (i < 1 || i > L.length+1) return ERROR; // i值不合法 49 if (L.length >= L.listsize) { // 当前存储空间已满，增加容量 50 ElemType *newbase = (ElemType *)realloc(L.elem, 51 (L.listsize+LISTINCREMENT)*sizeof (ElemType)); 52 if (!newbase) return ERROR; // 存储分配失败 53 L.elem = newbase; // 新基址 54 L.listsize += LISTINCREMENT; // 增加存储容量 55 } 56 ElemType *q = &(L.elem[i-1]); // q为插入位置 57 for (p = &(L.elem[L.length-1]); p>=q; --p) *(p+1) = *p; 58 // 插入位置及之后的元素右移 59 *q = e; // 插入e 60 ++L.length; // 表长增1 61 return OK; 62 } // ListInsert_Sq 63 64 Status ListDelete_Sq(SqList &L, int i, ElemType &e) 65 { // 算法2.5 66 // 在顺序线性表L中删除第i个元素，并用e返回其值。 67 // i的合法值为1≤i≤ListLength_Sq(L)。 68 ElemType *p, *q; 69 if (i<1 || i>L.length) return ERROR; // i值不合法 70 p = &(L.elem[i-1]); // p为被删除元素的位置 71 e = *p; // 被删除元素的值赋给e 72 q = L.elem+L.length-1; // 表尾元素的位置 73 for (++p; p<=q; ++p) *(p-1) = *p; // 被删除元素之后的元素左移 74 --L.length; // 表长减1 75 return OK; 76 } // ListDelete_Sq 77 78 79 void MergeList(SqList La,SqList Lb,SqList &Lc) 80 { 81 int i,j,k,La_len,Lb_len,ai,bj; 82 i=j=1; 83 k=0; 84 InitList_Sq(Lc); 85 La_len=ListLength(La); 86 Lb_len=ListLength(Lb); 87 while((i<=La_len)&&(j<=Lb_len)) 88 { GetElem(La,i,ai); 89 GetElem(Lb,j,bj); 90 if(ai<=bj) 91 { ListInsert_Sq(Lc,++k,ai); 92 i++; } 93 else 94 { ListInsert_Sq(Lc,++k,bj); j++; } } 95 while(i<=La_len) 96 { GetElem(La,i++,ai); 97 ListInsert_Sq(Lc,++k,ai); } 98 while(j<=Lb_len) 99 { GetElem(Lb,j++,bj); 100 ListInsert_Sq(Lc,++k,bj); } 101 Load_Sq(Lc); } 102 int main() 103 { int an,bn,i,e; 104 SqList La,Lb,Lc; 105 InitList_Sq(La); 106 scanf("%d",&an); 107 for(i=1;i<=an;i++) 108 { 109 scanf("%d",&e); 110 ListInsert_Sq(La,i,e); } 111 printf("List A:"); 112 Load_Sq(La); 113 InitList_Sq(Lb); 114 scanf("%d",&bn); 115 for(i=1;i<=an;i++) 116 { 117 scanf("%d",&e); 118 ListInsert_Sq(Lb,i,e); } 119 printf("List B:"); 120 Load_Sq(Lb); 121 printf("List C:"); 122 MergeList(La,Lb,Lc); 123 return 0; 124 }
时间限制:1000MS 内存限制:1000K
提交次数:3660 通过次数:2149
题型: 编程题 语言: G++;GCC
顺序表的基本操作代码如下：
#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
1 #include<stdio.h> 2 #include<malloc.h> 3 #define OK 1 4 #define ERROR 0 5 #define LIST_INIT_SIZE 100 6 #define LISTINCREMENT 10 7 #define ElemType int 8 9 typedef int Status; 10 typedef struct 11 { 12 int *elem; 13 int length; 14 int listsize; 15 }SqList; 16 17 Status InitList_Sq(SqList &L) 18 { // 算法2.3 19 // 构造一个空的线性表L。 20 L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType)); 21 if (!L.elem) return OK; // 存储分配失败 22 L.length = 0; // 空表长度为0 23 L.listsize = LIST_INIT_SIZE; // 初始存储容量 24 return OK; 25 } // InitList_Sq 26 27 Status ListInsert_Sq(SqList &L, int i, ElemType e) 28 { // 算法2.4 29 // 在顺序线性表L的第i个元素之前插入新的元素e， 30 // i的合法值为1≤i≤ListLength_Sq(L)+1 31 ElemType *p; 32 if (i < 1 || i > L.length+1) return ERROR; // i值不合法 33 if (L.length >= L.listsize) { // 当前存储空间已满，增加容量 34 ElemType *newbase = (ElemType *)realloc(L.elem, 35 (L.listsize+LISTINCREMENT)*sizeof (ElemType)); 36 if (!newbase) return ERROR; // 存储分配失败 37 L.elem = newbase; // 新基址 38 L.listsize += LISTINCREMENT; // 增加存储容量 39 } 40 ElemType *q = &(L.elem[i-1]); // q为插入位置 41 for (p = &(L.elem[L.length-1]); p>=q; --p) *(p+1) = *p; 42 // 插入位置及之后的元素右移 43 *q = e; // 插入e 44 ++L.length; // 表长增1 45 return OK; 46 } // ListInsert_Sq 47 48 Status ListDelete_Sq(SqList &L, int i, ElemType &e) 49 { // 算法2.5 50 // 在顺序线性表L中删除第i个元素，并用e返回其值。 51 // i的合法值为1≤i≤ListLength_Sq(L)。 52 ElemType *p, *q; 53 if (i<1 || i>L.length) return ERROR; // i值不合法 54 p = &(L.elem[i-1]); // p为被删除元素的位置 55 e = *p; // 被删除元素的值赋给e 56 q = L.elem+L.length-1; // 表尾元素的位置 57 for (++p; p<=q; ++p) *(p-1) = *p; // 被删除元素之后的元素左移 58 --L.length; // 表长减1 59 return OK; 60 } // ListDelete_Sq 61 int load(SqList &L) 62 { 63 int i; 64 for(i=0;i<L.length;i++) 65 { 66 printf("%d ",L.elem[i]); 67 } 68 printf("\n"); 69 return OK; 70 } 71 int load1(SqList &L) 72 { 73 int i; 74 for(i=L.length-1;i>=0;i--) 75 { 76 printf("%d ",L.elem[i]); 77 } 78 return OK; 79 } 80 int main() 81 { 82 SqList t; 83 InitList_Sq(t); 84 int i,a,b; 85 scanf("%d",&a); 86 for(i=1;i<=a;i++) 87 { 88 scanf("%d",&b); 89 ListInsert_Sq(t,i,b); 90 91 } 92 printf("The List is:"); 93 94 load(t); 95 printf("The turned List is:"); 96 load1(t); 97 }
时间限制:1000MS 内存限制:1000K
提交次数:5567 通过次数:2176
题型: 编程题 语言: G++;GCC
编写算法，创建一个含有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 = (LinkList)malloc(sizeof(LNode));
L->next = NULL; // 先建立一个带头结点的单链表
q = (LinkList)malloc(sizeof(LNode));
q = L;
for (i=0; i<n; i++) {
scanf("%d", &e);
p = (LinkList)malloc(sizeof(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:
1 #include<stdio.h> 2 #include<malloc.h> 3 #define ERROR 0 4 #define OK 1 5 #define ElemType int 6 7 typedef struct LNode 8 { 9 int data; 10 struct LNode *next; 11 }LNode,*LinkList; 12 13 int CreateLink_L(LinkList &L,int n){ 14 // 创建含有n个元素的单链表 15 LinkList p,q; 16 int i; 17 ElemType e; 18 L = (LinkList)malloc(sizeof(LNode)); 19 L->next = NULL; // 先建立一个带头结点的单链表 20 q = (LinkList)malloc(sizeof(LNode)); 21 q = L; 22 for (i=0; i<n; i++) { 23 scanf("%d", &e); 24 p = (LinkList)malloc(sizeof(LNode)); // 生成新结点 25 p->data=e; 26 p->next=q->next; 27 q->next=p; 28 q=q->next; 29 30 } 31 return OK; 32 } 33 34 int LoadLink_L(LinkList &L){ 35 // 单链表遍历 36 LinkList p = L->next; 37 if(!p)printf("The List is empty!"); // 请填空 38 else 39 { 40 printf("The LinkList is:"); 41 while(p) // 请填空 42 { 43 printf("%d ",p->data); 44 p=p->next; // 请填空 45 } 46 } 47 printf("\n"); 48 return OK; 49 } 50 51 int LinkInsert_L(LinkList &L,int i,ElemType e) 52 { 53 // 算法2.9 54 // 在带头结点的单链线性表L中第i个位置之前插入元素e 55 // 请补全代码 56 LinkList p=L,s;int j=0; 57 while(p&&j<i-1) 58 { 59 p=p->next; 60 j++; 61 } 62 if(!p||j>i-1) 63 return ERROR; 64 s=(LinkList)malloc(sizeof(LNode)); 65 s->data=e;s->next=p->next; 66 p->next=s; 67 return OK; 68 69 70 71 } 72 73 int LinkDelete_L(LinkList &L,int i, ElemType &e){ 74 // 算法2.10 75 // 在带头结点的单链线性表L中，删除第i个元素，并用e返回其值 76 // 请补全代码 77 LinkList p=L,q; 78 int j=0; 79 while(p->next&&j<i-1) 80 { 81 p=p->next; 82 ++j; 83 } 84 if(!(p->next)||j>i-1) 85 return ERROR; 86 q=p->next; 87 p->next=q->next; 88 e=q->data;free(q); 89 return OK; 90 91 } 92 93 int main() 94 { 95 LinkList T; 96 int a,n,i; 97 ElemType x, e; 98 printf("Please input the init size of the linklist:\n"); 99 scanf("%d",&n); 100 printf("Please input the %d element of the linklist:\n", n); 101 if(CreateLink_L(T,n)) // 判断链表是否创建成功，请填空 102 { 103 printf("A Link List Has Created.\n"); 104 LoadLink_L(T); 105 } 106 while(1) 107 { 108 printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n"); 109 scanf("%d",&a); 110 switch(a) 111 { 112 case 1: scanf("%d%d",&i,&x); 113 if(!LinkInsert_L(T,i,x)) printf("Insert Error!\n"); // 判断i值是否合法，请填空 114 else printf("The Element %d is Successfully Inserted!\n", x); 115 break; 116 case 2: scanf("%d",&i); 117 if(!LinkDelete_L(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法，请填空 118 else printf("The Element %d is Successfully Deleted!\n", e); 119 break; 120 case 3: LoadLink_L(T); 121 break; 122 case 0: return 1; 123 } 124 } 125 }
时间限制:1000MS 内存限制:1000K
提交次数:3724 通过次数:2077
题型: 编程题 语言: G++;GCC
线性链表的基本操作如下：
#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
1 #include<stdio.h> 2 #include<malloc.h> 3 #define ERROR 0 4 #define OK 1 5 #define ElemType int 6 7 typedef int Status; 8 typedef struct LNode 9 { 10 int data; 11 struct LNode *next; 12 }LNode,*LinkList; 13 14 15 Status ListInsert_L(LinkList &L, int i, ElemType e) { // 算法2.9 16 // 在带头结点的单链线性表L的第i个元素之前插入元素e 17 LinkList p,s; 18 p = L; 19 int j = 0; 20 while (p && j < i-1) { // 寻找第i-1个结点 21 p = p->next; 22 ++j; 23 } 24 if (!p || j > i-1) return ERROR; // i小于1或者大于表长 25 s = (LinkList)malloc(sizeof(LNode)); // 生成新结点 26 s->data = e; s->next = p->next; // 插入L中 27 p->next = s; 28 return OK; 29 } // LinstInsert_L 30 31 Status ListDelete_L(LinkList &L, int i, ElemType &e) { // 算法2.10 32 // 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值 33 LinkList p,q; 34 p = L; 35 int j = 0; 36 while (p->next && j < i-1) { // 寻找第i个结点，并令p指向其前趋 37 p = p->next; 38 ++j; 39 } 40 if (!(p->next) || j > i-1) return ERROR; // 删除位置不合理 41 q = p->next; 42 p->next = q->next; // 删除并释放结点 43 e = q->data; 44 free(q); 45 return OK; 46 } // ListDelete_L 47 int LoadLink_L(LinkList &L){ 48 // 单链表遍历 49 LinkList p = L->next; 50 // 请填空 51 52 53 while(p!=NULL) // 请填空 54 { 55 printf("%d ",p->data); 56 p=p->next; // 请填空 57 } 58 59 printf("\n"); 60 return OK; 61 } 62 int CreateLink_L(LinkList &L,int n){ 63 // 创建含有n个元素的单链表 64 LinkList p,q; 65 int i; 66 ElemType e; 67 L = (LinkList)malloc(sizeof(LNode)); 68 L->next = NULL; // 先建立一个带头结点的单链表 69 q = (LinkList)malloc(sizeof(LNode)); 70 q = L; 71 for (i=0; i<n; i++) { 72 scanf("%d", &e); 73 p = (LinkList)malloc(sizeof(LNode)); // 生成新结点 74 p->data=e; 75 p->next=q->next; 76 q->next=p; 77 q=q->next; 78 79 } 80 return OK; 81 } 82 83 void mer(LinkList &La,LinkList &Lb,LinkList &Lc) 84 { 85 LinkList pa=La->next,pb=Lb->next,pc; 86 pc=La; 87 Lc=pc; 88 while(pa&&pb) 89 { 90 if(pa->data<=pb->data) 91 { 92 pc->next=pa;pc=pa;pa=pa->next; 93 94 } 95 else 96 { 97 pc->next=pb; 98 pc=pb; 99 pb=pb->next; 100 } 101 } 102 pc->next=pa?pa:pb; 103 free(Lb); 104 105 } 106 int main() 107 { 108 int a,b,c,d,n; 109 LinkList pa,pb,pc; 110 scanf("%d",&a); 111 CreateLink_L(pa,a); 112 113 printf("List A:"); 114 LoadLink_L(pa); 115 scanf("%d",&d); 116 CreateLink_L(pb,d); 117 118 printf("List B:"); 119 LoadLink_L(pb); 120 printf("List C:"); 121 mer(pa,pb,pc); 122 LoadLink_L(pc); 123 124 }
8581 线性链表逆置时间限制:1000MS 内存限制:1000K 题型: 编程题 语言: G++;GCC
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 |
1 #include<stdio.h> 2 #include<malloc.h> 3 #define ERROR 0 4 #define OK 1 5 #define ElemType int 6 7 typedef int Status; 8 typedef struct LNode 9 { 10 int data; 11 struct LNode *next; 12 }LNode,*LinkList; 13 14 15 Status ListInsert_L(LinkList &L, int i, ElemType e) { // 算法2.9 16 // 在带头结点的单链线性表L的第i个元素之前插入元素e 17 LinkList p,s; 18 p = L; 19 int j = 0; 20 while (p && j < i-1) { // 寻找第i-1个结点 21 p = p->next; 22 ++j; 23 } 24 if (!p || j > i-1) return ERROR; // i小于1或者大于表长 25 s = (LinkList)malloc(sizeof(LNode)); // 生成新结点 26 s->data = e; s->next = p->next; // 插入L中 27 p->next = s; 28 return OK; 29 } // LinstInsert_L 30 31 Status ListDelete_L(LinkList &L, int i, ElemType &e) { // 算法2.10 32 // 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值 33 LinkList p,q; 34 p = L; 35 int j = 0; 36 while (p->next && j < i-1) { // 寻找第i个结点，并令p指向其前趋 37 p = p->next; 38 ++j; 39 } 40 if (!(p->next) || j > i-1) return ERROR; // 删除位置不合理 41 q = p->next; 42 p->next = q->next; // 删除并释放结点 43 e = q->data; 44 free(q); 45 return OK; 46 } // ListDelete_L 47 int CreateLink_L(LinkList &L,int n){ 48 // 创建含有n个元素的单链表 49 LinkList p,q; 50 int i; 51 ElemType e; 52 L = (LinkList)malloc(sizeof(LNode)); 53 L->next = NULL; // 先建立一个带头结点的单链表 54 q = (LinkList)malloc(sizeof(LNode)); 55 q = L; 56 for (i=0; i<n; i++) { 57 scanf("%d", &e); 58 p = (LinkList)malloc(sizeof(LNode)); // 生成新结点 59 p->data=e; 60 p->next=q->next; 61 q->next=p; 62 q=q->next; 63 64 } 65 return OK; 66 } 67 LinkList ListReverse(LinkList &L) 68 { 69 LinkList current,p; 70 71 if (L == NULL) 72 { 73 return NULL; 74 } 75 current = L->next; 76 while (current->next != NULL) 77 { 78 p = current->next; 79 current->next = p->next; 80 p->next = L->next; 81 L->next = p; 82 83 } 84 return L; 85 } 86 void load(LinkList &L) 87 { 88 LinkList p=L->next; 89 while(p) 90 { 91 printf("%d ",p->data); 92 p=p->next; 93 } 94 } 95 int main() 96 97 { 98 LinkList L; 99 int n; 100 scanf("%d",&n); 101 CreateLink_L(L,n); 102 printf("The List is:"); 103 load(L); 104 printf("\n"); 105 printf("The turned List is:"); 106 ListReverse(L); 107 load(L); 108 109 110 }
|
标签：return 占用 i++ break sizeof desc 基本 switch bsp
原文地址：https://www.cnblogs.com/guguchen/p/9281411.html
