哪位大佬可以帮忙改改这代码的问题呢？

Wuhahahaha

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <stdlib.h>
   
4. #include <assert.h>
   
5. 
   
6. 
   
7. #define VOLUME 255
   
8. 
   
9. typedef struct HString
   
10. {
    
11.         char* ch;   //指向字符串所在空间地址
    
12.         int   length; //记录字符串长度
    
13. }HString;
    
14. 
    
15. //初始化字符结构
    
16. void InitString(HString* S)
    
17. {
    
18.         S->ch = NULL;
    
19.         S->length = 0;
    
20. }
    
21. 
    
22. //赋值：将字符串str赋给字符结构T
    
23. void StrAssign(HString* T, char* str) {
    
24.         int i, j, len;
    
25.         char* c;
    
26.         if (str != NULL) {
    
27.                 if (T->ch)
    
28.                 {
    
29.                         free(T->ch);  //释放T原有的空间
    
30.                 }
    
31. 
    
32.                 for (len = 0; str[len] != '\0'; len++)
    
33.                 {
    
34.                         continue;
    
35.                 }
    
36. 
    
37.                 if (!len) {
    
38.                         T->ch = NULL;
    
39.                         T->length = 0;
    
40.                 }
    
41.                 else {
    
42.                         T->ch = (char*)malloc((len + 1) * sizeof(char)); // 为null终止符分配空间
    
43.                         if (T->ch == NULL) {
    
44.                                 exit(-1);
    
45.                         }
    
46.                 }
    
47. 
    
48.                 for (j = 0; j < len; j++) {
    
49.                         T->ch[j] = str[j];//分配成功后，将str中的字符逐个赋给T
    
50.                 }
    
51.                 T->length = len;//记录此时T的长度
    
52.         }
    
53. }
    
54. 
    
55. //获取next数组
    
56. void get_next(HString* T, int* next)
    
57. {
    
58.         int j = 0;
    
59.         int i = 1;
    
60.         next[1] = 0;
    
61. 
    
62.         while (i < T->length)
    
63.         {
    
64.                 if (0 == j || T->ch[i] == T->ch[j])
    
65.                 {
    
66.                         i++;
    
67.                         j++;
    
68.                         if (T->ch[i] != T->ch[j])
    
69.                         {
    
70.                                 next[i] = j;
    
71.                         }
    
72.                         else
    
73.                         {
    
74.                                 next[i] = next[j];
    
75.                         }
    
76.                 }
    
77.                 else
    
78.                 {
    
79.                         j = next[j];
    
80.                 }
    
81.         }
    
82. }
    
83. 
    
84. // 返回子串T在主串S第pos个字符之后的位置
    
85. // 若不存在，则返回-1
    
86. int Index_KMP(HString* S, HString* T, int pos)
    
87. {
    
88.         int i = pos;
    
89.         int j = 1;
    
90.         int *next;
    
91. 
    
92.         next = (int*)malloc(sizeof(int) * VOLUME);  //动态分配next数组
    
93.         get_next(T, next);
    
94. 
    
95.         while (i <= S->length && j <= T->length)
    
96.         {
    
97.                 if (i <= S->length && (0 == j || S->ch[i] == T->ch[j]))
    
98.                 {
    
99.                         i++;
    
100.                         j++;
     
101.                         if (T->ch[i] != T->ch[j])
     
102.                         {
     
103.                                 next[i] = j;
     
104.                         }
     
105.                         else
     
106.                         {
     
107.                                 next[i] = next[j];
     
108.                         }
     
109.                 }
     
110.                 else
     
111.                 {
     
112.                         j = next[j];
     
113.                 }
     
114.         }
     
115.        
     
116.         if (j > T->length)
     
117.         {
     
118.                 return i - T->length + 1;
     
119.         }
     
120.         else
     
121.         {
     
122.                 return -1;
     
123.         }
     
124.         free(next);
     
125. }
     
126. 
     
127. int StrCompare(HString *S, HString *T) {
     
128.         int i;
     
129.         for (i = 0; i < S->length && i < T->length; i++)
     
130.         {
     
131.                 if (S->ch[i] != T->ch[i])
     
132.                 {
     
133.                         return S->ch[i] - T->ch[i];
     
134.                 }
     
135.         }
     
136.         return  S->length - T->length;
     
137. }
     
138. 
     
139. int ClearString(HString* S) {
     
140.         if (S->ch)
     
141.         {
     
142.                 free(S->ch);
     
143.                 S->ch = NULL;
     
144.         }
     
145.         S->length = 0;
     
146.         return 0;
     
147. }
     
148. 
     
149. int main(int argc, char* argv[])
     
150. {
     
151.         HString input, keyword;
     
152.         InitString(&input);
     
153.         InitString(&keyword);
     
154.        
     
155.         if (argc != 3)
     
156.         {
     
157.                 printf("ERROR_01");
     
158.                 exit(-1);
     
159.         }
     
160. 
     
161.         StrAssign(&input, argv[1]);
     
162.         StrAssign(&keyword, argv[2]);
     
163. 
     
164.         printf("%d",Index_KMP(&input, &keyword, 0));
     
165.         ClearString(&input);
     
166.         ClearString(&keyword);
     
167.        
     
168.         return 0;
     
169. }

复制代码

isdkz

这段代码存在以下问题：

1. 在函数 get_next 中，没有对 next 数组进行初始化。应该在函数开始时将 next[0] 初始化为-1。

2. 在函数 Index_KMP 中，动态分配的 next 数组没有在函数结束时释放。应该将 free(next) 放在 return 语句之前。

3. 在函数 StrCompare 中，当字符串长度不相等时，返回的是 S->length - T->length ，这可能导致溢出。应该返回 S->length - T->length 的符号。

4. 在函数 ClearString 中，没有释放 S->ch 指向的内存空间。应该在释放之后将 S->ch 指向 NULL 。

下面是修改后的代码：

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #include <stdlib.h>
   
4. #include <assert.h>
   
5. 
   
6. #define VOLUME 255
   
7. 
   
8. typedef struct HString
   
9. {
   
10.     char* ch;   //指向字符串所在空间地址
    
11.     int   length; //记录字符串长度
    
12. }HString;
    
13. 
    
14. //初始化字符结构
    
15. void InitString(HString* S)
    
16. {
    
17.     S->ch = NULL;
    
18.     S->length = 0;
    
19. }
    
20. 
    
21. //赋值：将字符串str赋给字符结构T
    
22. void StrAssign(HString* T, char* str) {
    
23.     int i, j, len;
    
24.     char* c;
    
25.     if (str != NULL) {
    
26.         if (T->ch)
    
27.         {
    
28.             free(T->ch);  //释放T原有的空间
    
29.         }
    
30. 
    
31.         for (len = 0; str[len] != '\0'; len++)
    
32.         {
    
33.             continue;
    
34.         }
    
35. 
    
36.         if (!len) {
    
37.             T->ch = NULL;
    
38.             T->length = 0;
    
39.         }
    
40.         else {
    
41.             T->ch = (char*)malloc((len + 1) * sizeof(char)); // 为null终止符分配空间
    
42.             if (T->ch == NULL) {
    
43.                 exit(-1);
    
44.             }
    
45.         }
    
46. 
    
47.         for (j = 0; j < len; j++) {
    
48.             T->ch[j] = str[j];//分配成功后，将str中的字符逐个赋给T
    
49.         }
    
50.         T->ch[j] = '\0'; // 添加字符串结束符
    
51.         T->length = len;//记录此时T的长度
    
52.     }
    
53. }
    
54. 
    
55. //获取next数组
    
56. void get_next(HString* T, int* next)
    
57. {
    
58.     int j = 0;
    
59.     int i = 1;
    
60.     next[0] = -1; // 初始化next数组
    
61. 
    
62.     while (i < T->length)
    
63.     {
    
64.         if (j == -1 || T->ch[ i] == T->ch[j])
    
65.         {
    
66.             i++;
    
67.             j++;
    
68.             if (T->ch[ i] != T->ch[j])
    
69.             {
    
70.                 next[ i] = j;
    
71.             }
    
72.             else
    
73.             {
    
74.                 next[ i] = next[j];
    
75.             }
    
76.         }
    
77.         else
    
78.         {
    
79.             j = next[j];
    
80.         }
    
81.     }
    
82. }
    
83. 
    
84. // 返回子串T在主串S第pos个字符之后的位置
    
85. // 若不存在，则返回-1
    
86. int Index_KMP(HString* S, HString* T, int pos)
    
87. {
    
88.     int i = pos;
    
89.     int j = 0;
    
90.     int* next;
    
91. 
    
92.     next = (int*)malloc(sizeof(int) * VOLUME);  //动态分配next数组
    
93.     get_next(T, next);
    
94. 
    
95.     while (i < S->length && j < T->length)
    
96.     {
    
97.         if (j == -1 || S->ch[ i] == T->ch[j])
    
98.         {
    
99.             i++;
    
100.             j++;
     
101.         }
     
102.         else
     
103.         {
     
104.             j = next[j];
     
105.         }
     
106.     }
     
107. 
     
108.     free(next);
     
109. 
     
110.     if (j >= T->length)
     
111.     {
     
112.         return i - T->length;
     
113.     }
     
114.     else
     
115.     {
     
116.         return -1;
     
117.     }
     
118. }
     
119. 
     
120. int StrCompare(HString* S, HString* T) {
     
121.     int i;
     
122.     for (i = 0; i < S->length && i < T->length; i++)
     
123.     {
     
124.         if (S->ch[ i] != T->ch[ i])
     
125.         {
     
126.             return (S->ch[ i] > T->ch[ i]) ? 1 : -1;
     
127.         }
     
128.     }
     
129.     return (S->length > T->length) ? 1 : ((S->length < T->length) ? -1 : 0);
     
130. }
     
131. 
     
132. int ClearString(HString* S) {
     
133.     if (S->ch)
     
134.     {
     
135.         free(S->ch);
     
136.         S->ch = NULL;
     
137.     }
     
138.     S->length = 0;
     
139.     return 0;
     
140. }
     
141. 
     
142. int main(int argc, char* argv[])
     
143. {
     
144.     HString input, keyword;
     
145.     InitString(&input);
     
146.     InitString(&keyword);
     
147. 
     
148.     if (argc != 3)
     
149.     {
     
150.         printf("ERROR_01");
     
151.         exit(-1);
     
152.     }
     
153. 
     
154.     StrAssign(&input, argv[1]);
     
155.     StrAssign(&keyword, argv[2]);
     
156. 
     
157.     printf("%d", Index_KMP(&input, &keyword, 0));
     
158.     ClearString(&input);
     
159.     ClearString(&keyword);
     
160. 
     
161.     return 0;
     
162. }
     

复制代码