实验3-带头结点的单链表

实验1:

 1 /*编写函数void delx(linklist head, datatype x),删除带头结点单链表head中第一个值为x 的结点。
 2 并构造测试用例进行测试。
 3 */
 4 /**********************************/
 5 /*文件名称:lab3_01.c                 */
 6 /**********************************/
 7 #include "slnklist.h"
 8 /*请将本函数补充完整,并进行测试*/
 9 linklist delx(linklist head,datatype x)
10 {
11     linklist p,pre;
12     pre=head;
13     p=head->next;
14     while(p)
15     {
16         if(p->info==x) {pre->next=p->next;free(p);break;}
17         pre=p;
18         p=p->next;
19     }
20     return head;
21 }
22 
23 int main()
24 {   datatype x;
25     linklist head;
26     head=creatbyqueue();        /*尾插入法建立带头结点的单链表*/
27     print(head);
28     printf("请输入要删除的值:");
29     scanf("%d",&x);
30     head=delx(head,x);            /*删除单链表的第一个值为x的结点*/
31     print(head);
32     delList(head);                /*释放单链表空间*/
33     return 0;
34 }

实验2:

 1 /**********************************/
 2 /*文件名称:lab3_02.c                 */
 3 /**********************************/
 4 /*
 5 假设线性表(a1,a2,a3,…an)采用带头结点的单链表存储,请设计算法函数linklist reverse(linklist  head),
 6 将带头结点的单链表head就地倒置,使表变成(an,an-1,…a3.a2,a1)。并构造测试用例进行测试。
 7 */
 8 #include "slnklist.h"
 9 /*请将本函数补充完整,并进行测试*/
10 linklist reverse(linklist head)
11 {
12     int flag=1;
13     linklist p=NULL,q=NULL,r;
14     if(head->next) p=head->next;
15     if(p->next)    q=p->next;
16     while(q)
17     {
18         r=q->next;
19         q->next=p;
20         if(flag)  {p->next=NULL;flag=0;}
21         p=q;
22         q=r;
23     }
24     head->next=p;
25     return head;
26 }
27 int main()
28 {   datatype x;
29     linklist head;
30     head=creatbystack();            /*头插入法建立带头结点的单链表*/
31     print(head);                    /*输出原链表*/
32     head= reverse(head);            /*倒置单链表*/
33     print(head);                    /*输出倒置后的链表*/
34     delList(head);
35     return 0;
36 }

实验3:

 1 /*
 2 假设带头结点的单链表head是升序排列的,设计算法函数linklist insert(linklist head,datatype x),
 3 将值为x的结点插入到链表head中,并保持链表有序性。
 4 分别构造插入到表头、表中和表尾三种情况的测试用例进行测试。
 5 */
 6 /**********************************/
 7 /*文件名称:lab3_03.c                 */
 8 /**********************************/
 9 #include "slnklist.h"
10 /*请将本函数补充完整,并进行测试*/
11 linklist insert(linklist head ,datatype x)
12 {
13     linklist p=NULL,q=NULL,s;
14     s=(linklist)malloc(sizeof(node));
15     s->info=x;
16     p=head->next;
17     q=head;
18     while(p&&p->info<x)
19     {
20         q=p;
21         p=p->next;
22     }
23     q->next=s;
24     s->next=p;
25     return head;
26 }
27 int main()
28 {   datatype x;
29     linklist head;
30     printf("输入一组升序排列的整数:\n");
31     head=creatbyqueue();                /*尾插入法建立带头结点的单链表*/
32     print(head);
33     printf("请输入要插入的值:");
34     scanf("%d",&x);
35     head=insert(head,x);                /*将输入的值插入到带头结点的单链表适当位置*/
36     print(head);
37     delList(head);
38     return 0;
39 }

实验4:

 1 /*
 2 编写算法函数linklist delallx(linklist head, int x),删除带头结点单链表head中所有值为x的结点。
 3 */
 4 /**********************************/
 5 /*文件名称:lab3_04.c                 */
 6 /**********************************/
 7 #include "slnklist.h"
 8 /*请将本函数补充完整,并进行测试*/
 9 linklist delallx(linklist head,int x)
10 {
11     linklist p=NULL,q=NULL,r;
12     p=head->next;
13     q=head;
14     while(p)
15     {
16         if(p->info==x)
17         {
18             r=p->next;
19             q->next=r;
20             free(p);
21             p=r;
22         }
23         else
24         {
25             q=p;
26             p=p->next;
27         }
28     }
29         return head;    
30 }
31 int main()
32 {   datatype x;
33     linklist head;
34     head=creatbyqueue();                /*尾插入法建立带头结点的单链表*/
35     print(head);
36     printf("请输入要删除的值:");
37     scanf("%d",&x);
38     head=delallx(head,x);
39     print(head);
40     delList(head);
41     return 0;
42 }

实验5:

 1 /*
 2 已知线性表存储在带头结点的单链表head中,请设计算法函数void sort(linklist head),将head中的结点按结点值升序排列。
 3 */
 4 /**********************************/
 5 /*文件名称:lab3_05.c                 */
 6 /**********************************/
 7 #include "slnklist.h"
 8 /*请将本函数补充完整,并进行测试*/
 9 void  sort(linklist head)
10 {
11     int temp;
12     linklist p,q;
13     q=p=head->next;
14     for(q;q;q=q->next)
15     {
16         for(p=q;p;p=p->next)
17         {
18             if(p->info<q->info)
19             {
20                 temp=p->info;
21                 p->info=q->info;
22                 q->info=temp;
23             }
24         }
25     }
26     return head;
27 }
28 int main()
29 {        linklist head;
30          head=creatbyqueue();           /*尾插法建立带头结点的单链表*/
31          print(head);                    /*输出单链表head*/
32          sort(head);                     /*排序*/
33          print(head);
34          delList(head);
35          return 0;
36 }

实验6:

 1 /*
 2 已知两个带头结点的单链表L1和L2中的结点值均已按升序排序,设计算法函数
 3 linklist mergeAscend (linklist L1,linklist L2)将L1和L2合并成一个升序的
 4 带头结单链表作为函数的返回结果;
 5 设计算法函数linklist mergeDescend (linklist L1,linklist L2)
 6 将L1和L2合并成一个降序的带头结单链表作为函数的返回结果;
 7 并设计main()函数进行测试。
 8 */
 9 /**********************************/
10 /*文件名称:lab3_06.c                 */
11 /**********************************/
12 #include "slnklist.h"
13 /*请将本函数补充完整,并进行测试*/
14 linklist mergeAscend(linklist L1,linklist L2)
15 {
16     linklist head,q,p,r;
17     head=(linklist)malloc(sizeof(node));
18     head->next=NULL;
19     r=head;
20     q=L1->next;
21     p=L2->next;
22     while(q&&p)
23     {
24         if(q->info<=p->info)
25         {
26             r->next=q;
27             r=q;
28             q=q->next;
29         }
30         else
31         {
32             r->next=p;
33             r=p;
34             p=p->next;
35         }
36     }
37     r->next=q?q:p;
38     return head;
39 }
40 
41 linklist mergeDescend(linklist L1,linklist L2)
42 {
43 }
44 int main()
45 {       linklist h1,h2,h3;
46          h1=creatbyqueue();     /*尾插法建立单链表,请输入升序序列*/
47          h2=creatbyqueue();
48          print(h1);
49          print(h2);
50          h3=mergeAscend(h1,h2);/*升序合并到h3*/
51             /*降序合并请调用h3=mergeDescend(h1,h2); */
52          print(h3);
53          delList(h3);
54          return 0;
55 }

实验7:

 1 /*
 2 设计一个算法linklist interSection(linklist L1,linklist L2),
 3 求两个单链表表示的集合L1和L2的交集,并将结果用一个新的带头
 4 结点的单链表保存并返回表头地址。
 5 */
 6 /**********************************/
 7 /*文件名称:lab3_07.c                 */
 8 /**********************************/
 9 #include "slnklist.h"
10 /*请将本函数补充完整,并进行测试*/
11 linklist   interSection(linklist L1, linklist L2)
12 {
13     linklist head,p,q,s,r;
14     head=(linklist)malloc(sizeof(node));
15     head->next=NULL;
16     r=head;
17     p=L1->next;
18     q=L2->next;
19     for(p;p;p=p->next)
20     {
21         for(q=L2->next;q;q=q->next)
22         {
23             if(q->info==p->info)
24             {
25                 s=(linklist)malloc(sizeof(node));
26                 s->info=p->info;
27                 r->next=s;
28                 r=s;
29                 break;
30             }
31         }
32     }
33     r->next=NULL;
34     return head;
35 }
36 
37 int main()
38 {
39  linklist h1,h2,h3;
40  h1=creatbyqueue();           /*尾插法建立单链表,输入时请勿输入重复数据*/
41  h2=creatbyqueue();
42  print(h1);                   /*输出单链表h1*/
43  print(h2);
44  h3=interSection(h1,h2);      /* 求h1和h2的交集*/
45  print(h3);
46  delList(h1);
47  delList(h2);
48  delList(h3);
49  return 0;
50 }

实验8:

 1 /*
 2 请编写一个算法函数void partion(linklist head),
 3 将带头结点的单链表head中的所有值为奇数的结点调整
 4 到链表的前面,所有值为偶数的结点调整到链表的后面。
 5 */
 6 
 7 /**********************************/
 8 /*文件名称:lab3_08.c             */
 9 /**********************************/
10 #include "slnklist.h"
11 #include<math.h>
12 /*请将本函数补充完整,并进行测试*/
13 void partion(linklist head)
14 {
15     linklist p,s,pre;
16     pre=head;
17     p=head->next;
18     while(p)
19     {
20         if(p->info%2==0)
21         {
22             pre=p;
23             p=p->next;
24         }
25         else
26         {
27             s=p;
28             pre->next=p->next;
29             p=pre->next;
30             s->next=NULL;
31             s->next=head->next;
32             head->next=s;
33         }
34     }
35 
36 }
37 int main()
38 {        linklist head;
39          head=creatbyqueue();           /*尾插法建立带头结点的单链表*/
40          print(head);                   /*输出单链表head*/
41          partion(head);
42          print(head);
43          delList(head);
44          return 0;
45 }

实验9:

 1 /*
 2 编写一个程序,用尽可能快的方法返回带头结点单链表中倒数第k个结点的地址,如果不存在,则返回NULL。
 3 */
 4 /**********************************/
 5 /*文件名称:lab3_09.c             */
 6 /**********************************/
 7 #include "slnklist.h"
 8 /*请将本函数补充完整,并进行测试*/
 9 linklist   search(linklist head,int k)
10 {
11     int count=0,i;
12     linklist p=NULL,q;
13     p=head->next;
14     for(p;p;p=p->next)
15     {
16         count++;
17     }
18     if(count<k) return 0;
19     else
20     {
21         p=head;
22         for(i=1;i<=count-k+1;i++)
23         {
24             p=p->next;
25         }
26     }
27     return p;
28 }
29 int main()
30 {
31      int k;
32      linklist head,p;
33      head=creatbyqueue();        /*尾插法建立带头结点的单链表*/
34      print(head);                  /*输出单链表head*/
35      printf("k=");
36      scanf("%d",&k);
37      p=search(head,k);
38      if (p) printf("%d\n",p->info);
39      else
40          printf("Not Found!\n");
41      delList(head);
42      return 0;
43 }

 头文件:

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 /**************************************/
  4 /* 链表实现的头文件,文件名slnklist.h */
  5 /**************************************/
  6  typedef int datatype;
  7  typedef struct link_node{
  8    datatype info;
  9    struct link_node *next;
 10  }node;
 11 typedef node *linklist;
 12 /******************************************/
 13 /*函数名称:creatbystack()                      */
 14 /*函数功能:头插法建立带头结点的单链表    */
 15 /******************************************/
 16 linklist creatbystack()
 17 {
 18 
 19     linklist  head,s;
 20     datatype x;
 21     head=(linklist)malloc(sizeof(node));
 22     head->next=NULL;
 23 
 24     printf("请输入整数序列(空格分开,以0结束):\n");
 25     scanf("%d",&x);
 26     while (x!=0)
 27     {
 28         s=(linklist)malloc(sizeof(node));
 29         s->info=x;
 30 
 31         s->next=head->next;
 32         head->next=s;
 33 
 34         scanf("%d",&x);
 35     }
 36     return head;
 37 }
 38 /***************************************/
 39 /*函数名称:creatbyqueue()                */
 40 /*函数功能:尾插法建立带头结点的单链表 */
 41 /***************************************/
 42 linklist creatbyqueue()
 43 {
 44     linklist head,r,s;
 45     datatype x;
 46     head=r=(linklist)malloc(sizeof(node));
 47     head->next=NULL;
 48     printf("请输入整数序列(空格分开,以0结束):\n");
 49     scanf("%d",&x);
 50     while (x!=0)
 51     {
 52          s=(linklist)malloc(sizeof(node));
 53          s->info=x;
 54          r->next=s;
 55          r=s;
 56          scanf("%d",&x);
 57    }
 58     r->next=NULL;
 59     return head;
 60 }
 61 /**********************************/
 62 /*函数名称:print()                      */
 63 /*函数功能:输出带头结点的单链表      */
 64 /**********************************/
 65 void print(linklist head)
 66 {
 67     linklist p;
 68     int i=0;
 69     p=head->next;
 70     printf("List is:\n");
 71     while(p)
 72     {
 73         printf("%7d",p->info);
 74         i++;
 75         if (i%10==0)    printf("\n");
 76         p=p->next;
 77     }
 78     printf("\n");
 79 
 80 }
 81 
 82 /******************************************/
 83 /*函数名称:creatLink()                   */
 84 /*函数功能:从文件中读入n个数据构成单链表 */
 85 /******************************************/
 86 linklist creatLink(char *f, int n)
 87 {
 88     FILE *fp;
 89     int i;
 90     linklist s,head,r;
 91     head=r=(linklist)malloc(sizeof(node));
 92     head->next=NULL;
 93     fp=fopen(f,"r");
 94     if (fp==NULL)
 95         return head;
 96     else
 97     {
 98          for (i=0;i<n;i++)
 99             {
100                 s=(linklist)malloc(sizeof(node));
101                 fscanf(fp,"%d",&(s->info));
102                 r->next=s;
103                 r=s;
104             }
105         r->next=NULL;
106         fclose(fp);
107         return head;
108     }
109 }
110 
111 /*
112     函数名称:writetofile
113     函数功能:将链表内容存入文件f
114 */
115 void writetofile(linklist head, char *f)
116 {
117     FILE *fp;
118     linklist p;
119     int i=0;
120     fp=fopen(f,"w");
121     if (fp!=NULL)
122     {
123         p=head->next;
124         fprintf(fp,"%s","List is:\n");
125         while(p)
126         {
127             fprintf(fp,"%7d",p->info);
128             i++;
129             if (i%10==0)    fprintf(fp,"%c",'\n');
130             p=p->next;
131         }
132         fprintf(fp,"%c",'\n');
133         fclose(fp);
134     }
135     else    printf("创建文件失败!");
136 
137 }
138 
139 
140 /**********************************/
141 /*函数名称:delList()                  */
142 /*函数功能:释放带头结点的单链表      */
143 /**********************************/
144 void delList(linklist head)
145 { linklist p=head;
146   while (p)
147   { head=p->next;
148     free(p);
149     p=head;
150   }
151 }

 

转载于:https://www.cnblogs.com/zyb993963526/p/6028323.html

  • 5
    点赞
  • 44
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值