数据结构 - 链表

1.单链表

https://blog.csdn.net/qq_36806987/article/details/79858957

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 
  4 /*结构体部分*/
  5 typedef struct Node
  6 {
  7     int data;   //数值域
  8     struct Node *next;  //指针域
  9 }N;
 10 
 11 N *Init()    //初始化单链表
 12 {
 13     N *n;
 14     n = (N *)malloc(sizeof(N));
 15     n->next = NULL;
 16     return n;
 17 }
 18 
 19 N* Create(N* n)
 20 {
 21     /*通过输入n个数据，创建一个单链表*/
 22     int x;
 23     N *p,*r,*l;
 24     l = r = n;
 25     printf("输入-1结束\n");
 26     scanf("%d",&x);
 27     while(-1 != x )
 28     {
 29         p = (N *)malloc(sizeof(N));
 30         p -> data = x;
 31         p -> next = NULL;
 32         r->next = p;
 33         r = r->next;    //指针r始终指向链表中末数据元素所在位置
 34         scanf("%d",&x);
 35     }
 36     return l;
 37 }
 38 
 39 void output(N* n) //输出
 40 {
 41     N *p;
 42     p = n->next;
 43     while(p)
 44     {
 45         printf("%d ",p->data);
 46         p = p->next;
 47     }
 48     printf("\n");
 49 }
 50 
 51 int InsItem(N *L,int item,int x) /*给定的序号来插入*/
 52 {
 53     int i = 1;
 54     N *p,*t;
 55     p = L;
 56     t = (N *)malloc(sizeof(N));
 57     t ->data = item;
 58     if(L->next==NULL)
 59     {   /*若L为空表且要求将新结点插入到第0个位置*/
 60         if(x==1)
 61             {
 62                 L->next=t;
 63                 t->next=NULL;
 64                 return 1;
 65             }
 66     }
 67     while(p->next!=NULL&&i<x)/*查找第i个节点*/
 68     {
 69         p = p->next;
 70         i++;
 71     }
 72     if(p->next==NULL&&i<x)/*在表中不存在插入位置i ，找不到，则插入操作失败*/
 73     {
 74         return 0;
 75     }
 76     else
 77     {
 78         t->next = p->next;
 79         p->next = t;
 80         return 1;
 81     }
 82 }
 83 
 84 int DelItem(N *L,int x)//在单链表中删除数据元素
 85 {
 86     int i = 1;
 87     N *p,*q;
 88     p = L;
 89     if(L->next==NULL) /*L为空表，无结点可删除*/
 90     {
 91         return 0;
 92     }
 93     while(p->next!=NULL&&i<x)
 94     {
 95         p = p->next;
 96         i++;
 97     }
 98     if(p->next==NULL)/*若没有第i个结点，则删除操作失败*/
 99     {
100         return 0;
101     }
102     else
103     {
104         q = p->next;
105         p->next = p->next->next;
106         free(q);
107         return 1;
108     }
109 }
110 
111 int main()
112 {
113     N* n = Init();
114     n = Create(n);
115     output(n);
116     InsItem(n,5,5);
117     output(n);
118     DelItem(n,5);
119     output(n);
120 
121     return 0;
122 }

2.双链表

https://blog.csdn.net/qq_16933601/article/details/105351119

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 
  4 typedef struct Node{
  5     struct Node *pre;
  6     int data;
  7     struct Node *next;
  8 }N;
  9 
 10 N *Init()
 11 {
 12     N *n;
 13     n=(N*)malloc(sizeof(N));//鍒涘缓閾捐〃绗竴涓粨鐐癸紙棣栧厓缁撶偣锛?
 14     n->next = n->pre=NULL;
 15     return n;
 16 }
 17 
 18 N* Create(N* n)
 19 {
 20    /*通过输入n个数据，创建一个单链表*/
 21     int x;
 22      N *p,*r,*l;
 23      l = r = n;
 24      printf("输入-1结束\n");
 25      scanf("%d",&x);
 26      while(-1 != x )
 27      {
 28          p = (N *)malloc(sizeof(N));
 29          p -> data = x;
 30          p->pre = p -> next = NULL;
 31          r->next = p;
 32          p->pre = r;
 33          r = r->next;    //指针r始终指向链表中末数据元素所在位置
 34          scanf("%d",&x);
 35     }
 36     return l;
 37 }
 38 
 39 void output(N* n) //输出
 40 {
 41      N *p;
 42      p = n->next;
 43      while(p)
 44      {
 45          printf("%d ",p->data);
 46          p = p->next;
 47      }
 48      printf("\n");
 49 }
 50 
 51 int InsItem(N *L,int item,int x) /*给定的序号来插入*/
 52 {
 53     int i = 1;
 54     N *p,*t;
 55     p = L;
 56     t = (N *)malloc(sizeof(N));
 57     t ->data = item;
 58     if(L->next==NULL)
 59     {   /*若L为空表且要求将新结点插入到第0个位置*/
 60         if(x==1)
 61         {
 62             L->next=t;
 63             t->pre = L;
 64             t->next=NULL;
 65             return 1;
 66         }
 67     }
 68     while(p->next!=NULL&&i<x)/*查找第i个节点*/
 69     {
 70         p = p->next;
 71         i++;
 72     }
 73     if(p->next==NULL&& i == x)/*在表中不存在插入位置i ，找不到，则插入操作失败*/
 74     {
 75         t->next = NULL;
 76         p->next = t;
 77         t->pre = p;
 78         return 1;
 79     }
 80     else
 81     {
 82         p->next->pre=t;
 83         t->next=p->next;
 84         p->next=t;
 85         t->pre=p;
 86         return 1;
 87     }
 88 }
 89 
 90 int DelItem(N *L,int x)//在单链表中删除数据元素
 91 {
 92     int i = 0;
 93     N *p,*q;
 94     p = L;
 95     if(L->next==NULL) /*L为空表，无结点可删除*/
 96     {
 97         return 0;
 98     }
 99     while(p->next!=NULL&&i<x)
100     {
101         p = p->next;
102         i++;
103     }
104     if(p->next==NULL && i == x)/*若没有第i个结点，则删除操作失败*/
105     {
106         p->pre->next = NULL;
107         free(p);
108         return 1;
109     }
110     else
111     {
112         p->pre->next=p->next;
113         p->next->pre=p->pre;
114         free(p);
115         return 1;
116     }
117 }
118 
119 int main()
120 {
121     N* n;
122     n = Init();
123     n = Create(n);
124     output(n);
125     InsItem(n,5,5);
126     output(n);
127     DelItem(n,5);
128     output(n);
129 
130     return 0;
131 }

3.单链表的反转

https://liang.blog.csdn.net/article/details/90116419

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3  
 4 typedef int ElemType;
 5 
 6 typedef struct Node
 7 {
 8     ElemType data;   //数值域
 9     struct Node *next;  //指针域
10 }Linklist;
11  
12 Linklist *InitList(Linklist *L)    //初始化单链表
13 {
14     L = (Linklist *) malloc(sizeof(Linklist));
15     L->next = NULL;
16     return L;
17 }
18  
19 Linklist *CreateList(int n)
20 {
21     /*通过输入n个数据，创建一个单链表*/
22     int x,i;
23     Linklist *L,*r,*p;
24     L = InitList(L); //构造头结点
25     r = L;
26     printf("input %d value: ",n);
27     for(i=0;i<n;i++)
28     {
29         scanf("%d",&x);
30         p = (Linklist *)malloc(sizeof(Linklist));
31         p -> data = x;
32         p -> next = NULL;
33         r->next = p;
34         r = r->next;    //指针r始终指向链表中末数据元素所在位置
35  
36     }
37     return L;
38 }
39 
40 //头插法
41 int add_node_head(Linklist* head, Linklist* new_node)
42 {
43     if(NULL == head || NULL == new_node)
44         return -1;
45      new_node->next = head->next;
46     head->next = new_node;
47     return 0; 
48 } 
49 
50 //头插方式1-反转链表 
51 Linklist* revert_list(Linklist* head)
52 {
53     if(NULL == head)
54         return NULL;
55  
56     Linklist* p = head->next;
57     head->next= NULL;
58     Linklist* tmp = NULL;
59     while(p)
60     {
61         tmp = p->next;
62         add_node_head(head, p); 
63         p = tmp;    
64     }
65     return head;
66 }
67 
68 void output(Linklist *L) //输出
69 {
70     Linklist *p;
71     p = L->next;
72     printf("output element: \n");
73     for(;p!=NULL;p=p->next)
74     {
75         printf(" %d ",p->data);
76     }
77     printf("\n");
78 }
79 
80 int main()
81 {
82     Linklist *l = CreateList(6);
83     output(l);
84     l = revert_list(l);
85     output(l);
86     
87     return 0;
88 }

4.删除链表中的重复元素

https://blog.csdn.net/m0_59938453/article/details/123021127

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3  
 4 typedef int ElemType;
 5 
 6 typedef struct Node
 7 {
 8     ElemType data;   //数值域
 9     struct Node *next;  //指针域
10 }Linklist;
11  
12 Linklist *InitList(Linklist *L)    //初始化单链表
13 {
14     L = (Linklist *) malloc(sizeof(Linklist));
15     L->next = NULL;
16     return L;
17 }
18  
19 Linklist *CreateList(int n)
20 {
21     /*通过输入n个数据，创建一个单链表*/
22     int x,i;
23     Linklist *L,*r,*p;
24     L = InitList(L); //构造头结点
25     r = L;
26     printf("input %d value: ",n);
27     for(i=0;i<n;i++)
28     {
29         scanf("%d",&x);
30         p = (Linklist *)malloc(sizeof(Linklist));
31         p -> data = x;
32         p -> next = NULL;
33         r->next = p;
34         r = r->next;    //指针r始终指向链表中末数据元素所在位置
35  
36     }
37     return L;
38 }
39 
40 void output(Linklist *L) //输出
41 {
42     Linklist *p;
43     p = L->next;
44     printf("output element: \n");
45     for(;p!=NULL;p=p->next)
46     {
47         printf(" %d ",p->data);
48     }
49     printf("\n");
50 }
51 
52 Linklist* deleteDuplicates(Linklist* head)
53 {
54     //空链表就直接返回空指针
55     if(NULL == head)  // 注：在条件判断中，head == NULL 和 !head 所起的作用是一样的。
56         return NULL;
57 
58     Linklist* cur = head;
59     while(cur->next)  // 注意循环条件
60     {
61         Linklist* next = cur->next;
62         //若相等，则删掉下一个节点
63         if(cur->data == next->data)
64         {
65             cur->next = next->next;
66             free(next);
67         }
68         //若不等，则将下一个节点变为当前节点
69         else
70             cur = cur->next;
71     }
72     return head;  
73 }
74 
75 int main()
76 {
77     Linklist *l = CreateList(6);
78     output(l);
79     l = deleteDuplicates(l);
80     output(l);
81     
82     return 0;
83 }

c++实现删除链表的重复元素，把重复的元素全部删除（力扣82题）：

 1 #include <iostream>
 2 #include <vector>
 3 using namespace std;
 4 
 5 typedef struct Node
 6 {
 7    int data;   
 8     struct Node *next;  
 9 }Linklist;
10 
11 class node1{
12 public:
13     Linklist *InitList(Linklist *L){    //初始化单链表
14         L = new Linklist;
15         L->next = NULL;
16         return L;
17     }
18     
19     Linklist *CreateList(int n){
20      /*通过输入n个数据，创建一个单链表*/
21         int x,i;
22         Linklist *L,*r,*p;
23         L = InitList(L); //构造头结点
24         r = L;
25         for(i=0;i<n;i++){
26             cin >> x;
27             p = new Linklist;
28             p -> data = x;
29             p -> next = NULL;
30             r->next = p;
31             r = r->next;    //指针r始终指向链表中末数据元素所在位置
32         }
33          return L;
34      }
35     
36      void output(Linklist *L){ //输出
37         Linklist *p;
38         p = L->next;
39         for(;p!=NULL;p=p->next)
40             cout << p->data;
41         cout << endl;
42      }
43      
44     Linklist *deletedup(Linklist *L){
45         Linklist *dumy = new Linklist,*p = dumy;
46         dumy->next = L;
47         while(p->next){
48            Linklist* q = p->next;
49            while(q->next && q->next->data == q->data)  q = q->next;
50            if(q == p->next) p = p->next;
51            else p->next = q->next;
52         }
53         return dumy->next;
54     }
55 };
56 
57 int main()
58 {
59    node1 n;
60    Linklist *l,*p;
61    l = n.CreateList(5);
62    n.output(l);
63    p = n.deletedup(l);
64    n.output(p);
65     
66    return 0;
67 }

c++实现删除链表重复元素，使得重复元素只出现一次（力扣83题）

 1 #include <iostream>
 2 #include <vector>
 3 using namespace std;
 4 
 5 typedef struct Node
 6 {
 7    int data;   
 8     struct Node *next;  
 9 }Linklist;
10 
11 class node1{
12 public:
13     Linklist *InitList(Linklist *L){    //初始化单链表
14         L = new Linklist;
15         L->next = NULL;
16         return L;
17     }
18     
19     Linklist *CreateList(int n){
20      /*通过输入n个数据，创建一个单链表*/
21         int x,i;
22         Linklist *L,*r,*p;
23         L = InitList(L); //构造头结点
24         r = L;
25         for(i=0;i<n;i++){
26             cin >> x;
27             p = new Linklist;
28             p -> data = x;
29             p -> next = NULL;
30             r->next = p;
31             r = r->next;    //指针r始终指向链表中末数据元素所在位置
32         }
33          return L;
34      }
35     
36      void output(Linklist *L){ //输出
37         Linklist *p;
38         p = L->next;
39         for(;p!=NULL;p=p->next)
40             cout << p->data;
41         cout << endl;
42      }
43      
44     Linklist *deletedup(Linklist *L){
45         Linklist *p = L;
46         while(p && p->next){
47            Linklist *q = p->next;
48            while(q && q->data == p->data) q = q->next;
49            p->next = q;
50            p = p->next;
51         }
52         return L;
53     }
54 };
55 
56 int main()
57 {
58    node1 n;
59    Linklist *l,*p;
60    l = n.CreateList(5);
61    n.output(l);
62    p = n.deletedup(l);
63    n.output(p);
64     
65    return 0;
66 }

5.链表排序

https://blog.csdn.net/Vectory0213/article/details/79168475

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3  
 4 typedef int ElemType;
 5 
 6 typedef struct Node
 7 {
 8     ElemType data;   //数值域
 9     struct Node *next;  //指针域
10 }Linklist;
11  
12 Linklist *InitList(Linklist *L)    //初始化单链表
13 {
14     L = (Linklist *) malloc(sizeof(Linklist));
15     L->next = NULL;
16     return L;
17 }
18  
19 Linklist *CreateList(int n)
20 {
21     /*通过输入n个数据，创建一个单链表*/
22     int x,i;
23     Linklist *L,*r,*p;
24     L = InitList(L); //构造头结点
25     r = L;
26     printf("input %d value: ",n);
27     for(i=0;i<n;i++)
28     {
29         scanf("%d",&x);
30         p = (Linklist *)malloc(sizeof(Linklist));
31         p -> data = x;
32         p -> next = NULL;
33         r->next = p;
34         r = r->next;    //指针r始终指向链表中末数据元素所在位置
35  
36     }
37     return L;
38 }
39 
40 void output(Linklist *L) //输出
41 {
42     Linklist *p;
43     p = L->next;
44     printf("output element: \n");
45     for(;p!=NULL;p=p->next)
46     {
47         printf(" %d ",p->data);
48     }
49     printf("\n");
50 }
51 
52 void BubbleSort(Linklist *head)
53 {
54     Linklist *cur,*tail;
55     cur=head;
56     tail=NULL; 
57     if(cur==NULL||cur->next==NULL){
58         return;
59     }
60     while(cur!=tail)
61     {
62         while(cur->next!=tail)
63         {
64             if(cur->data > cur->next->data)
65             {
66                 int temp=cur->data;
67                 cur->data=cur->next->data;
68                 cur->next->data=temp;
69             }
70             cur=cur->next;
71         }
72         tail=cur;
73         cur=head;
74     }
75 }
76 
77 int main()
78 {
79     Linklist *l = CreateList(6);
80     output(l);
81     BubbleSort(l);
82     output(l);
83     
84     return 0;
85 }

6.旋转链表（链表的移位）力扣61题

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 #include<stdio.h>
 5 #include<stdlib.h>
 6  
 7 typedef int ElemType;
 8 /*结构体部分*/
 9 typedef struct Node
10 {
11     ElemType data;   //数值域
12     struct Node *next;  //指针域
13 }Linklist;
14  
15 Linklist *InitList(Linklist *L)    //初始化单链表
16 {
17     int x;
18     scanf("%d",&x);
19     L = (Linklist *) malloc(sizeof(Linklist));
20     L->data = x;
21     L->next = NULL;
22     return L;
23 }
24  
25 Linklist *CreateList(int n)
26 {
27     /*通过输入n个数据，创建一个单链表*/
28     int x,i;
29     Linklist *L,*r,*p;
30     L = InitList(L); //构造头结点
31     r = L;
32     printf("input %d value: ",n);
33     for(i=0;i<n;i++)
34     {
35         scanf("%d",&x);
36         p = (Linklist *)malloc(sizeof(Linklist));
37         p -> data = x;
38         p -> next = NULL;
39         r->next = p;
40         r = r->next;    //指针r始终指向链表中末数据元素所在位置
41  
42     }
43     return L;
44 }
45 
46 Linklist *rotatRight(Linklist *head,int k)
47 {
48     if(NULL == head) return NULL;
49     Linklist *cur = head;
50     int n = 1;
51     while(cur->next) cur = cur->next;n++;
52     cur->next = head;
53     for(int i = 0;i<n-k%n;i++)
54     {
55         cur = cur->next;
56     }
57     head = cur->next;
58     cur->next = NULL;
59     return head;
60 }
61 
62 void output(Linklist *L) //输出
63 {
64     Linklist *p;
65     p = L;
66     printf("output element: \n");
67     for(;p!=NULL;p=p->next)
68     {
69         printf(" %d ",p->data);
70     }
71     printf("\n");
72 }
73 
74 int main()
75 {
76     Linklist *l = CreateList(4);
77     output(l);
78     l = rotatRight(l,5);
79     output(l);
80     
81     return 0;
82 }

7.两数之和（力扣第二题）

创建2个链表，对两个链表对应位进行相加。

 1 #include<iostream>
 2 using namespace std;
 3 
 4 typedef struct Node
 5 {
 6     int data;   
 7     struct Node *next;  
 8 }Linklist;
 9 
10 class node{
11 public:
12     Linklist *InitList(Linklist *L)    //初始化单链表
13     {
14        L = new Linklist;
15        L->next = NULL;
16        return L;
17     }
18  
19     Linklist *CreateList(int n)
20     {
21     /*通过输入n个数据，创建一个单链表*/
22        int x,i;
23        Linklist *L,*r,*p;
24        L = InitList(L); //构造头结点
25        r = L;
26        for(i=0;i<n;i++)
27        {
28            cin >> x;
29            p = new Linklist;
30            p -> data = x;
31            p -> next = NULL;
32            r->next = p;
33            r = r->next;    //指针r始终指向链表中末数据元素所在位置
34        }
35         return L;
36     }
37     
38     void output(Linklist *L) //输出
39     {
40        Linklist *p;
41        p = L->next;
42        for(;p!=NULL;p=p->next)
43        {
44            cout << p->data;
45        }
46        cout << endl;
47     }
48     
49     Linklist *addtwonumbers(Linklist *l1,Linklist *l2)
50     {
51         Linklist *dumy = new Linklist,*cur = dumy;
52         int sum = 0;
53         while(l1 || l2 || sum){
54             if(l1) sum += l1->data,l1=l1->next;
55             if(l2) sum += l2->data,l2=l2->next;
56             cur->next = new Linklist;
57             cur->data = sum%10;
58             cur = cur->next;
59             sum /= 10;
60         }
61         return dumy->next;
62     }
63 };
64 
65 int main()
66 {
67     node n;
68     Linklist *l,*r,*p;
69     l = n.CreateList(3);
70     n.output(l);
71     r = n.CreateList(3);
72     n.output(r);
73     p = n.addtwonumbers(l,r);
74     n.output(p);
75     
76     return 0;
77 }

8.合并两个有序链表（力扣21题）

 1 #include<iostream>
 2 using namespace std;
 3  
 4  typedef struct Node
 5  {
 6      int data;   
 7       struct Node *next;  
 8  }Linklist;
 9  
10 class node{
11 public:
12     Linklist *InitList(Linklist *L)    //初始化单链表
13      {
14         L = new Linklist;
15         L->next = NULL;
16         return L;
17      }
18   
19      Linklist *CreateList(int n)
20      {
21      /*通过输入n个数据，创建一个单链表*/
22         int x,i;
23         Linklist *L,*r,*p;
24         L = InitList(L); //构造头结点
25         r = L;
26         for(i=0;i<n;i++)
27         {
28             cin >> x;
29             p = new Linklist;
30             p -> data = x;
31             p -> next = NULL;
32             r->next = p;
33             r = r->next;    //指针r始终指向链表中末数据元素所在位置
34         }
35          return L;
36      }
37      
38      void output(Linklist *L) //输出
39      {
40         Linklist *p;
41         p = L->next;
42         for(;p!=NULL;p=p->next)
43         {
44             cout << p->data;
45         }
46         cout << endl;
47      }
48      
49      Linklist *addtwonumbers(Linklist *l1,Linklist *l2)
50      {
51            Linklist* dumy = new Linklist,*cur = dumy;
52            while(l1 && l2){
53                if(l1->data <=l2->data){
54                   cur->next = new Linklist;
55                   cur->next->data = l1->data;
56                   l1 = l1->next;
57                }else{
58                   cur->next = new Linklist;
59                   cur->next->data = l2->data;
60                   l2 = l2->next;
61                }   
62                cur = cur->next;
63            }
64          cur->next = l1 ? l1 : l2;
65          return dumy->next->next;
66      }
67  };
68  
69  int main()
70  {
71      node n;
72      Linklist *l,*r,*p;
73      l = n.CreateList(3);
74      n.output(l);
75      r = n.CreateList(3);
76      n.output(r);
77      p = n.addtwonumbers(l,r);
78      n.output(p);
79      
80      return 0;
81  }

9.删除链表的倒数第N个元素（力扣第十九题）

#include <iostream>
using namespace std;

typedef struct Node
{
     int data;   //数值域
     struct Node *next;  //指针域
}Linklist;

class node{
public:
    Linklist *InitList(Linklist *L)    //初始化单链表
    {
       L = new Linklist;
       L->next = NULL;
       return L;
    }
    
    Linklist *CreateList(int n)
    {
       /*通过输入n个数据，创建一个单链表*/
       int x,i;
       Linklist *L,*r,*p;
       L = InitList(L); //构造头结点
       r = L;
       for(i=0;i<n;i++)
       {
           cin >> x;
           p = new Linklist;
           p -> data = x;
           p -> next = NULL;
           r->next = p;
           r = r->next;    //指针r始终指向链表中末数据元素所在位置
       }
       return L;
    }
    
    void output(Linklist *L) //输出
    {
       Linklist *p;
       p = L->next;
       for(;p!=NULL;p=p->next)
       {
           cout << p->data << " ";
       }
       cout << endl;
    }
    
    Linklist* removee(Linklist* head,int n)
    {
        Linklist *dumy = new Linklist;
        Linklist *slow = dumy,*fast = dumy;
        dumy->next = head;
        for(int i = 0;i<n;i++){
            fast = fast->next;
        }
        while(fast->next){
            slow = slow->next;
            fast = fast->next;
        }
        slow->next = slow->next->next;
        return dumy->next;
    }
};

int main() 
{
    node n;
    Linklist *l = n.CreateList(5);
    n.output(l);
    l = n.removee(l,4);
    n.output(l);
    
    return 0;
}