数据结构顺序表问题

乔治爱啃脚趾

1. #include <stdio.h>;
   
2. #include <stdlib.h>;
   
3. #define maxsize 100
   
4. #define ok 1
   
5. typedef int elemtype;
   
6. typedef struct {
   
7.         elemtype *elem;
   
8.         int length;
   
9.         int initsize;
   
10. }sqlist;
    
11. void initlist(sqlist *L)
    
12. {
    
13.         int n;
    
14.         printf("请输入你想创建的顺序表长度：\n");
    
15.         scanf("%d",&n);
    
16.         L->elem=(elemtype *)malloc(sizeof(elemtype)*n);
    
17.         L->length=0;
    
18.         L->initsize=maxsize;
    
19.         printf("请输入顺序表里的数值：\n");
    
20.         for(int i=0;i<n;i++)
    
21.         {
    
22.                 scanf("%d",&L->elem[i]);
    
23.                 L->length++;
    
24.         }
    
25.         printf("顺序表创建成功\n");
    
26. 
    
27. }
    
28. void DisplayList(sqlist *L)
    
29. {
    
30.         int i;
    
31.         for(i=0;i<L->length;i++)
    
32.         {
    
33.                 printf("%d ",L->elem[i]);
    
34.         }
    
35. 
    
36. }
    
37. void listinsert(sqlist *L,int i,elemtype e)
    
38. {
    
39.         int *p,*q;
    
40.         printf("请输入你要插入的数字\n");
    
41.         scanf("%d",&e);
    
42.         printf("请输入你要插入的位置\n");
    
43.         scanf("%d",&i);
    
44.         q=&(L->elem[i-1]);
    
45.         if(i<1||i>L->length)
    
46.         {
    
47.                 printf("error!");
    
48.         }
    
49.         else
    
50.         {
    
51.                 for(p=&(L->elem[L->length-1]);p>=q-1;p--){
    
52.                     *(p+1)=*p;
    
53.                         }
    
54.                         *q=e;
    
55.                         L->length++;
    
56.                
    
57.                
    
58.         }printf("插入成功\n");
    
59. }
    
60. void listdelete(sqlist *L,int i,elemtype e)
    
61. {
    
62.         printf("\n请输入你要删除第几位数：\n");
    
63.         scanf("%d",&i);
    
64.         if(i<1||i>L->length)
    
65.         {
    
66.                 printf("error!");
    
67.         }
    
68.         else
    
69.         {
    
70.                 for(i;i<=L->length;i++){
    
71.                         L->elem[i-1]=L->elem[i];
    
72.                 }
    
73.                 L->length--;
    
74.         }
    
75. }
    
76. void search(sqlist *L)
    
77. {
    
78.         int e,i,k=0;
    
79.         printf("\n请输入你想要查找的数字：");
    
80.         scanf("%d",&e);
    
81.                 for(i=0;i<=L->length-1;i++){
    
82.                         if(e==L->elem[i])
    
83.                         {
    
84.                                 k=1;
    
85.                                 break;
    
86.                         }
    
87.                 }
    
88.                 if(k==1)
    
89.                 {
    
90.                         printf("\n查找成功,位于第%d位\n",i+1);
    
91.                 }
    
92.                 else
    
93.                 {
    
94.                         printf("\n查找失败！\n");
    
95.                 }
    
96.        
    
97. }
    
98. void shanchuduoyu(sqlist *L)
    
99. {
    
100.        
     
101. }
     
102. int main()
     
103. {
     
104.         sqlist L;
     
105.         int i,e;
     
106.         initlist(&L);
     
107.         listinsert(&L,i,e);
     
108.         DisplayList(&L);
     
109.         listdelete(&L,i,e);
     
110.         printf("删除后表中数为：");
     
111.         DisplayList(&L);
     
112.         search(&L);
     
113.         shanchuduoyu(&L);
     
114.         DisplayList(&L);
     
115.         return 0;
     
116. }

复制代码

实验要求

（1）根据输入顺序表的长度n和n个无序整数值建立一个顺序表；

（2）在顺序表的第i个元素之前插入一个值为x的元素，并输出插入后的顺序表中各元素值；

（3）删除顺序表中第i个元素，并输出删除后的顺序表中各元素值；

（4）在顺序表中查找值为e的数据元素，如果查找成功，则输出“查找成功！”和该元素在顺序表中的位置，否则输出“查找失败！”；

（5）根据输入顺序表的长度m和m个非递减的有序整数建立一个有序顺序表，然后删除其中所有的重复元素（即相同的整数只保留一个） ，最后输出删除后的有序顺序表中各元素值。

前四题已完成，请帮我看看哪有错的吗，还有第五题不会写。写在shanchuduoyu那里。

isdkz

代码中存在一些问题，具体如下：



1. 在listinsert函数中，已经定义了参数i和e，不需要再次输入，应该直接使用。



2. 在listdelete函数中，应该先判断删除的位置是否合法，否则会出现数组越界的问题。



3. 在search函数中，应该先判断顺序表是否为空，否则会出现数组越界的问题。



4. 在shanchuduoyu函数中，应该先判断顺序表是否为空，否则会出现数组越界的问题。



5. 在shanchuduoyu函数中，应该先判断顺序表是否有重复元素，否则会出现删除错误的问题。



下面是修改后的代码：

1. #include <stdio.h>
   
   
2. #include <stdlib.h>
   
   
3. 
   
   
4. #define maxsize 100
   
   
5. #define ok 1
   
   
6. 
   
   
7. typedef int elemtype;
   
   
8. 
   
   
9. typedef struct {
   
   
10.     elemtype *elem;
    
    
11.     int length;
    
    
12.     int initsize;
    
    
13. } sqlist;
    
    
14. 
    
    
15. void initlist(sqlist *L)
    
    
16. {
    
    
17.     int n;
    
    
18.     printf("请输入你想创建的顺序表长度：\n");
    
    
19.     scanf("%d", &n);
    
    
20.     L->elem = (elemtype *) malloc(sizeof(elemtype) * n);
    
    
21.     L->length = 0;
    
    
22.     L->initsize = maxsize;
    
    
23.     printf("请输入顺序表里的数值：\n");
    
    
24.     for (int i = 0; i < n; i++) {
    
    
25.         scanf("%d", &L->elem[ i]);
    
    
26.         L->length++;
    
    
27.     }
    
    
28.     printf("顺序表创建成功\n");
    
    
29. }
    
    
30. 
    
    
31. void DisplayList(sqlist *L)
    
    
32. {
    
    
33.     for (int i = 0; i < L->length; i++) {
    
    
34.         printf("%d ", L->elem[ i]);
    
    
35.     }
    
    
36.     printf("\n");
    
    
37. }
    
    
38. 
    
    
39. void listinsert(sqlist *L, int i, elemtype e)
    
    
40. {
    
    
41.     printf("请输入你要插入的数字：\n");
    
    
42.     scanf("%d", &e);
    
    
43.     printf("请输入你要插入的位置：\n");
    
    
44.     scanf("%d", &i);
    
    
45.     if (i < 1 || i > L->length + 1) {
    
    
46.         printf("error!\n");
    
    
47.         return;
    
    
48.     }
    
    
49.     elemtype *p = &(L->elem[L->length - 1]);
    
    
50.     elemtype *q = &(L->elem[i - 1]);
    
    
51.     while (p >= q) {
    
    
52.         *(p + 1) = *p;
    
    
53.         p--;
    
    
54.     }
    
    
55.     *q = e;
    
    
56.     L->length++;
    
    
57.     printf("插入成功\n");
    
    
58.     DisplayList(L);
    
    
59. }
    
    
60. 
    
    
61. void listdelete(sqlist *L, int i, elemtype e)
    
    
62. {
    
    
63.     printf("请输入你要删除第几位数：\n");
    
    
64.     scanf("%d", &i);
    
    
65.     if (i < 1 || i > L->length) {
    
    
66.         printf("error!\n");
    
    
67.         return;
    
    
68.     }
    
    
69.     elemtype *p = &(L->elem[i - 1]);
    
    
70.     while (p < &(L->elem[L->length - 1])) {
    
    
71.         *p = *(p + 1);
    
    
72.         p++;
    
    
73.     }
    
    
74.     L->length--;
    
    
75.     printf("删除成功\n");
    
    
76.     DisplayList(L);
    
    
77. }
    
    
78. 
    
    
79. void search(sqlist *L)
    
    
80. {
    
    
81.     if (L->length == 0) {
    
    
82.         printf("顺序表为空！\n");
    
    
83.         return;
    
    
84.     }
    
    
85.     int e, i, k = 0;
    
    
86.     printf("请输入你想要查找的数字：\n");
    
    
87.     scanf("%d", &e);
    
    
88.     for (i = 0; i < L->length; i++) {
    
    
89.         if (e == L->elem[ i]) {
    
    
90.             k = 1;
    
    
91.             break;
    
    
92.         }
    
    
93.     }
    
    
94.     if (k == 1) {
    
    
95.         printf("查找成功，位于第%d位\n", i + 1);
    
    
96.     } else {
    
    
97.         printf("查找失败！\n");
    
    
98.     }
    
    
99. }
    
    
100. 
     
     
101. void shanchuduoyu(sqlist *L)
     
     
102. {
     
     
103.     if (L->length == 0) {
     
     
104.         printf("顺序表为空！\n");
     
     
105.         return;
     
     
106.     }
     
     
107.     int i, j;
     
     
108.     for (i = 0, j = 1; j < L->length; j++) {
     
     
109.         if (L->elem[ i] != L->elem[j]) {
     
     
110.             L->elem[++i] = L->elem[j];
     
     
111.         }
     
     
112.     }
     
     
113.     L->length = i + 1;
     
     
114.     printf("删除成功\n");
     
     
115.     DisplayList(L);
     
     
116. }
     
     
117. 
     
     
118. int main()
     
     
119. {
     
     
120.     sqlist L;
     
     
121.     int i, e;
     
     
122.     initlist(&L);
     
     
123.     listinsert(&L, i, e);
     
     
124.     listdelete(&L, i, e);
     
     
125.     search(&L);
     
     
126.     shanchuduoyu(&L);
     
     
127.     return 0;
     
     
128. }
     
     

复制代码

第五题的实现思路：



1. 遍历顺序表，如果当前元素与前一个元素相同，则将当前元素删除。



2. 删除元素后，需要将后面的元素向前移动。



3. 最后，更新顺序表的长度。

乔治爱啃脚趾

isdkz 发表于 2023-9-20 21:57
代码中存在一些问题，具体如下：



1. 在listinsert函数中，已经定义了参数i和e，不需要再次输入，应该 ...

这个最后还需要排个序，排成递增的