链表的练习

最新推荐文章于 2024-07-12 16:35:20 发布

weixin_30856725

最新推荐文章于 2024-07-12 16:35:20 发布

阅读量113

点赞数

文章标签：数据结构与算法面试

原文链接：http://www.cnblogs.com/shangyu/archive/2012/03/11/2390544.html

版权

001_02

时间限制： 1000 ms | 内存限制： 65535 KB

描述

合并数列

给定两个非降序排列的数列A，B。数列中元素的值为int, 元素个数不超过1,000。将两个已排序的数列合并成一个非升序的数列输出。

[Any Problem: trueshlqsh@gmail.com ||dengdong1211@sse.buaa.edu.cn|| oeddyo@gmail.com]

输入

输入有3m+1行。第一行为测试数据的组数m。下面的3m分别为m组测试数据，每组测试数据的第一行包括a，b两个数，表示接下来两行分别有a个数和b个数，接下来数列A B占两行，每个数列中的元素用空格隔开。

输出

输出有m行，对应输入的m组测试数据输出合并后的非升序数列，元素之间用空格隔开。

样例输入

样例输出

10 9 8 7 6 5 4 3 2 1
-1 -2 -9 -10

View Code

 1 #include<stdio.h>
 2 #include<malloc.h>
 3 typedef struct node
 4 {
 5     int data;
 6     struct node *next;
 7 }st;
 8 st *creat(int n)
 9 {
10     st *p,*head;
11     head = (st *)malloc(sizeof(st));
12     head->next = NULL;
13     while(n--)
14     {
15         p = (st *)malloc(sizeof(st));
16         scanf("%d", &p->data);        
17         p->next = head->next; 
18         head->next = p;
19     }
20     return head;
21 }
22 void traverse(st *head)
23 {
24     st *p ;
25     int i = 0;
26     p = head->next ;
27     while(p)
28     {
29         i++ ;
30         if(i!=1)
31             printf(" ") ;
32         printf("%d",p->data);
33         p = p->next ;
34     }
35     puts("");
36 }
37 void merge(st*head1,st*head2)
38 {
39     st *p,*q,*tail;
40     p = head1->next;
41     q = head2->next;
42     head1->next = NULL;
43     tail = head1 ;
44     free(head2);
45     while(q&&p)
46     {
47         if(q->data<p->data)
48         {
49             tail->next = p;
50             tail = p ;
51             p = p->next ;
52         }
53         else
54         {
55             tail->next = q;
56             tail = q ;
57             q = q->next ;
58         }
59     }
60     if(p)
61         tail->next = p;
62     else
63         tail->next = q;
64     traverse(head1);
65 }
66 int main()
67 {
68     st *head1,*head2;
69     int t,n,a,b;
70     scanf("%d", &t);
71     while(t--)
72     {
73         scanf("%d%d", &a,&b);
74         head1 = creat(a);
75         head2 = creat(b);
76         merge(head1,head2);
77     }
78     return 0;
79 }

001_03

时间限制： 1000 ms | 内存限制： 65535 KB

描述

逆转链表

给定一个链表A(a0, a1, …, an-2,an-1)，实现一个链表的逆转操作，得到A’(an-1, an-2, …,a1, a0)。对于有n个元素的线性表，你的算法的运行时间最好应为O(n)。链表中元素为int, 元素个数<N<1,000，要求用链表实现，检查代码。

[Any Problem: trueshlqsh@gmail.com ||dengdong1211@sse.buaa.edu.cn|| oeddyo@gmail.com]

输入

输入有2m+1行。第一行为测试数据的组数m。下面的2m行分别为m组测试数据,每组测试数据的第一行为链表元素个数，下面一行为各个元素，链表中的元素用空格隔开。

输出

输入有m行，对应输入的m组测试数据输出逆转后的链表，元素之间用空格隔开。

样例输入

2
10
1 2 3 4 5 6 7 8 9 10
1
1

样例输出

10 9 8 7 6 5 4 3 2 1
1

View Code

 1 #include<stdio.h>
 2 #include<malloc.h>
 3 typedef struct node
 4 {
 5     int data ;
 6     struct node *next ;
 7 }st ;
 8 st *creat(int n)
 9 {
10     st *head,*p,*tail ;
11     head = (st *)malloc(sizeof(st));
12     head->next = NULL;
13     tail = head ;
14     while(n--)
15     {
16         p = (st *)malloc(sizeof(st));
17         scanf("%d", &p->data);
18         tail->next = p ;
19         tail = p ;
20         tail->next = NULL;
21     }
22     return head ;
23 }
24 void traverse(st *head)
25 {
26     st *p ;
27     int i = 0 ;
28     p = head->next ;
29     while(p)
30     {
31         i++ ;
32         if(i!=1)
33             printf(" ");
34         printf("%d", p->data);
35         p = p->next ;
36     }
37     puts("");
38 }
39 void reverse(st *head)
40 {
41     st *p,*q;
42     p = head->next ;
43     head->next = NULL;
44     q = p->next ;
45     while(p!=NULL)
46     {
47         p->next = head->next ;
48         head->next = p;
49         p = q ;
50         if(q!=NULL)
51             q = q->next;
52     }
53     traverse(head);
54 }
55 int main()
56 {
57     st *head ;
58     int t,n ;
59     scanf("%d", &t);
60     while(t--)
61     {
62         scanf("%d", &n);
63         head = creat(n);
64         reverse(head);
65     }
66     return 0;
67 }

(基础题)元素的删除

时间限制： 1000 ms | 内存限制： 2000 KB

描述

给出一个单链表，删除其中的第i个元素（请注意考虑首尾的情况）

示例输入

（必须用链表做否则不得分）

输入

共T组数据。

其后的每组中，N为元素个数。

接着是N个元素，然后是待删元素编号i

输出

输出删除后的链表

样例输入

样例输出

2 3

View Code

 1 #include<stdio.h>
 2 #include<malloc.h>
 3 typedef struct node
 4 {
 5     int data;
 6     struct node *next;
 7 }st;
 8 st *creat(int n)
 9 {
10     st *head,*p,*tail;
11     head = (st *)malloc(sizeof(st));
12     head->next = NULL;
13     tail = head ;
14     while(n--)
15     {
16         p = (st *)malloc(sizeof(st));
17         scanf("%d", &p->data);
18         tail->next = p ;
19         tail = p;
20         tail->next = NULL;
21     }
22     return head ;
23 }
24 st *del(st *head,int i)
25 {
26     st *p,*q;
27     i--;
28     q = head;
29     p = q->next ;
30     if(i == 0)
31     {        
32         q->next = p->next;
33         free(p);
34     }
35     else
36     {
37         q = p;
38         while(p!=NULL)
39         {
40             p = q->next;
41             i--;
42             if(i == 0)
43             {        
44                 q->next = p->next;
45                 free(p);
46             }
47             else
48                 q = p;            
49         }
50     }
51     return head;
52 }
53 void traverse(st *head)
54 {
55     st *p;
56     int i = 0;
57     p = head->next;
58     while(p)
59     {
60         if(i!=0)
61             printf(" ");
62         printf("%d", p->data);
63         p = p->next ;
64         i++;
65     }
66     puts("");
67 }
68 int main()
69 {
70     st *head,*head1 ;
71     int t,n,i;
72     scanf("%d", &t);
73     while(t--)
74     {
75         scanf("%d", &n);
76         head = creat(n);
77         scanf("%d", &i);
78         head1 = del(head,i) ;
79         traverse(head1);
80     }
81     return 0;
82 }

真题之清华面试篇

时间限制： 1000 ms | 内存限制： 2000 KB

描述

给定单链表头结点，删除链表中倒数第k个结点。

提示：

使用两个节点p1,p2，p1初始化指向头结点，p2一直指向p1后第k个节点，两个结点平行向后移动直到p2到达链表尾部(NULL),然后根据p1删除对应结点。

要求：

练习一下指针链表的使用，要求使用链表做

输入

第一行两个整数K,N表示有N个数据，请删除倒数第K个数据

第二行包含K个数据；

输出

输出删除后的数组

样例输入

1 3
1 2 3

样例输出

1 2

View Code

 1 #include<stdio.h>
 2 #include<malloc.h>
 3 typedef struct node
 4 {
 5     int data;
 6     struct node *next;
 7 }st;
 8 st *creat(int n)
 9 {
10     st *head,*p,*tail;
11     head = (st *)malloc(sizeof(st));
12     head->next = NULL;
13     tail = head ;
14     while(n--)
15     {
16         p = (st *)malloc(sizeof(st));
17         scanf("%d", &p->data);
18         tail->next = p ;
19         tail = p;
20         tail->next = NULL;
21     }
22     return head ;
23 }
24 st *del(st *head,int i)
25 {
26     st *p,*q;
27     i--;
28     q = head;
29     p = q->next ;
30     if(i == 0)
31     {        
32         q->next = p->next;
33         free(p);
34     }
35     else
36     {
37         q = p;
38         while(p!=NULL)
39         {
40             p = q->next;
41             i--;
42             if(i == 0)
43             {        
44                 q->next = p->next;
45                 free(p);
46                 break ;
47             }
48             else
49                 q = p;            
50         }
51     }
52     return head;
53 }
54 void traverse(st *head)
55 {
56     st *p;
57     int i = 0;
58     p = head->next;
59     while(p)
60     {
61         if(i!=0)
62             printf(" ");
63         printf("%d", p->data);
64         p = p->next ;
65         i++;
66     }
67     puts("");
68 }
69 int main()
70 {
71     st *head,*head1 ;
72     int t,n,k;
73     scanf("%d%d", &k,&n);
74     head = creat(n);
75     head1 = del(head,n-k+1) ;
76     traverse(head1);
77     return 0;
78 }

链表基础练习题(1)

时间限制： 1000 ms | 内存限制： 1000 KB

描述

已知线性表，要求删除线性表内的数大于等于MIN，小于等于

MAX的，并输出删除后的线性表

要求：请使用链表做，否则不计成绩！

输入

第一行包含一个数T表示有T组数据

每组数据第一行包含3个数字N,MIN,MAX，分别表示有N个数据，删除范围为MIN-MAX

第二行包含初始的N个数据

输出

输出删除数据后的线性表

样例输入

样例输出

3
1 1 1 1 1

View Code

 1 #include<stdio.h>
 2 #include<malloc.h>
 3 struct node 
 4 {
 5     int data;
 6     struct node *next;
 7 };
 8 struct node *input(int n)
 9 {
10     int i;
11     struct node *head,*tail,*p;
12     head=((struct node *)malloc(sizeof(struct node)));
13     head->next=NULL;
14     tail=head;
15     for(i=1;i<=n;i++)
16     {
17         p=((struct node *)malloc(sizeof(struct node)));
18         scanf("%d",&p->data);       
19         tail->next=p;
20         tail=p;
21         p->next=NULL;
22     }
23     return head;
24 }
25 int main()
26 {
27     int n,min,max,i;
28     int m,j,t;
29     struct node *head,*p,*tail,*q;
30     scanf("%d",&m);
31     for(j=1;j<=m;j++)
32     {
33         scanf("%d%d%d",&n,&min,&max);
34         head=input(n);
35         p=head;
36         while(p->next!=NULL)
37         {
38             if(p->next->data>=min&&p->next->data<=max)
39             {
40                 q=p->next;
41                 p->next=q->next;
42                 free(q);
43             }
44             else p=p->next;
45         }
46         i = 0;
47         p = head->next ;
48         if(p!=NULL)
49         {
50             while(p->next)
51             {
52                 printf("%d ", p->data);
53                 p = p->next;
54             }
55             printf("%d\n", p->data);
56         }
57     }
58     return 0;
59 }

002_03 圆桌问题

时间限制： 2000 ms | 内存限制： 65535 KB

描述

圆桌问题
编号为1—n的n个人围坐在圆桌前，从第一个人开始报数，以1开始，报数为常数m的人离开桌子。n<=10000, m<100
下个人接着从1开始报数，依次重复进行下去，直到全部人都离开桌子。
要求输出各位离开的编号次序。

输入

输入一共有t+1行。第一行为测试数据的组数t，下面的t行分别对应t组测试数据。每行为人数n和报数值m，两个数用空格隔开

输出

输出一共有m行，分别对应m组测试数据。输出离开座位的编号次序，编号之间用空格隔开。

样例输入

1
10 2

样例输出

2 4 6 8 10 3 7 1 9 5

View Code

 1 #include<stdio.h>
 2 #include<malloc.h>
 3 typedef struct node 
 4 {
 5     int data;
 6     struct node *next ;
 7 }st;
 8 st *q;
 9 st *creat(int n)
10 {
11     st *head,*tail,*p;
12     int i ;
13     head = (st *)malloc(sizeof(st));
14     head->data = 1;
15     head->next = NULL;
16     tail = head ;
17     for(i = 2 ; i <= n ; i++)
18     {
19         p = (st *)malloc(sizeof(st));
20         p->data = i ;
21         tail->next = p ;
22         tail = p;
23         tail->next = NULL;
24     }
25     q = tail;
26     tail->next = head ;
27     return head ;
28 }
29 void sel(st *head,int m,int n)
30 {
31     int count = 0,i = 0,j = 0;
32     st *p;
33     while(count<n-1)
34     {
35         p = q->next ;
36         j++;
37         if(j%m == 0)
38         {
39             i++;
40             if(i!=1)
41                 printf(" ");            
42             q->next = p->next ;
43             printf("%d",p->data);        
44             free(p);
45             count ++;
46         }
47         else
48         q = p;
49     }
50     printf(" %d\n",q->data);
51 }
52 int main()
53 {
54     int m,n,t ;
55     st *head;
56     scanf("%d", &t);
57     while(t--)
58     {
59         scanf("%d%d", &n,&m);
60         head = creat(n);
61         sel(head,m,n);
62     }
63     return 0;
64 }

转载于:https://www.cnblogs.com/shangyu/archive/2012/03/11/2390544.html

weixin_30856725

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
链表的练习

001_02时间限制：1000 ms | 内存限制：65535 KB描述合并数列给定两个非降序排列的数列A，B。数列中元素的值为int, 元素个数不超过1,000。将两个已排序的数列合并成一个非升序的数列输出。[Any Problem: trueshlqsh@gmail.com ||dengdong1211@sse.buaa.edu.cn||...
复制链接

扫一扫