[已解决]静态链表插入元素，打印结果总是只有第二个位置有数，且后面会覆盖前面

猪猪虾

1. //用C++新建一个类，实现静态表的初始化, 获取元素的值，插入，删除操作
   
2. //要求：
   
3. //1.数据类型可以存储字符串
   
4. //2.插入数据，是插入数据后，链表的数据顺序如下：
   
5. //"ZHAO"
   
6. //"QIAN"
   
7. //"SUN"
   
8. //"LI"
   
9. //"ZHOU"
   
10. //"WU"
    
11. //"ZHENG"
    
12. //"WANG"
    
13. 
    
14. #include<winuser.inl>
    
15. #include<stdio.h>
    
16. #include <cstdlib>
    
17. #include<string.h>
    
18. 
    
19. #define MAXSIZE 10
    
20. #define True 1
    
21. void InitialList(struct People* people);
    
22. int Getlength(struct People* space);
    
23. void InsertElement(struct People* space, int position, int element);
    
24. void DeleteElement(struct People* space, int position);
    
25. void Free(struct People* space, int position_index);
    
26. void printfInfo(struct People* space);
    
27. 
    
28. 
    
29. struct People
    
30. {
    
31.         int data;
    
32.         int cur;
    
33. }people[MAXSIZE];
    
34.        
    
35. 
    
36. void InitialList(struct People *people)
    
37. {
    
38.         int i;
    
39.         for(i = 0; i < MAXSIZE - 1 ; i++)
    
40.         {
    
41.                 people[i].cur = i + 1;
    
42.         }
    
43.         people[MAXSIZE - 1].cur = 0;
    
44. }
    
45. 
    
46. int Getlength(struct People* space)
    
47. {
    
48.         int count = 0;
    
49.         //最后一个元素的游标是第一个存有元素的位置下标
    
50.         int i = space[MAXSIZE - 1].cur;
    
51.         while (i)
    
52.         {
    
53.                 count++;
    
54.                 i = space[i].cur;
    
55.         }
    
56.         return count;
    
57. }
    
58. 
    
59. int Get_first_spare_index(struct People* space)
    
60. {
    
61.         //首先需要判断备用链表是不是空，如果备用链表为空，则说明没有多余的空间可以插入元素
    
62.         //当前数组第一个元素的cur，是的备用链表的第一个元素的下标
    
63.         int i = space[0].cur;
    
64.         if (space[0].cur)  //如果备用链表非空
    
65.         {
    
66.                 //把第一个备用元素从备用链表中剔除，i即是被剔除的那个备用元素的下标
    
67.                 space[0].cur = space[i].cur;
    
68.         }
    
69.         return i;
    
70. }
    
71. //插入元素
    
72. void InsertElement(struct People* space, int position, int element)
    
73. {
    
74.         int spare_of_first_e, k ;
    
75.         k = MAXSIZE - 1;  //当前k是最后一个元素的下标
    
76.         if (position < 1 || position > MAXSIZE)
    
77.         {
    
78.                 printf("out index\n");
    
79.         }
    
80.         else
    
81.         {
    
82.                 spare_of_first_e = Get_first_spare_index(space);
    
83.                 if (spare_of_first_e)
    
84.                 {
    
85.                         space[spare_of_first_e].data = element;
    
86.                         //找到要插入位置的前一个位置元素的游标，将游标等于position，
    
87.                         //再将当前元素的游标指向原本位置的当前元素的下标
    
88.                         //由于游标和下标之间没有连续的对应关系，所以不能通过i++的形式来直接索引
    
89.                         for (int z = 1; z <= position - 1; z++) //对下标的索引
    
90.                         {
    
91.                                 k = space[k].cur;
    
92.                         }
    
93.                         space[spare_of_first_e].cur = space[k].cur;
    
94.                         space[k].cur = spare_of_first_e;
    
95.                 }
    
96.         }
    
97. }
    
98.        
    
99. 
    
100. 
     
101. //删除元素
     
102. void DeleteElement(struct People* space, int position)
     
103. {
     
104.         if (position < 1 || position > Getlength(space) + 1)
     
105.         {
     
106.                 printf("out index\n");
     
107.         }
     
108.         else
     
109.         {
     
110.                 int k ;
     
111.                 k = MAXSIZE - 1;
     
112.                 for (int z = 1; z <= position - 1; z++) //对下标的索引
     
113.                 {
     
114.                         k = space[k].cur;  //获得要删除的元素的前一个元素的下标
     
115.                 }
     
116.                 space[k].cur = space[position].cur;
     
117.                 Free(space, position);
     
118.         }
     
119. }
     
120. 
     
121. void Free(struct People* space, int position_index)
     
122. {
     
123.         //将指定下标的节点回收到备用链表
     
124.         space[position_index].cur = space[0].cur ;
     
125.         space[0].cur = position_index;
     
126. }
     
127. 
     
128. void printfInfo(struct People *space)
     
129. {
     
130.         printf("all element: \n");
     
131.         for (int i = 0; i < MAXSIZE; i++)
     
132.         {
     
133.                 printf("%d ", space[i].data);
     
134.         }
     
135.         printf("\n");
     
136. }
     
137. 
     
138. int main()
     
139. {       
     
140.         struct People space[MAXSIZE];
     
141.         InitialList(space);
     
142.         InsertElement(space, 2, 1);
     
143.         InsertElement(space, 4, 10);
     
144.         printfInfo(space);
     
145. 
     
146. }

复制代码

最佳答案

月排行榜 / 总排行榜

人造人

2021-3-6 20:57:43

好多的错误，我认为你这部分没有学好，建议重新学习一下这部分内容

1. //用C++新建一个类，实现静态表的初始化, 获取元素的值，插入，删除操作
   
2. //要求：
   
3. //1.数据类型可以存储字符串
   
4. //2.插入数据，是插入数据后，链表的数据顺序如下：
   
5. //"ZHAO"
   
6. //"QIAN"
   
7. //"SUN"
   
8. //"LI"
   
9. //"ZHOU"
   
10. //"WU"
    
11. //"ZHENG"
    
12. //"WANG"
    
13. 
    
14. //#include<winuser.inl>
    
15. #include<stdio.h>
    
16. #include <cstdlib>
    
17. #include<string.h>
    
18. 
    
19. #define MAXSIZE 10
    
20. #define True 1
    
21. void InitialList(struct People* people);
    
22. int Getlength(struct People* space);
    
23. void InsertElement(struct People* space, int position, int element);
    
24. void DeleteElement(struct People* space, int position);
    
25. void Free(struct People* space, int position_index);
    
26. void printfInfo(struct People* space);
    
27. 
    
28. /*
    
29.    struct People
    
30.    {
    
31.    int data;
    
32.    int cur;
    
33.    }people[MAXSIZE];
    
34.    */
    
35. struct People
    
36. {
    
37.     int data;
    
38.     int cur;
    
39. };
    
40. 
    
41. void InitialList(struct People *people)
    
42. {
    
43.     int i;
    
44.     for(i = 0; i < MAXSIZE - 1 ; i++)
    
45.     {
    
46.         people[i].cur = i + 1;
    
47.     }
    
48. 
    
49. 
    
50. 
    
51.     // 备用链表怎么结束？
    
52.     people[MAXSIZE - 2].cur = 0;
    
53. 
    
54. 
    
55. 
    
56.     people[MAXSIZE - 1].cur = 0;
    
57. }
    
58. 
    
59. int Getlength(struct People* space)
    
60. {
    
61.     int count = 0;
    
62.     //最后一个元素的游标是第一个存有元素的位置下标
    
63.     int i = space[MAXSIZE - 1].cur;
    
64.     while (i)
    
65.     {
    
66.         count++;
    
67.         i = space[i].cur;
    
68.     }
    
69.     return count;
    
70. }
    
71. 
    
72. int Get_first_spare_index(struct People* space)
    
73. {
    
74.     //首先需要判断备用链表是不是空，如果备用链表为空，则说明没有多余的空间可以插入元素
    
75.     //当前数组第一个元素的cur，是的备用链表的第一个元素的下标
    
76.     int i = space[0].cur;
    
77.     if (space[0].cur)  //如果备用链表非空
    
78.     {
    
79.         //把第一个备用元素从备用链表中剔除，i即是被剔除的那个备用元素的下标
    
80.         space[0].cur = space[i].cur;
    
81.     }
    
82.     return i;
    
83. }
    
84. //插入元素
    
85. void InsertElement(struct People* space, int position, int element)
    
86. {
    
87.     int spare_of_first_e, k ;
    
88.     k = MAXSIZE - 1;  //当前k是最后一个元素的下标
    
89. 
    
90. 
    
91. 
    
92.     // position 等于 MAXSIZE 也不行吧？
    
93.     //if (position < 1 || position > MAXSIZE)
    
94.     if (position < 1 || position >= MAXSIZE)
    
95.     {
    
96.         printf("out index\n");
    
97.     }
    
98.     else
    
99.     {
    
100.         spare_of_first_e = Get_first_spare_index(space);
     
101.         if (spare_of_first_e)
     
102.         {
     
103.             space[spare_of_first_e].data = element;
     
104.             //找到要插入位置的前一个位置元素的游标，将游标等于position，
     
105.             //再将当前元素的游标指向原本位置的当前元素的下标
     
106.             //由于游标和下标之间没有连续的对应关系，所以不能通过i++的形式来直接索引
     
107.             for (int z = 1; z <= position - 1; z++) //对下标的索引
     
108.             {
     
109.                 // 这里难道不需要判断一下吗？
     
110.                 // 试想一下，当前链表只有3个元素，而插入的位置是5,那么这里将会是怎么样的一个状态呢？
     
111.                 k = space[k].cur;
     
112.             }
     
113.             space[spare_of_first_e].cur = space[k].cur;
     
114.             space[k].cur = spare_of_first_e;
     
115.         }
     
116.     }
     
117. }
     
118. 
     
119. 
     
120. 
     
121. //删除元素
     
122. void DeleteElement(struct People* space, int position)
     
123. {
     
124.     // 这里为什么要加1呢？
     
125.     // 如果链表只有一个元素我要删除位置2呢？
     
126.     //if (position < 1 || position > Getlength(space) + 1)
     
127.     if (position < 1 || position > Getlength(space))
     
128.     {
     
129.         printf("out index\n");
     
130.     }
     
131.     else
     
132.     {
     
133.         int k ;
     
134.         k = MAXSIZE - 1;
     
135.         for (int z = 1; z <= position - 1; z++) //对下标的索引
     
136.         {
     
137.             k = space[k].cur;  //获得要删除的元素的前一个元素的下标
     
138.         }
     
139. 
     
140.         int f = space[k].cur;
     
141.         space[k].cur = space[f].cur;
     
142.         Free(space, f);
     
143. 
     
144.         // 下面这波操作是在做什么啊？
     
145.         //space[k].cur = space[position].cur;
     
146.         //Free(space, position);
     
147.     }
     
148. }
     
149. 
     
150. void Free(struct People* space, int position_index)
     
151. {
     
152.     //将指定下标的节点回收到备用链表
     
153.     space[position_index].cur = space[0].cur ;
     
154.     space[0].cur = position_index;
     
155. }
     
156. 
     
157. // 这个函数是要做什么？输出数组内容？不应该是输出链表内容吗？
     
158. //void printfInfo(struct People *space)
     
159. void printArray(struct People *space)
     
160. {
     
161.     printf("all element: \n");
     
162.     for (int i = 0; i < MAXSIZE; i++)
     
163.     {
     
164.         printf("%d ", space[i].data);
     
165.     }
     
166.     printf("\n");
     
167. }
     
168. 
     
169. void printElement(struct People *space)
     
170. {
     
171.     printf("all element: \n");
     
172.     int i = space[MAXSIZE - 1].cur;
     
173.     while(i)
     
174.     {
     
175.         printf("%d ", space[i].data);
     
176.         i = space[i].cur;
     
177.     }
     
178.     printf("\n");
     
179. }
     
180. 
     
181. int main()
     
182. {
     
183.     /*
     
184.     struct People space[MAXSIZE];
     
185.     InitialList(space);
     
186.     InsertElement(space, 2, 1);     // 在2的位置插入1？位置1怎么办？
     
187.     InsertElement(space, 4, 10);    // 位置3怎么办？
     
188.     printInfo(space);
     
189.     */
     
190. 
     
191. 
     
192.     struct People space[MAXSIZE];
     
193.     InitialList(space);
     
194.     InsertElement(space, 1, 5);
     
195.     InsertElement(space, 2, 9);
     
196.     InsertElement(space, 3, 7);
     
197.     InsertElement(space, 4, 8);
     
198.     printElement(space);
     
199.     DeleteElement(space, 3);
     
200.     DeleteElement(space, 2);
     
201.     printElement(space);
     
202.     return 0;
     
203. }
     

复制代码

跳转到最佳答案楼层

人造人

好多的错误，我认为你这部分没有学好，建议重新学习一下这部分内容

1. //用C++新建一个类，实现静态表的初始化, 获取元素的值，插入，删除操作
   
2. //要求：
   
3. //1.数据类型可以存储字符串
   
4. //2.插入数据，是插入数据后，链表的数据顺序如下：
   
5. //"ZHAO"
   
6. //"QIAN"
   
7. //"SUN"
   
8. //"LI"
   
9. //"ZHOU"
   
10. //"WU"
    
11. //"ZHENG"
    
12. //"WANG"
    
13. 
    
14. //#include<winuser.inl>
    
15. #include<stdio.h>
    
16. #include <cstdlib>
    
17. #include<string.h>
    
18. 
    
19. #define MAXSIZE 10
    
20. #define True 1
    
21. void InitialList(struct People* people);
    
22. int Getlength(struct People* space);
    
23. void InsertElement(struct People* space, int position, int element);
    
24. void DeleteElement(struct People* space, int position);
    
25. void Free(struct People* space, int position_index);
    
26. void printfInfo(struct People* space);
    
27. 
    
28. /*
    
29.    struct People
    
30.    {
    
31.    int data;
    
32.    int cur;
    
33.    }people[MAXSIZE];
    
34.    */
    
35. struct People
    
36. {
    
37.     int data;
    
38.     int cur;
    
39. };
    
40. 
    
41. void InitialList(struct People *people)
    
42. {
    
43.     int i;
    
44.     for(i = 0; i < MAXSIZE - 1 ; i++)
    
45.     {
    
46.         people[i].cur = i + 1;
    
47.     }
    
48. 
    
49. 
    
50. 
    
51.     // 备用链表怎么结束？
    
52.     people[MAXSIZE - 2].cur = 0;
    
53. 
    
54. 
    
55. 
    
56.     people[MAXSIZE - 1].cur = 0;
    
57. }
    
58. 
    
59. int Getlength(struct People* space)
    
60. {
    
61.     int count = 0;
    
62.     //最后一个元素的游标是第一个存有元素的位置下标
    
63.     int i = space[MAXSIZE - 1].cur;
    
64.     while (i)
    
65.     {
    
66.         count++;
    
67.         i = space[i].cur;
    
68.     }
    
69.     return count;
    
70. }
    
71. 
    
72. int Get_first_spare_index(struct People* space)
    
73. {
    
74.     //首先需要判断备用链表是不是空，如果备用链表为空，则说明没有多余的空间可以插入元素
    
75.     //当前数组第一个元素的cur，是的备用链表的第一个元素的下标
    
76.     int i = space[0].cur;
    
77.     if (space[0].cur)  //如果备用链表非空
    
78.     {
    
79.         //把第一个备用元素从备用链表中剔除，i即是被剔除的那个备用元素的下标
    
80.         space[0].cur = space[i].cur;
    
81.     }
    
82.     return i;
    
83. }
    
84. //插入元素
    
85. void InsertElement(struct People* space, int position, int element)
    
86. {
    
87.     int spare_of_first_e, k ;
    
88.     k = MAXSIZE - 1;  //当前k是最后一个元素的下标
    
89. 
    
90. 
    
91. 
    
92.     // position 等于 MAXSIZE 也不行吧？
    
93.     //if (position < 1 || position > MAXSIZE)
    
94.     if (position < 1 || position >= MAXSIZE)
    
95.     {
    
96.         printf("out index\n");
    
97.     }
    
98.     else
    
99.     {
    
100.         spare_of_first_e = Get_first_spare_index(space);
     
101.         if (spare_of_first_e)
     
102.         {
     
103.             space[spare_of_first_e].data = element;
     
104.             //找到要插入位置的前一个位置元素的游标，将游标等于position，
     
105.             //再将当前元素的游标指向原本位置的当前元素的下标
     
106.             //由于游标和下标之间没有连续的对应关系，所以不能通过i++的形式来直接索引
     
107.             for (int z = 1; z <= position - 1; z++) //对下标的索引
     
108.             {
     
109.                 // 这里难道不需要判断一下吗？
     
110.                 // 试想一下，当前链表只有3个元素，而插入的位置是5,那么这里将会是怎么样的一个状态呢？
     
111.                 k = space[k].cur;
     
112.             }
     
113.             space[spare_of_first_e].cur = space[k].cur;
     
114.             space[k].cur = spare_of_first_e;
     
115.         }
     
116.     }
     
117. }
     
118. 
     
119. 
     
120. 
     
121. //删除元素
     
122. void DeleteElement(struct People* space, int position)
     
123. {
     
124.     // 这里为什么要加1呢？
     
125.     // 如果链表只有一个元素我要删除位置2呢？
     
126.     //if (position < 1 || position > Getlength(space) + 1)
     
127.     if (position < 1 || position > Getlength(space))
     
128.     {
     
129.         printf("out index\n");
     
130.     }
     
131.     else
     
132.     {
     
133.         int k ;
     
134.         k = MAXSIZE - 1;
     
135.         for (int z = 1; z <= position - 1; z++) //对下标的索引
     
136.         {
     
137.             k = space[k].cur;  //获得要删除的元素的前一个元素的下标
     
138.         }
     
139. 
     
140.         int f = space[k].cur;
     
141.         space[k].cur = space[f].cur;
     
142.         Free(space, f);
     
143. 
     
144.         // 下面这波操作是在做什么啊？
     
145.         //space[k].cur = space[position].cur;
     
146.         //Free(space, position);
     
147.     }
     
148. }
     
149. 
     
150. void Free(struct People* space, int position_index)
     
151. {
     
152.     //将指定下标的节点回收到备用链表
     
153.     space[position_index].cur = space[0].cur ;
     
154.     space[0].cur = position_index;
     
155. }
     
156. 
     
157. // 这个函数是要做什么？输出数组内容？不应该是输出链表内容吗？
     
158. //void printfInfo(struct People *space)
     
159. void printArray(struct People *space)
     
160. {
     
161.     printf("all element: \n");
     
162.     for (int i = 0; i < MAXSIZE; i++)
     
163.     {
     
164.         printf("%d ", space[i].data);
     
165.     }
     
166.     printf("\n");
     
167. }
     
168. 
     
169. void printElement(struct People *space)
     
170. {
     
171.     printf("all element: \n");
     
172.     int i = space[MAXSIZE - 1].cur;
     
173.     while(i)
     
174.     {
     
175.         printf("%d ", space[i].data);
     
176.         i = space[i].cur;
     
177.     }
     
178.     printf("\n");
     
179. }
     
180. 
     
181. int main()
     
182. {
     
183.     /*
     
184.     struct People space[MAXSIZE];
     
185.     InitialList(space);
     
186.     InsertElement(space, 2, 1);     // 在2的位置插入1？位置1怎么办？
     
187.     InsertElement(space, 4, 10);    // 位置3怎么办？
     
188.     printInfo(space);
     
189.     */
     
190. 
     
191. 
     
192.     struct People space[MAXSIZE];
     
193.     InitialList(space);
     
194.     InsertElement(space, 1, 5);
     
195.     InsertElement(space, 2, 9);
     
196.     InsertElement(space, 3, 7);
     
197.     InsertElement(space, 4, 8);
     
198.     printElement(space);
     
199.     DeleteElement(space, 3);
     
200.     DeleteElement(space, 2);
     
201.     printElement(space);
     
202.     return 0;
     
203. }
     

复制代码