求指教，输入一个食物名称，按序显示，最后显示部分弄不好。

lzgw

/* 习题要求创建一个餐馆结构,对于给定食物,要按最小花费显示出所有餐馆*/

#include <stdio.h>
#include <malloc.h>

typedef struct uct_food //食物结构体，用来创建餐馆内食物链表
{
        char food_name[10];   //食物名称
        int food_price;       //食物价格
        struct uct_food * next; //链表尾节点指针
} FOOD;

typedef struct uct_eatery  //餐馆结构体 ，用来创建餐馆链表
{
        char eatery_name[10];    //餐馆名称
        char eatery_address[10]; //餐馆地址
        FOOD * food_head;        //食物链表头指针
        struct eatery * next;    //链表尾节点指针
}EATERY;

typedef EATERY eatery;  //自定义

eatery * input();    //函数声明
void print(eatery * p, char * c); //函数声明

void main()
{
        eatery * head;   //餐馆指针
        char f[10];   //存放查找的食物名称
        printf("****************\n"
                   "* 商铺管理系统 *\n"
                   "****************\n");
        head = input();  //输入餐馆信息，返回头指针
        scanf("%s", f);  //输入查找食物
        fflush(stdin);   //清空缓冲区
        print(head, f);
#if(0)                //测试部分,可忽略
        while(head != NULL)
        {
                printf("%s餐馆，地址%s，", head->eatery_name, head->eatery_address);
                while(head->food_head != NULL)
                {
                        printf("食物%s，价格%d， ", head->food_head->food_name, head->food_head->food_price);
                        head->food_head = head->food_head->next;
                }
                printf("\n");
                head = head->next;
        }
#endif
}

eatery * input()
{
        eatery * p_food, * p_food_1, *p_food_head;  //餐馆指针
        FOOD * p, *p1;     //食物指针
        char temp[10];     //临时字符数组
        int count = 0, food_count;  //餐馆计数器清零，食物计数器待用
        int a;
        do
        {
                if((p_food = malloc(sizeof(eatery))) == NULL)  //分配链表空间
                        printf("%d号空间分配失败", count);
                if(count == 0)
                                p_food_head = p_food_1 = p_food;  //判断是否是头结点
                else               
                {
                        p_food_1->next = p_food;    //不是头结点则连接餐馆链表
                        p_food_1 = p_food;
                }
                printf("%d号餐馆名称：\n", count++);   //取值部分
                gets(temp);
                strcpy(p_food->eatery_name, temp);
#if(1)
                printf("%s餐馆地址：\n", p_food->eatery_name);
                gets(temp);
                strcpy(p_food->eatery_address, temp);
#endif
                food_count = 0;          //食物计数器清零
                do                                         //偷懒了，应该建立调用函数的  %>_<%
                {
                        if((p = malloc(sizeof(FOOD))) == NULL) //分配结点空间
                                printf("%d号空间分配失败", count);
                        if(food_count ==0)     //判断是否是头结点
                                p_food->food_head = p1 = p;
                        else                   //不是头结点则连接食物链表
                        {
                                p1->next = p;
                                p1 = p;
                        }
                        printf("%s餐馆No.%d食物名称：\n", p_food->eatery_name, food_count++);  //取值部分
                        gets(temp);
                        strcpy(p->food_name, temp);
                        printf("价格：\n");
                        gets(temp);
                        p->food_price = atoi(temp);
                        printf("食物输入完毕请按0, 继续输入请按任意键\n");  //询问食物部分是否继续录入
                        scanf("%d", &a);
                        fflush(stdin);      //清空缓冲区
                        if(a == 0)          //结束录入则next指向NULL
                        {
                                p1->next = NULL;
                        }
                }while(a);  //a为0则结束循环
                printf("餐馆输入完毕请按0, 继续输入请按任意键\n");  //询问餐馆部分是否继续录入
                        scanf("%d", &a);
                        fflush(stdin);
                        if(a == 0)
                        {
                                p_food_1->next = NULL;
                        }
        }while(a);  
        return (p_food_head);  //返回头指针
}

void print(eatery * p, char * c)
{
        static int price = 0;    //此部分原想在另一个函数里赋予需要查找的食物的价格,偷下懒直接归零
        if(p == NULL)            //链表结尾判断
                return;
        while(p->food_head != NULL)   //循环查找所有餐馆
        {
                if(strcmp(p->food_head->food_name, c) == 0)  //判断是否存在要查找的食物
                {
                        if(p->food_head->food_price > price)      //如果价格比最低价格高
                        {
                                print(p->next, c);                    //进入递归循环继续查找
                        }
                       
                        printf("食物%s，价格%d， ", p->food_head->food_name, p->food_head->food_price); //递反显示
                        price = p->food_head->food_price;    //最低价格赋值
                        break;
                }
                p->food_head = p->food_head->next;     //餐馆指针位置后移
        }
        printf("%s餐馆，地址%s。", p->eatery_name, p->eatery_address);  //打印餐馆信息
        printf("\n");  //换行符
}

//最后这个函数弄不好，大神帮忙，用递归或迭代实现都可以，求指教。

代码农民

我也作为练习，写了一些代码...

1. /* CanGuan.h */
   
2. struct Node_CanGuan;
   
3. typedef Node_CanGuan CanGuan;
   
4. 
   
5. struct Node_ShiWu;
   
6. typedef Node_ShiWu ShiWu;
   
7. 
   
8. struct Node_Record;
   
9. typedef Node_Record Record;
   
10. 
    
11. Record*
    
12. Create_Record_List();
    
13. Record*
    
14. Create_Next_CanGuan_Record( const char* name, CanGuan* X );
    
15. void
    
16. Insert_Record_List( Record* X, Record* Head );
    
17. void
    
18. Sort_Record_List( Record* Head );
    
19. void
    
20. Print_Record_List( Record* Head );
    
21. void
    
22. Destroy_Record_List( Record* Head );
    
23. 
    
24. 
    
25. 
    

复制代码

1. /* 实现.c */
   
2. #include "CanGuan.h"
   
3. #include <stdio.h>
   
4. #include <string.h>
   
5. #include <stdlib.h>
   
6. /*---------------------------------------------------------------------------*/
   
7. Record*
   
8. Create_Record_List()
   
9. {
   
10.     Record  *p;
    
11. 
    
12.     p = malloc( sizeof( Record ) );
    
13.    
    
14.     return p;
    
15. }
    
16. /*---------------------------------------------------------------------------*/
    
17. Record*
    
18. Create_Next_CanGuan_Record( const char* name, CanGuan* X )
    
19. {
    
20.     CanGuan  *p;
    
21.     ShiWu    *p1;
    
22.     Record   *p2;
    
23.    
    
24.     if( X == NULL || p = X->next == NULL )
    
25.         return NULL;
    
26.    
    
27.     p2 = malloc( sizeof( Record ) );
    
28.     if( p2 == NULL )
    
29.     {
    
30.         printf( "Create_Next_CanGuan_Record运行时内存不足\n" );
    
31.         return NULL;
    
32.     }
    
33. 
    
34.     while( p != NULL )
    
35.        if( p1 = Find_ShiWu( name, p->list ) != NULL )
    
36.        {
    
37.             p2->position = p;
    
38.             p2->price = p1->price;
    
39.             break;
    
40.        }
    
41.        else
    
42.         p = p->next;
    
43. 
    
44.     if( p == NULL )
    
45.     {
    
46.         printf( "没有找到餐馆信息，请重试...\n" );
    
47.         return NULL;
    
48.     }
    
49.     else
    
50.         return p2;
    
51. }
    
52. 
    
53. /*------*/
    
54. static ShiWu*
    
55. Find_ShiWu( const char* name, ShiWu* Head )
    
56. {
    
57.     ShiWu  *p = Head->next;
    
58. 
    
59.     while( p != NULL )
    
60.         if( strcmp( name, p->name ) == 0 )
    
61.             break;
    
62.         else
    
63.             p = p->next;
    
64. 
    
65.     return p;
    
66. }
    
67. /*---------------------------------------------------------------------------*/
    
68. void
    
69. Insert_Record_List( Record* X, Record* Head )
    
70. {
    
71.     Record*  p;
    
72. 
    
73.     if( Head == NULL )
    
74.         return;
    
75.    
    
76.     p = Head;
    
77.     while( p->next != NULL )
    
78.         p = p->next;
    
79. 
    
80.     p->next = X;
    
81.     X->next = NULL;
    
82. }
    
83. /*---------------------------------------------------------------------------*/
    
84. void/* 我用的插入排序法 */
    
85. Sort_Record_List( Record* Head )
    
86. {
    
87.     Record Tmp;
    
88.     Record *a, *b;
    
89. 
    
90.     a = Head->next;
    
91.     while( a != NULL )
    
92.     {
    
93.         b = a->next;
    
94.         while( b != NULL )
    
95.         if( b->price < a->price )
    
96.         {
    
97.             Tmp->price = a->price;
    
98.             a->price = b->price;
    
99.             b->price = Tmp->price;
    
100. 
     
101.             Tmp->position = a->position;
     
102.             a->position = b->position;
     
103.             b->position = Tmp->position;
     
104.         }
     
105.         else
     
106.             b = b->next;
     
107.     }
     
108. }
     
109. /*---------------------------------------------------------------------------*/
     
110. void
     
111. Print_Record_List( Record* Head )
     
112. {
     
113.     Record* p;
     
114. 
     
115.     if( Head == NULL || p = Head->next == NULL )
     
116.     {
     
117.         printf( "记录为空\n" );
     
118.         return;
     
119.     }
     
120. 
     
121.     while( p != NULL )
     
122.     {
     
123.         printf( "价格: %d\n餐馆名称: %s\n餐馆地址: %s\n\n",
     
124.                 p->price, p->position->name, p->position->address );
     
125.         p = p->next;
     
126.     }
     
127. }
     
128. /*---------------------------------------------------------------------------*/
     
129. void
     
130. Destroy_Record_List( Record* Head )
     
131. {
     
132.     Record  *p1, *p2;
     
133. 
     
134.     p1 = Head;
     
135.     p2 = p1->next;
     
136.    
     
137.     while( p1 != NULL )
     
138.     {
     
139.         free( p1 );
     
140.         p1 = p2;
     
141.         p2 = p1->next;
     
142.     }
     
143. }
     

复制代码

1. 
   
2. /* 接口.C */
   
3. 
   
4. #include "CanGuan.h"
   
5. #include <stdio.h>
   
6. /*---------------------------------------------------------------------------*/
   
7. struct Node_ShiWu
   
8. {
   
9.     char*           name[ 20 ];
   
10.     int             price;
    
11.     ShiWu*          next;
    
12. };
    
13. struct Node_CanGuan
    
14. {
    
15.     char*           name[ 20 ];
    
16.     char*           address[ 20 ];
    
17.     ShiWu*          list;  
    
18.     CanGuan*        next;
    
19. };
    
20. struct Node_Record
    
21. {
    
22.     CanGuan*         position;
    
23.     int              price;
    
24.     Record*          next;
    
25. };
    
26. /*---------------------------------------------------------------------------*/
    
27. void
    
28. main()
    
29. {   
    
30.     /* 假设餐馆的头结点是Head */
    
31.     Record    *p;
    
32.     CanGuan   *p1;
    
33.     char*      name[ 20 ];
    
34. 
    
35.     p = Create_Record_List();
    
36.     if( p == NULL )
    
37.     {
    
38.         printf( "Create_Record_list运行时内存不足\n" );
    
39.         return;
    
40.     }
    
41. 
    
42.     while(1)
    
43.         if( scanf( "%s", name ) == 1 )
    
44.             break;
    
45.    
    
46.     p1 = Head;
    
47.     while( p1 != NULL )
    
48.     {
    
49.         p = Create_Next_CanGuan_Record( name, p1 );
    
50.         if( p == NULL )
    
51.             return;
    
52.         
    
53.         Insert_Record_List( p );
    
54.         p1 = p1->next;
    
55.     }
    
56.    
    
57.     Print_Record_List( p );
    
58.     Destroy_Record_List( p );
    
59. }

复制代码

lzgw

代码农民 发表于 2017-1-10 17:54
我也作为练习，写了一些代码...

我也把代码发上来，探讨一下哪个更省事，偷懒没建.h 和.c文件，都放一起了

1. /*商店信息系统
   
2. 以商店为单位按价格
   
3. 由低到高显示所需物品*/
   
4. 
   
5. #include <stdio.h>
   
6. #include <stdlib.h>
   
7. 
   
8. typedef struct b1             //定义内层结构体
   
9. {
   
10.         char          name[10];   //物品名称
    
11.         int           b;                  //物品价格
    
12.         struct b1 *   next;       //内层节点指针
    
13. }b;                           //自定义类型名为b
    
14. typedef struct a1             //定义外层结构体
    
15. {
    
16.         char          a[10];           //商铺名称
    
17.         struct b1 *   head;       //内层结构体头指针
    
18.         struct a1 *   next;       //外层节点指针
    
19. }a;                      //自定义类型名为a；
    
20. typedef a * A;   //自定义a类型指针为A
    
21. 
    
22. A input_c();    //输入外层链表数据
    
23. b * input_i();  //输入内层链表数据
    
24. A paixu(A pai, int num); //对外层链表排序
    
25. void print(A head); //打印链表数据（内外层）
    
26. void print_pai(A head); //打印排序后链表数据（内外层）
    
27. 
    
28. void main()     //主函数
    
29. {
    
30.         int num = 0;   //外层链表节点计数器
    
31.         A head;        //外层链表头指针
    
32.         head = input_c(&num);  //输入函数
    
33.         printf("\n");
    
34.         printf("排序前\n");
    
35.         print(head);           //显示函数
    
36.         head = paixu(head, num);  //排序函数
    
37.         printf("\n");
    
38.         printf("排序后\n");
    
39.         print_pai(head);   //显示函数
    
40. }
    
41. 
    
42. 输入函数略；
    
43. 
    
44. void print(A p_head)   //显示函数
    
45. {
    
46.         A head = p_head;   //设定一个外层链表指针代替头指针,防止指针后移影响其他函数操作
    
47.         b * p;             //设定一个内层链表指针代替头指针,防止指针后移影响其他函数操作
    
48.         while(head)
    
49.         {      
    
50.                
    
51.                 printf("%s店铺  ", head->a); //打印第一个店铺名称
    
52.                 p = head->head;   //内层链表指针赋值
    
53.                 while(p)
    
54.                 {
    
55.                         printf("%s=", p->name); //打印内层物品名称
    
56.                         printf("%d。", p->b);  //打印内层物品价格
    
57.                         p = p->next; //内层链表指针指向下一个节点
    
58.                 }
    
59.                 printf("\n");
    
60.                 head = head->next;   //外层链表指针指向下一个节点
    
61.         }
    
62.         printf("\n");
    
63. }
    
64. 
    
65. void print_pai(A p_head)   //显示函数
    
66. {
    
67.         char temp[10] = "app";  //此处假定查找的物品名，可以用交互式输入代替
    
68.         A head = p_head;   //设定一个外层链表指针代替头指针,防止指针后移影响其他函数操作
    
69.         b * p;             //设定一个内层链表指针代替头指针,防止指针后移影响其他函数操作
    
70.         while(head)
    
71.         {      
    
72.                 p = head->head;   //内层链表指针赋值
    
73.                 while(p && (strcmp(p->name, temp) != 0))//查找是否有要显示的物品
    
74.                         p = p->next;   
    
75.                 if(p && (strcmp(p->name, temp) == 0)) //若有则执行  
    
76.                 {
    
77.                         printf("%s店铺  ", head->a); //打印第一个店铺名称
    
78.                         p = head->head;   //内层链表指针赋值
    
79.                         while(p)
    
80.                         {
    
81.                                 if(strcmp(p->name, temp) == 0)
    
82.                                 {
    
83.                                         printf("%s=", p->name); //打印内层物品名称
    
84.                                         printf("%d。", p->b);  //打印内层物品价格
    
85.                                 }
    
86.                                 p = p->next; //内层链表指针指向下一个节点
    
87.                         }
    
88.                         printf("\n");
    
89.                 }      
    
90.                 head = head->next;  //外层链表指针指向下一个节点
    
91.         }
    
92.         printf("\n");
    
93. }
    
94. #if(0)
    
95. A paixu(A pai, int num)  //排序函数（未完善）
    
96. {
    
97.         A p1,p2,p3;     //设定三个外层指针
    
98.         char temp[10] = "app"; //此处假定查找的物品名，可以用交互式输入代替
    
99.         while(num)
    
100.         {
     
101.                 p3 = p1 = pai;   //p1指向头结点,第一个店铺
     
102.                 p2 = p1->next;   //p2指向p1后的节点，第二个店铺
     
103.                 while(p2)
     
104.                 {
     
105.                         while(p1->head && (strcmp(p1->head->name, temp) != 0))
     
106.                                 p1->head = p1->head->next;
     
107.                         //若没有该物品，则p1->head变成空指针
     
108.                         while(p2->head && (strcmp(p2->head->name, temp) != 0))
     
109.                                 p2->head = p2->head->next;
     
110.                         //若没有该物品，则p2->head变成空指针
     
111.                        
     
112.                         if((p1->head != NULL) && (p2->head != NULL) && (p1->head->b > p2->head->b))  
     
113.                           //  若p1店内有该物品并且p1店铺内的物品价格大于p2店铺的物品价格
     
114.                         {
     
115.                                 p1->next = p2->next;       //p1尾指针指向p2尾指针
     
116.                                 p2->next = p1;             //p2尾指针指向p1
     
117.                                 //此处完成p1和p2的位置交换
     
118.                                 if(p1 == pai)// p1为第一节点的时候
     
119.                                 {
     
120.                                         pai = p3 = p2;   //头指针\p3都指向交换后的p2,(p2和p1已经交换位置)
     
121.                                 }
     
122.                                 else    //p1不是第一个节点的时候
     
123.                                 {
     
124.                                         p3->next = p2;   //p3尾指针指向p2
     
125.                                         p3 = p2;         //p3指向p2,即p3永远指向p1的上一个节点
     
126.                                 }
     
127.                                 p2 = p1->next;   //p2指针指向p1的后一个节点
     
128.                         }
     
129.                         else if((p1->head == NULL) || (p2->head != NULL) && (p1->head->b <= p2->head->b))
     
130.                                    // 若p1店铺内没有该物品，或物品价格小于等于p2店铺的物品价格
     
131.                         {      
     
132.                                 p3 = p1;         //p3指向p1;   p1,p2都后移一个节点
     
133.                                 p2 = p2->next;
     
134.                                 p1 = p1->next;
     
135.                         }
     
136.                 }
     
137.                 num--;
     
138.         }
     
139.         return pai; //返回外层链表头指针
     
140. }
     
141. #else
     
142. A paixu(A pai, int num)  //排序函数（已完善）
     
143. {
     
144.         A p1,p2,p3;     //设定三个外层指针
     
145.         b *        q1, *q2;  //定义2个内层指针
     
146.         char temp[10] = "app";
     
147.         while(num)
     
148.         {
     
149.                 p3 = p1 = pai;   //p1指向头结点,第一个店铺
     
150.                 p2 = p1->next;   //p2指向p1后的节点，第二个店铺
     
151.                
     
152.                 while(p2)
     
153.                 {      
     
154.                         q1 = p1->head;
     
155.                         q2 = p2->head;
     
156.                         while(q1 && (strcmp(q1->name, temp) != 0))
     
157.                                 q1 = q1->next;
     
158.                         //若没有该物品，则p1->head变成空指针
     
159.                         while(q2 && (strcmp(q2->name, temp) != 0))
     
160.                                 q2 = q2->next;
     
161.                         //若没有该物品，则p2->head变成空指针
     
162.                
     
163.                         if(q1 == NULL)  //  若p1店内有该物品并且p1店铺内的物品价格大于p2店铺的物品价格
     
164.                         {
     
165.                                 p3 = p1;         //p3指向p1;   p1,p2都后移一个节点
     
166.                                 p2 = p2->next;
     
167.                                 p1 = p1->next;
     
168.                         }
     
169.                         else if((q1 != NULL) && (q2 == NULL))
     
170.                         {
     
171.                                 p1->next = p2->next;       //p1尾指针指向p2尾指针
     
172.                                 p2->next = p1;             //p2尾指针指向p1
     
173.                                 //此处完成p1和p2的位置交换
     
174.                                 if(p1 == pai)// p1为第一节点的时候
     
175.                                 {
     
176.                                         pai = p3 = p2;   //头指针\p3都指向交换后的p2,(p2和p1已经交换位置)
     
177.                                 }
     
178.                                 else    //p1不是第一个节点的时候
     
179.                                 {
     
180.                                         p3->next = p2;   //p3尾指针指向p2
     
181.                                         p3 = p2;         //p3指向p2,即p3永远指向p1的上一个节点
     
182.                                 }
     
183.                                 p2 = p1->next;   //p2指针指向p1的后一个节点
     
184.                         }
     
185.                         else if((q1 != NULL) && (q2 != NULL))
     
186.                         {
     
187.                                 if(q1->b > q2->b)
     
188.                                 {
     
189.                                         p1->next = p2->next;       //p1尾指针指向p2尾指针
     
190.                                         p2->next = p1;             //p2尾指针指向p1
     
191.                                         //此处完成p1和p2的位置交换
     
192.                                         if(p1 == pai)// p1为第一节点的时候
     
193.                                         {
     
194.                                                 pai = p3 = p2;   //头指针\p3都指向交换后的p2,(p2和p1已经交换位置)
     
195.                                         }
     
196.                                         else    //p1不是第一个节点的时候
     
197.                                         {
     
198.                                                 p3->next = p2;   //p3尾指针指向p2
     
199.                                                 p3 = p2;         //p3指向p2,即p3永远指向p1的上一个节点
     
200.                                         }
     
201.                                         p2 = p1->next;   //p2指针指向p1的后一个节点
     
202.                                 }
     
203.                                 else    //(p1->head->b <= p2->head->b) 若p1店铺内没有该物品，或物品价格小于等于p2店铺的物品价格
     
204.                                 {      
     
205.                                         p3 = p1;         //p3指向p1;   p1,p2都后移一个节点
     
206.                                         p2 = p2->next;
     
207.                                         p1 = p1->next;
     
208.                                 }
     
209.                         }
     
210.                 }
     
211.                 num--;
     
212.         }
     
213.         return pai; //返回外层链表头指针
     
214. }
     
215. #endif

复制代码