指针数组，多字符串输入问题？

haiouda

#include <stdio.h>
#if(1)
int main()
{
char *p[30];
p[0]="China";
p[1]="man";
printf("%s %s\n",p[0],p[1]);
#endif;
}








上面这段程序，定义了30个指针组成的，指针数组，前二个指针指向了字符串，还有28个指针没有指向字符串，如何实现动态输入（在程序运行中输入）28个字符串，让其它的指针，指向输入的28个字符串；这个就是我要，求教的问题，谢谢。
******************************************************************************
下面第 4 楼，第二个问题，求助 :handshake
下面第 5 楼，对程序进行了改进，可三楼的第二个问题，怎么解决一点思路也没有，请求指点::handshake

lightninng

haiouda 发表于 2015-3-19 14:41
这个的缺点是：1）不输入1000个字串不能退出（这个可以自己解决）；
                             ...

首先说，想节省空间，相对的一般要用时间来换，提一种思路解决你说的问题
借用链表的方法

1. typedef struct LNode
   
2. {
   
3.     char *str;
   
4.     struct Node *next;
   
5. }LNode;
   
6. main()
   
7. {
   
8.         LNode *head = NULL;#用于记录头结点的位置
   
9.         LNode *p =NULL,*pre = NULL;
   
10.         char *temp_str; #用于暂时存放输入的字符串
    
11.         for (i=0;i<1000;i++)
    
12.         {
    
13.             p = (LNode *)malloc(sizeof(LNode));#p指向新生成的结点   
    
14.                         scanf("%s",temp_str);
    
15.                         p->str = temp_str;
    
16.                         p->next = head;
    
17.                         head = P;#头插法生成链表                        
    
18.         }
    
19.         #以下为冒泡法排序
    
20.         int i,j;
    
21.         for(i = 1000; i > 0; i--)
    
22.                 p = head;
    
23.                 pre = NULL;
    
24.                 for(j = 0; j < i; j++)
    
25.                         if(strcmp(p->str，p->next->str)>0)
    
26.                         {
    
27.                                 #若p指向结点所存字符串比后一结点的大刚交换两者位置
    
28.                                 if(pre)
    
29.                                 {
    
30.                                         head = p->next;#若p指向头结点则在交换结点位置前需要更改头指针的指向
    
31.                                 }
    
32.                                 else
    
33.                                 {
    
34.                                         pre->next = P->next;#若p未指向头结点则在交换结点位置前先要将p前一结点的指针指向新的位置
    
35.                                 }
    
36.                                 #交换p和p下一个结点的位置
    
37.                                 pre = p->next;
    
38.                                 p->next = pre->next;
    
39.                                 pre->next = p;
    
40.                         }               
    
41.                         else
    
42.                         {
    
43.                                 #反之则将p和pre指针后移继续检查后继结点
    
44.                                 pre = p, p = p->next        
    
45.                         }
    
46.         #按排好的顺序输出字符串
    
47.         for(p = head; p; p = p->next)
    
48.                 printf("%s", p->str);
    
49. }

复制代码

上面这段代码的错误在于，新建的结构体结点内的str指针未初始化，不能用于scanf函数中，可以改变它的指向，为了达到楼主所说的节省空间，代码改为下面这样

1. 
   
2. typedef struct LNode
   
3. {
   
4.     char *str;
   
5.     struct Node *next;
   
6. }LNode;
   
7. main()
   
8. {
   
9.         LNode *head = NULL;#用于记录头结点的位置
   
10.         LNode *p =NULL,*pre = NULL;
    
11.                
    
12.                
    
13.         for (i=0;i<1000;i++)
    
14.         {
    
15.                         int str_len,count;
    
16.                         char temp_char;
    
17.                         char* temp_str = (char*)malloc(sizeof(char*) * 5);
    
18.                         for(int i = 0; i < 1000; i++)
    
19.                         {
    
20.                                 #这段代码用于创建一个申请空间等于输入字符数的字符串
    
21.                                 str_len = 5,count = 0;
    
22.                                 printf("Please input a string: ");
    
23.                                 temp_str = (char*)malloc(temp_str, sizeof(char*) * 5);
    
24.                                 do
    
25.                                 {
    
26.                                         temp_char = getchar();
    
27.                                         count++;
    
28.                                         if (count >= str_len)
    
29.                                                 temp_str = (char*)realloc(temp_str, sizeof(char*) * (++str_len));
    
30.                                         temp_str[count-1] = temp_char;
    
31.                                 } while (temp_char != '\n');
    
32.                                 temp_str[count] = '\0';
    
33.                                 #将得到的字符串的首地址赋于结点p中的str指针
    
34.                                 p = (LNode *)malloc(sizeof(LNode));#p指向新生成的结点            
    
35.                 p->str = temp_str;
    
36.                 p->next = head;
    
37.                 head = P;#头插法生成链表   
    
38.                         }
    
39.         }
    
40.         #以下为冒泡法排序
    
41.         int i,j;
    
42.         for(i = 1000; i > 0; i--)
    
43.                 p = head;
    
44.                 pre = NULL;
    
45.                 for(j = 0; j < i; j++)
    
46.                         if(strcmp(p->str，p->next->str)>0)
    
47.                         {
    
48.                                 #若p指向结点所存字符串比后一结点的大刚交换两者位置
    
49.                                 if(pre)
    
50.                                 {
    
51.                                         head = p->next;#若p指向头结点则在交换结点位置前需要更改头指针的指向
    
52.                                 }
    
53.                                 else
    
54.                                 {
    
55.                                         pre->next = P->next;#若p未指向头结点则在交换结点位置前先要将p前一结点的指针指向新的位置
    
56.                                 }
    
57.                                 #交换p和p下一个结点的位置
    
58.                                 pre = p->next;
    
59.                                 p->next = pre->next;
    
60.                                 pre->next = p;
    
61.                         }               
    
62.                         else
    
63.                         {
    
64.                                 #反之则将p和pre指针后移继续检查后继结点
    
65.                                 pre = p, p = p->next        
    
66.                         }
    
67.         #按排好的顺序输出字符串
    
68.         for(p = head; p; p = p->next)
    
69.                 printf("%s", p->str);
    
70. }

复制代码

链表的好处是每当你输入一个新的字符串你都可以创建一个新的结点去存储它，然后链接到链表的头部或者尾部即可（头插和尾插），坏处是不能随机查找（即按位置取值），但是题目要求只是顺序输出字符串，冒泡法也只用比较相邻的结点数据，相对来说比较好用，其实，这么麻烦的实现方法，楼主还不如直接多申请点空间保存你的字符串

ANDES

书上有题目，照着改就行了，这样才能进步。

haiouda

ANDES 发表于 2015-3-19 09:15
书上有题目，照着改就行了，这样才能进步。

     这个的缺点是：1）不输入1000个字串不能退出（这个可以自己解决）；
                               2）输入的字符串长度，最长为29个字符（由二维数组确定），输入不够浪费空间，输入超了无效；

  第二个问题哪位能指点下怎么修改，谢谢:handshake ;  还有，我试着让数组指针，指向二维数组，可只能第一个字符串指给，打针数组，后面的二者地址就不一样了，无奈，才在for 语句中，一对 一的指定；问下 这里，还有更好的办法么？

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #define xx 1000
   
4. int main()
   
5. {
   
6.         void pxx(char *b[],int n);
   
7.         int i;
   
8.         char p[xx][30],*a[xx];
   
9.         
   
10.         for (i=0;i<xx;i++)
    
11.         {
    
12.                 a[i]=p[i];
    
13.         scanf("%s",a[i]);
    
14.         }
    
15.    
    
16.    pxx(a,xx);
    
17. 
    
18. 
    
19. 
    
20.         for (i=0;i<xx;i++)
    
21.         {
    
22.         printf("%s ",a[i]);
    
23.                
    
24.         }
    
25.         printf("\n");
    
26. 
    
27. return 0;
    
28. 
    
29. }
    
30. 
    
31. void pxx(char *b[],int n)
    
32. {
    
33.         int i,k;
    
34.         char *temp;
    
35.         for (i=n;i>0;i--)
    
36.         {
    
37.                 for(k=0;k<i-1;k++)
    
38.                 if(strcmp(b[k],b[k+1])>0)
    
39.                 {
    
40.                         temp=b[k]; b[k]=b[k+1]; b[k+1]=temp;
    
41. 
    
42.                 }
    
43.         }
    
44. }
    

复制代码

ANDES

haiouda 发表于 2015-3-19 14:41
这个的缺点是：1）不输入1000个字串不能退出（这个可以自己解决）；
                             ...

改变 XX 的值就行了，不要1000，这样就可以了。一对一的赋值是对的，好像这样最简单。  建议代码打完要把每行代码都进行注释，方便别人阅读你的代码。

haiouda

1. #include <stdio.h>
   
2. #include <string.h>
   
3. #define xx 1000
   
4. int main()
   
5. {
   
6.         void pxx(char *b[],int n);    //声明函数 用于从小到大排列数组
   
7.         int i,k;
   
8.         char p[xx][30],*a[xx];
   
9. 
   
10.         printf("请输入字符串，按下回车表示一个字符串输入完毕，连续按三次回车表示所有字符串输入完毕：");
    
11.         for (i=0;i<xx;i++)
    
12.         {
    
13.                 a[i]=p[i];                //二次数组与指针数组建立关系
    
14.                
    
15.                
    
16.                 for (k=0;k<30;k++)         //输入字符串
    
17.                 {
    
18.                         p[i][k]=getchar();
    
19.                         if(p[i][k]=='\n')      //每一次回车，表明一个字符串输入完成
    
20.                         {
    
21.                                 p[i][k]='\0';
    
22.                                 break;
    
23.                         }
    
24.                 }
    
25.                 if ( a[i]=="" && a[i-1]=="" && a[i-2]=="")
    
26.                 {
    
27.                         break;
    
28.                 }
    
29.                
    
30.                         
    
31.         }
    
32.         
    
33.         printf("\n\n");
    
34.         pxx(a,xx);
    
35.         
    
36.         
    
37.         
    
38.         for (i=0;i<xx;i++)         //打印排序后的字符串
    
39.         {
    
40.                 printf("%s\n",a[i]);
    
41.                
    
42.         }
    
43.         printf("\n");
    
44.         
    
45.         return 0;
    
46.         
    
47. }
    
48. 
    
49. void pxx(char *b[],int n)     //函数定义
    
50. {
    
51.         int i,k;
    
52.         char *temp;
    
53.         for (i=n;i>0;i--)
    
54.         {
    
55.                 for(k=0;k<i-1;k++)
    
56.                         if(strcmp(b[k],b[k+1])>0)
    
57.                         {
    
58.                                 temp=b[k]; b[k]=b[k+1]; b[k+1]=temp;
    
59.                                 
    
60.                         }
    
61.         }
    
62. }

复制代码

lightninng

haiouda 发表于 2015-3-19 21:51

看楼上的贴子，不一定对，不过我尽力了，在学python手头没有c的编译环境，所以楼主自己试一下吧~

haiouda

lightninng 发表于 2015-3-19 23:32
看楼上的贴子，不一定对，不过我尽力了，在学python手头没有c的编译环境，所以楼主自己试一下吧~

谢谢回复；
终于有思路了 :handshake
看来只有继续看下去，不停留在针指这里才能找到解决的方法，不过有思路就好 {:1_1:}

lightninng

haiouda 发表于 2015-3-20 08:42
谢谢回复；
终于有思路了
看来只有继续看下去，不停留在针指这里才能找到解决的方法，不过 ...

恩。c语言字符串和指针的部分是精华。但是也是难点。基本难一点的问题都出在这里。我觉得我的方法可能还是有些问题。给你回答问题自己了学到了很多。一起加油吧~~