华南农业大学数据结构上机考试

8576 顺序线性表的基本操作

时间限制:1000MS  内存限制:1000K
提交次数: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 #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 }

8577 合并顺序表

时间限制:1000MS  内存限制:1000K
提交次数:5339 通过次数:2251

题型: 编程题   语言: 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和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 }

8578 顺序表逆置

时间限制:1000MS  内存限制:1000K
提交次数: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
 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 }

8579 链式线性表的基本操作

时间限制:1000MS  内存限制:1000K
提交次数: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 = (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 }

8580 合并链表

时间限制:1000MS  内存限制:1000K
提交次数:3724 通过次数:2077

题型: 编程题   语言: 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和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
提交次数:2811 通过次数:2032

题型: 编程题   语言: 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 }

原文地址：https://www.cnblogs.com/guguchen/p/9281411.html

时间： 2024-10-29 13:27:54

华南农业大学数据结构上机考试的相关文章

2015数据结构上机考试题解

#include<cstdio> #define inf 0x3f3f3f3f const int maxn=10000; using namespace std; int n,m,q; int a[maxn+10]; int bs(int x){ int l=0,r=n-1; while(l<=r){ int mid=(l+r)>>1; if(a[mid]==x) return 1; else if(a[mid]>x) r=mid-1; else l=mid+1; }

数据结构上机考试（楷神版）

插入排序 #include<cstdio> using namespace std; const int maxn = 1111; int array1[maxn]; int array2[maxn]; //1 2 4 7 -1 void insert(int v){ for(int i = 0;i <= v; i++){ if(i == v){ //如果需要插入到最后一个位置 array2[i] = array1[v]; return; } if(array2[i] > arra

石家庄XX大学2017年java基础上机考试

石家庄XX大学 2017 年秋季 2016 级本科班期末上机考试试卷(A) 课程名称: JAVA 语言程序设计 任课教师: XXX考试时间: 150 分钟 学号: 姓名: 班级: 考试性质(学生填写):正常考试( )缓考( )补考( )重修( )提前修读( ) 题 号 一 二 三 四 五 六 七 总分 满 分 10 40 50 得 分 阅卷人 试卷说明: 一. 本试卷为 2016 级 JAVA 语言程序设计上机考试试卷: 二. 注意编程规范: (4 分) (1) 通过 Eclipse 添加类的方

数据结构上机测试2-1:单链表操作A (顺序建表+关键字删除)

数据结构上机测试2-1:单链表操作A Time Limit: 1000MS Memory limit: 4096K 题目描述 输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,将单链表中的值为m的结点全部删除.分别输出建立的初始单链表和完成删除后的单链表. 输入 第一行输入数据个数n: 第二行依次输入n个整数: 第三行输入欲删除数据m. 输出 第一行输出原始单链表的长度: 第二行依次输出原始单链表的数据: 第三行输出完成删除后的单链表长度: 第四行依次输出完成删除后的

HDU 1234 （浙大计算机研究生复试上机考试-2005年） 开门人和关门人 （水）

开门人和关门人 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 11133    Accepted Submission(s): 5667 Problem Description 每天第一个到机房的人要把门打开,最后一个离开的人要把门关好.现有一堆杂乱的机房签 到.签离记录,请根据记录找出当天开门和关门的人. Input 测试输入的第一

hdu 4416 水题 浙大计算机研究生复试上机考试-2005年 可是发现自己写代码有问题

Spring3与Hibernate4整合时出现了nested exception is java.lang.NoClassDefFoundError: Lorg/hibernate/cache/CacheProvider. hibernate3的时候,用spring来控制sessionfactory用的可以是org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean,因为用的是hibernate4所以照猫画

数据结构技能考试系统

通过一个月的努力,终于把数据结构技能考试系统用C++的语言实现(其中有C语言的穿插),系统的最大优点是可以检测学生答题时是否插入了U盘,打开了word及记事本等辅助工具.此系统分为两部分,一部分是学生端,一部分是教师端. 学生端主要是学生输入学号及姓名(对此进行检测),根据学号的后四位对应的ASCII码模8求值,达到抽题的效果(也可适当改进改为IP读题),在题库中抽取两道题,随机答一道题即可,在完成作答后选择所作的试题,避免了选题后不会做的情况.抽题时显示倒计时,时间为60分钟,如若超时,允许的

java web程序 上机考试登陆界面设计实现

今天是java web上机.做一个登陆注册的界面.要求:jsp.mysql数据库,js做一个美观的界面.功能.可以添加 更多啊.我做的界面被老师狠狠的扣了分.问题在于.当用户没有输入任何信息(没有输入用户名和密码)就直接提交的 时候,页面显示500错误,这里改正的方案2点.我是这么想的.1.要么是提交时弹出一个对话框.显示用户名和密码为空!.这里 要注意的是,弹出的对话框不能阻止用户输入信息,弹出后,依然让用户输入.2.要么是提交按钮后依然跳转到本页面.因为一个form表单 只能跳转到一个页面,

java web程序 上机考试做一个登陆注册程序

大二期末 java web.用到数据库,jdbc.myeclipse实现用户的注册,登陆 并且不能出现500错误,用户不能重复注册.当用户任意点击时也不能出现500错误! 这里.我只写注册成功的页面.这个不让用户重复注册 当时老师对我各种扣分.可后来.我问他的时候,他说不出来.我不是那个第一个提交作业的学生,可我的分数却比他低,我的功能比他多一个好吧 无所谓啊  谁叫我那么背时,再也不想问了.特别烦躁了 registerOk.jsp <body> <% String name=reque