请教：按照输入字符串的第一个单词的长度将字符串排序

mcmay

各位达人，最近做一个练习题，当中有个题目要求按照输入字符串的第一个单词的长度将整个字符串按照从小到大的顺序来排列，例如，输入了以下10个字符串：
Like your life.
Protecting your dignity.
Your parents love you.
Love your hobby.
The child is cute.
Complete your work.
Loading data.
Long for your things.
Shut down your computer.
system.

排列的结果应为：
The child is cute.
Like your life.
Your parents love you.
Love your hobby.
Long for your things.
Shut down your computer.
Loading data.
system.
Complete your work.
Protecting your dignity.

我按照自己的理解写了如下实现，不过并未达到预期效果。

1. 
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. #include <ctype.h>
   
5. 
   
6. #define MAX 81
   
7. #define SIZE 10
   
8. 
   
9. void srt_str_fstwdlen(char *ar[], int n);
   
10. 
    
11. int main(void)
    
12. {
    
13.     char str[SIZE][MAX];
    
14.     int choice, i = 0;
    
15.     char * ptr[SIZE];
    
16. 
    
17.     printf("Input %d strings (to quit, press Enter at the beginning of a line):\n", SIZE);
    
18.     while( i < SIZE  && gets(str[i]) != NULL && str[i][0] != '\0')
    
19.     {
    
20.          ptr[i] = str[i];  //用ptr[i]拷贝源字符串的指针以便传送给srt_str_fstwdlen()
    
21.          i++;
    
22.     }
    
23.     if(str[0] != NULL)
    
24.         srt_str_fstwdlen(ptr, i);
    
25. 
    
26.     puts("Done!");
    
27.     return 0;
    
28. }
    
29. 
    
30. void srt_str_fstwdlen(char *ar[], int n)
    
31. {
    
32.     int i , j;
    
33.     char * temp;
    
34.     char wd[SIZE][MAX];  //用以收集每个字符串中的第一个单词
    
35. 
    
36.     for(i = 0; i < n; i++)
    
37.             for(j = 0; j < MAX; j++)
    
38.             {
    
39.                 if(isspace(ar[i][j]))
    
40.             {
    
41.                 wd[i][j] = '\0';    //将从源字符串拷贝过来的字符形成字符串
    
42.                 break;
    
43.             }
    
44.                 wd[i][j] = ar[i][j];
    
45.             }
    
46.    for(i = 0; i < n - 1; i++)        //排序过程
    
47.    {
    
48.            for(j = i + 1; j < n; j++)
    
49.                if(strlen(wd[i]) > strlen(wd[j]))
    
50.             {
    
51.                temp = ar[i];                           //由于wd[i]中的字符串的顺序与ar[i]中
    
52.                ar[i] = ar[j];                         //字符串的顺序相同，因此尝试用wd[i]字符串
    
53.                ar[j] = temp;                       //的长度比较作为条件，然后实际对ar[i]中
    
54.             }                                             //的字符串进行换位以达到排序的目的。但是，
    
55.     }                                                   //看来问题就是出在这里了。  
    
56.    puts("\nAfter sorting:");
    
57.    for(i = 0; i < n; i++)
    
58.        puts(ar[i]);
    
59. }

复制代码

以上代码中应该是排序的做法不对，请各位指点一下应该如何处理。谢谢！

lxyscls

这种排序还真是蛋疼啊

sqfasd

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. int first_word_len(const char* str) {
   
6.   int len = 0;
   
7.   while (*str != '\0' && *str != ' ') {
   
8.     len++;
   
9.     str++;
   
10.   }
    
11.   return len;
    
12. }
    
13. 
    
14. int compare(const void* left, const void* right) {
    
15.   return first_word_len(*(char* const*)left) >
    
16.          first_word_len(*(char* const*)right);
    
17. }
    
18. 
    
19. int main() {
    
20.   char* lines[] = {
    
21.     "Like your life.",
    
22.     "Protecting your dignity.",
    
23.     "Your parents love you.",
    
24.     "Love your hobby.",
    
25.     "The child is cute.",
    
26.     "Complete your work.",
    
27.     "Loading data.",
    
28.     "Long for your things.",
    
29.     "Shut down your computer.",
    
30.     "system.",
    
31.   };
    
32.   int len = sizeof(lines) / sizeof(char*);
    
33.   int i;
    
34.   qsort(lines, len, sizeof(char*), compare);
    
35.   for (i = 0; i < len; ++i) {
    
36.     puts(lines[i]);
    
37.   }
    
38.   return 0;
    
39. }
    

复制代码

bikong0411

qsort好牛逼

晓得飞天千秋雪

mcmay 发表于 2013-07-11 14:02
各位达人，最近做一个练习题，当中有个题目要求按照输入字符串的第一个单词的长度将整个字符串按照从小到大 ...

为设么“system.”要排在“Loading data.”后呢？不是说好了是第一个单词的长度吗？所以此问题给出的示例结果有问题。另外，应该说明，如果两字符串的第一个单词的长度相等，则谁先谁后无所谓。

我的程序参见：http://kan.weibo.com/con/3599341697235962?_from=title

mcmay

感谢楼上诸兄参与本帖的讨论，特别是sqfasd和晓得飞天千秋雪二位还特别给出解决方案。sqfasd兄的解决方案似乎未能达到题目要求的结果，这一点经晓得飞天千秋雪兄测试也是如此。晓得飞天千秋雪兄在自己的微博中给出了他的解法，经过测试，可以说是比题目要求的结果还要准确。后来诸君可循其帖中给出的网址观之。在此，我也将CSDN上网友的一解贴出，以供参考。
#include <stdio.h>
#include <string.h>
#include <ctype.h>

#define MAX 81
#define SIZE 10

void srt_str_fstwdlen(char *ar[], int n);

int main(void)
{
    char str[SIZE][MAX];
    int choice, i = 0;
    char * ptr[SIZE];

    printf("Input %d strings (to quit, press Enter at the beginning of a line):\n", SIZE);
    while( i < SIZE  && gets(str[i]) != NULL && str[i][0] != '\0')
    {
         ptr[i] = str[i];  //用ptr[i]拷贝源字符串的指针以便传送给srt_str_fstwdlen()
         i++;
    }
    if(str[0] != NULL)
        srt_str_fstwdlen(ptr, i);

    puts("Done!");
    return 0;
}
void srt_str_fstwdlen(char *ar[], int n)
{
    int i , j, k;
    char * temp;
    char wd[SIZE][MAX];  //用以收集每个字符串中的第一个单词
    char tmp[81];    //

    for(i = 0; i < n; i++){
        for(j = 0; j < MAX; j++)
        {
            if(isspace(ar[i][j]))
            {
                wd[i][j] = '\0';    //将从源字符串拷贝过来的字符形成字符串
                break;
            }
            wd[i][j] = ar[i][j];
        }
   }
   for(i = 0; i < n - 1; i++)        //排序过程
   {
        for(j = i + 1; j < n; j++){
            if(strlen(wd[i]) > strlen(wd[j]))
            {
                       temp = ar[i];                       //由于wd[i]中的字符串的顺序与ar[i]中
               ar[i] = ar[j];                      //字符串的顺序相同，因此尝试用wd[i]字符串
               ar[j] = temp;                       //的长度比较作为条件，然后实际对ar[i]中

               strcpy(tmp,wd[i]);                  //比较的条件也要换位置，要不会出现重复比较
               strcpy(wd[i],wd[j]);
                       strcpy(wd[j],tmp);

            }
        }
    }
   puts("\nAfter sorting:");
   for(i = 0; i < n; i++)
       puts(ar[i]);   //注意这里
}

谢谢各位继续参与讨论！

djsxut

只是看单词长度，不需要比较同样长度顺序的话， 读进来就判断一下首字母长度，再存入一个指示长度的链表也行。不需要排序。

cobras

1. 
   
2. #include <ctype.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. 
   
6. #define LENGTH(a) (sizeof(a)/sizeof((a)[0]))
   
7. 
   
8. int get_first_word_length(const char *s)
   
9. {
   
10.         int i;
    
11. 
    
12.         if (s != NULL) {
    
13.                 for (i = 0; s[i] != '\0'; ++i) {
    
14.                         if (!isalpha(s[i])) {
    
15.                                 break;
    
16.                         }
    
17.                 }
    
18.                 return i;
    
19.         }
    
20.         return 0;
    
21. }
    
22. 
    
23. int first_word_length_compare(const char **s1, const char **s2)
    
24. {
    
25.         int len1;
    
26.         int len2;
    
27. 
    
28.         len1 = get_first_word_length(*s1);
    
29.         len2 = get_first_word_length(*s2);
    
30.         if (len1 < len2) {
    
31.                 return -1;
    
32.         }else if (len1 > len2) {
    
33.                 return 1;
    
34.         }
    
35.         return 0;
    
36. }
    
37. 
    
38. int main(void)
    
39. {
    
40.         static const char *table[] =
    
41.         {
    
42.                 "Like your life.",
    
43.                 "Protecting your dignity.",
    
44.                 "Your parents love you.",
    
45.                 "Love your hobby.",
    
46.                 "The child is cute.",
    
47.                 "Complete your work.",
    
48.                 "Loading data.",
    
49.                 "Long for your things.",
    
50.                 "Shut down your computer.",
    
51.                 "system.",
    
52.         };
    
53.         int i;
    
54. 
    
55.         qsort((char**)table, LENGTH(table), sizeof(char*), first_word_length_compare);
    
56.         for (i = 0; i < LENGTH(table); ++i) {
    
57.                 puts(table[i]);
    
58.         }
    
59.         return 0;
    
60. }
    

复制代码

cobras

加了点，若长度相等，则按首单词字母顺序排列。

1. 
   
2. #include <ctype.h>
   
3. #include <stdio.h>
   
4. #include <stdlib.h>
   
5. #include <string.h>
   
6. 
   
7. #define LENGTH(a) (sizeof(a)/sizeof((a)[0]))
   
8. 
   
9. int get_first_word_length(const char *s)
   
10. {
    
11.         int i;
    
12. 
    
13.         if (s != NULL) {
    
14.                 for (i = 0; s[i] != '\0'; ++i) {
    
15.                         if (!isalpha(s[i])) {
    
16.                                 break;
    
17.                         }
    
18.                 }
    
19.                 return i;
    
20.         }
    
21.         return 0;
    
22. }
    
23. 
    
24. int first_word_length_compare(const char **s1, const char **s2)
    
25. {
    
26.         int len1;
    
27.         int len2;
    
28. 
    
29.         len1 = get_first_word_length(*s1);
    
30.         len2 = get_first_word_length(*s2);
    
31.         if (len1 < len2) {
    
32.                 return -1;
    
33.         }else if (len1 > len2) {
    
34.                 return 1;
    
35.         }
    
36.         return strncmp(*s1, *s2, len1);
    
37. }
    
38. 
    
39. int main(void)
    
40. {
    
41.         static const char *table[] =
    
42.         {
    
43.                 "Like your life.",
    
44.                 "Protecting your dignity.",
    
45.                 "Your parents love you.",
    
46.                 "Love your hobby.",
    
47.                 "The child is cute.",
    
48.                 "Complete your work.",
    
49.                 "Loading data.",
    
50.                 "Long for your things.",
    
51.                 "Shut down your computer.",
    
52.                 "system.",
    
53.         };
    
54.         int i;
    
55. 
    
56.         qsort((char**)table, LENGTH(table), sizeof(char*), first_word_length_compare);
    
57.         for (i = 0; i < LENGTH(table); ++i) {
    
58.                 puts(table[i]);
    
59.         }
    
60.         return 0;
    
61. }
    

复制代码