链表操作算法题合集

最新推荐文章于 2021-05-17 19:38:29 发布
最新推荐文章于 2021-05-17 19:38:29 发布
阅读量854 收藏 3
点赞数
分类专栏： C/C++ 文章标签： 算法 链表 单链表 指针 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011239443/article/details/51655202
版权

http://blog.csdn.net/u011239443/article/details/51655202

0.单链表的增、删、改、查（无头指针）

  1 #include <stdio.h>
  2 #include<stdlib.h>
  3 struct Node
  4 {
  5     int val;
  6     Node * next;
  7 };
  8 
  9 Node* Node_Insert(Node* First,int val) 
 10 {
 11     Node* p=(Node*)calloc(1,sizeof(Node));
 12     p->val=val;
 13     p->next=First;
 14     First=p;
 15     return First;
 16 }
 17 
 18 Node* Node_Delete(Node* First,int val) 
 19 {
 20     Node* p = First;
 21     Node* pre=NULL;
 22     Node* tem=NULL;
 23     int find=0;
 24     while(p!=NULL)
 25     {
 26         if(p->val==val)
 27         {
 28             pre->next=p->next;
 29             tem=p;
 30             p=pre->next;
 31             free(tem);
 32         }
 33         else
 34         {
 35             pre=p;
 36             p=p->next;
 37         }
 38     }
 39     return First;
 40 }
 41 
 42 
 43 
 44 Node* Node_Change(Node* First,int m,int n)
 45 {
 46     Node* p = First;
 47     while(p!=NULL)
 48     {
 49         if(p->val==m)
 50         {
 51             p->val=n;
 52         }
 53         p=p->next;
 54     }
 55     return First;
 56 }
 57 
 58 
 59 int Node_Search(Node* First,int x)
 60 {
 61     Node* p = First;
 62     int index=0;
 63     while(p!=NULL)
 64     {
 65         ++index;
 66         if(p->val==x)
 67             break;
 68         p=p->next;
 69     }
 70     if(p==NULL)
 71         index=-1;
 72     return index;
 73 }
 74 
 75 
 76 void order(Node* First)
 77 {
 78     Node* p=First;
 79     while(p!=NULL)
 80     {
 81         printf("%d ",p->val);
 82         p=p->next;
 83     }
 84 }
 85 
 86 
 87 int main()
 88 {
 89     int n,i,tem,tem2;
 90     while(printf("链表长度：")&&scanf("%d",&n)!=EOF)
 91     {
 92         getchar();
 93         Node* First=NULL;
 94         printf("请插入链表：");
 95         for(i=0;i<n;i++)
 96         {
 97             scanf("%d",&tem);
 98             First=Node_Insert(First,tem);
 99         }
100         getchar();
101         printf("请输入删除的值：");
102         scanf("%d",&tem);
103         getchar();
104         First=Node_Delete(First,tem);
105         printf("删除后：\n");
106         order(First);
107         printf("\n");
108         printf("请输入修改前和修改后的值：");
109         scanf("%d %d",&tem,&tem2);
110         getchar();
111         First=Node_Change(First,tem,tem2);
112         printf("修改后：\n");
113         order(First);
114         printf("\n");
115         printf("请输入要查找的值：");
116         scanf("%d",&tem);
117         getchar();
118         tem2=Node_Search(First,tem);
119         if(tem2==-1) printf("没有这个数\n");
120         else printf("第%d个数\n",tem2);
121     }
122     return 0;
123 }

 

 

1.单链表反转

 1 /*
 2 struct ListNode {
 3     int val;
 4     struct ListNode *next;
 5     ListNode(int x) :
 6             val(x), next(NULL) {
 7     }
 8 };*/
 9 class Solution {
10 public:
11     ListNode* ReverseList(ListNode* pHead) {
12           if(pHead!=NULL)
13          {
14                 ListNode * pre=NULL;
15                 ListNode * p=pHead;
16                ListNode * q=pHead->next;
17             while(q!=NULL)
18             {
19                 p->next=pre;
20                 pre=p;
21                 p=q;
22                 q=q->next;
23             }
24             p->next=pre;
25             return p;
26          }
27          return NULL;
28     }
29 };

 

 

2.找出单链表的倒数第n个元素

*p,*q 指向第一个指针，p向前移动n次，q再跟着和p一直移动，等p移到末尾，q所指的就是倒是第n个元素

 1 #include <stdio.h>
 2 #include<stdlib.h>
 3 struct Node
 4 {
 5     int val;
 6     Node * next;
 7 };
 8 
 9 Node* Node_Insert(Node* First,int val) 
10 {
11     Node* p=(Node*)calloc(1,sizeof(Node));
12     p->val=val;
13     p->next=First;
14     First=p;
15     return First;
16 }
17 
18 
19 
20 
21 void order(Node* First)
22 {
23     Node* p=First;
24     while(p!=NULL)
25     {
26         printf("%d ",p->val);
27         p=p->next;
28     }
29 }
30 
31 int My_Node_Search(Node* First,int n)
32 {
33     int i;
34     Node* p,*q;
35     q=p=First;
36 
37     if(First->next==NULL&&n==1) return 1;
38     if(First->next==NULL&&n>1) return -1;
39     if(n<=0) return -1;
40 
41     for(i=0;i<n;i++)
42     {
43         if(p==NULL) return -1;
44         p=p->next;
45     }
46     while(p!=NULL)
47     {
48         p=p->next;
49         q=q->next;
50     }
51     return q->val;
52 }
53 
54 int main()
55 {
56     int n,i,tem;
57     while(printf("链表长度：")&&scanf("%d",&n)!=EOF)
58     {
59         getchar();
60         Node* First=NULL;
61         printf("请插入链表：");
62         for(i=0;i<n;i++)
63         {
64             scanf("%d",&tem);
65             First=Node_Insert(First,tem);
66         }
67         getchar();
68         printf("链表为：");
69         order(First);
70         printf("\n");
71 
72         printf("取倒数第几个数：");
73         while(scanf("%d",&tem)!=EOF)
74         {
75             tem=My_Node_Search(First,tem);
76             if(tem!=-1)
77                 printf("值为%d\n",tem);
78             else printf("越界！\n");
79             printf("取倒数第几个数：");
80         }
81     }
82     return 0;
83 }

 

3.找出单链表的中间元素（见0）


4.删除无头单链表的一个节点（见0）


5.两个不交叉的有序链表的合并

 1 /*
 2 struct ListNode {
 3     int val;
 4     struct ListNode *next;
 5     ListNode(int x) :
 6             val(x), next(NULL) {
 7     }
 8 };*/
 9 class Solution {
10 public:
11     ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
12     {
13          ListNode* p=pHead1;
14         ListNode* q=pHead2;
15             ListNode* First=NULL;
16             ListNode* r=NULL;
17         if (p == NULL )
18             return q;
19         if (q == NULL )
20             return p;
21         
22         if(p->val<q->val)
23         {
24             r=p;
25             p=p->next;
26         }
27         else
28         {
29             r=q;
30             q=q->next;
31         }
32 
33     First=r;
34     while(p!=NULL&&q!=NULL)
35     {
36         if(p->val<q->val)
37         {
38             r->next=p;
39             p=p->next;
40         }
41         else
42         {
43             r->next=q;
44             q=q->next;
45         }
46         r=r->next;
47     }
48 
49     while(p!=NULL)
50     {
51         r->next=p;
52         r=r->next;
53         p=p->next;
54     }
55 
56     while(q!=NULL)
57     {
58         r->next=q;
59         r=r->next;
60         q=q->next;
61     }
62 
63     r=NULL;
64 
65     return First;
66     }
67 };

 

 

6.判断单链表是否有环？

p1 p2 指向开头，p1的每次移动步长为1，p2的每次移动的步长为2。在p2==NULL前，如果出现p1==p2，则有环。 
 1 #include <stdio.h>
 2 #include<stdlib.h>
 3 struct Node
 4 {
 5     int val;
 6     Node * next;
 7 };
 8 
 9 Node* Node_Create(Node* p,int val) 
10 {
11     p=(Node*)calloc(1,sizeof(Node));
12     p->val=val;
13     p->next=NULL;
14     return p;
15 }
16 
17 int If_Have_Circle(Node* First)
18 {
19     if( First==NULL) return 0;
20     Node* p1=First;
21     Node* p2=First;
22     int Have=0;
23     while(p1!=NULL&&p2!=NULL)
24     {
25         p1=p1->next;
26         if(p1==NULL) break;
27 
28         p2=p2->next;
29         if(p2==NULL) break;
30         p2=p2->next;
31         if(p2==NULL) break;
32 
33         if(p1==p2)
34         {
35             Have=1;
36             break;
37         }
38     }
39 
40     return Have;
41 }
42 int main()
43 {
44     int i,tem;
45 
46     Node* No_Circle_First=NULL;
47     Node* Have_Circle_First=NULL;
48 
49     Node* p=NULL;
50     Node* q=NULL;
51     q=Node_Create(q,1);
52     p=q;
53     No_Circle_First=q;
54 
55     q=Node_Create(q,2);
56     p->next=q;
57     p=p->next;
58     q=Node_Create(q,3);
59     p->next=q;
60     p=p->next;
61     q=Node_Create(q,4);
62     p->next=q;
63 
64     q=Node_Create(q,1);
65     p=q;
66     Have_Circle_First=q;
67 
68     q=Node_Create(q,2);
69     p->next=q;
70     p=p->next;
71 
72     q=Node_Create(q,3);
73     p->next=q;
74     p=p->next;
75     Node* index=p;
76 
77     q=Node_Create(q,4);
78     p->next=q;
79     p=p->next;
80 
81     q=Node_Create(q,5);
82     p->next=q;
83     p=p->next;
84     p->next=index;
85 
86     int tem1=If_Have_Circle(No_Circle_First);
87     printf("%s\n",tem1==0?"No":"Yes");
88     tem1=If_Have_Circle(Have_Circle_First);
89     printf("%s\n",tem1==0?"No":"Yes");
90     return 0;
91 }

 

7.判断两个单链表是否相交（见8）


8.两个单链表相交，计算相交点

先计算出两条链表的长度L1、L2，n=ans(L1-L2)。p1,p2分别指向两个链表的开头，指向长的链表的指针先向前移动n次，然后再两个一起移动。如果出现p1==p2，则开始计数。 
 1 #include <stdio.h>
 2 #include<stdlib.h>
 3 struct Node
 4 {
 5     int val;
 6     Node * next;
 7 };
 8 
 9 Node* Node_Create(Node* p,int val) 
10 {
11     p=(Node*)calloc(1,sizeof(Node));
12     p->val=val;
13     p->next=NULL;
14     return p;
15 }
16 
17 
18 void Find_Same(Node* First1,Node* First2)
19 {
20     int len1,len2,count;
21     len1=len2=count=0;
22     Node* p,*q;
23     p=First1;
24     while(p!=NULL)
25     {
26         ++len1;
27         p=p->next;
28     }
29 
30     p=First2;
31     while(p!=NULL)
32     {
33         ++len2;
34         p=p->next;
35     }
36     p=First1;q=First2;
37     while(len1!=len2)
38     {
39         if(len1>len2) 
40         {
41             p=p->next;
42             ++len2;
43         }
44         else
45         {
46             q=q->next;
47             ++len1;
48         }
49     }
50 
51     while(p!=q)
52     {
53         p=p->next;
54         q=q->next;
55     }
56 
57     while(p!=NULL)
58     {
59         ++count;
60         printf("%d ",p->val);
61         p=p->next;
62     }
63     printf("\n共%d个公共节点\n",count);
64 }
65 
66 int main()
67 {
68     int i;
69 
70     Node* First1=NULL;
71     Node* First2=NULL;
72 
73     Node* p=NULL;
74     Node* q=NULL;
75     q=Node_Create(q,1);
76     p=q;
77     First1=q;
78 
79     q=Node_Create(q,2);
80     p->next=q;
81     p=p->next;
82     q=Node_Create(q,3);
83     p->next=q;
84     p=p->next;
85     Node* index=p;
86     q=Node_Create(q,4);
87     p->next=q;
88 
89     q=Node_Create(q,1);
90     p=q;
91     First2=q;
92     p->next=index;
93     Find_Same(First1,First2);
94     return 0;
95 }

 


9.单链表排序

链表只能相邻改变，所以用冒泡排序最好。 
 1 #include <stdio.h>
 2 #include<stdlib.h>
 3 struct Node
 4 {
 5     int val;
 6     Node * next;
 7 };
 8 
 9 Node* Node_Insert(Node* First,int val) 
10 {
11     Node* p=(Node*)calloc(1,sizeof(Node));
12     p->val=val;
13     p->next=First;
14     First=p;
15     return First;
16 }
17 
18 void order(Node* First)
19 {
20     Node* p=First;
21     while(p!=NULL)
22     {
23         printf("%d ",p->val);
24         p=p->next;
25     }
26 }
27 
28 
29 Node* Node_sort(Node* First)
30 {
31     if(First==NULL)
32         return First;
33     Node* p1,*p2,*pre;
34     Node* rear=First;
35     Node* L=(Node*)calloc(1,sizeof(Node));
36     L->next=First;
37     while(rear->next!=NULL)
38         rear=rear->next;
39     while(rear!=First)
40     {
41         pre=L;
42         p1=L->next;
43         p2=L->next->next;
44         while(p2!=rear->next&&p2!=NULL)
45         {
46             if(p1->val>p2->val)
47             {
48                 pre->next=p1->next;
49                 p1->next=p2->next;
50                 p2->next=p1;
51                 pre=pre->next;
52                 p2=p1->next;
53             }
54             else
55             {
56                 pre=pre->next;
57                 p1=p1->next;
58                 p2=p2->next;
59             }
60         }
61 
62         rear=pre;
63     }
64 
65     return L->next;
66 }
67 
68 int main()
69 {
70     int n,i,tem;
71     while(printf("链表长度：")&&scanf("%d",&n)!=EOF)
72     {
73         getchar();
74         Node* First=NULL;
75         printf("请插入链表：");
76         for(i=0;i<n;i++)
77         {
78             scanf("%d",&tem);
79             First=Node_Insert(First,tem);
80         }
81         getchar();
82         printf("链表为：");
83         order(First);
84         printf("\n");
85 
86         First=Node_sort(First);
87         printf("排序后为：");
88         order(First);
89         printf("\n");
90     }
91     return 0;
92 }

 

10.删除单链表中重复的元素

用Hash数组保存各相同元素值的个数 
 1 #include <stdio.h>
 2 #include<stdlib.h>
 3 
 4 struct Node
 5 {
 6     int val;
 7     Node * next;
 8 };
 9 
10 Node* Node_Insert(Node* First,int val) 
11 {
12     Node* p=(Node*)calloc(1,sizeof(Node));
13     p->val=val;
14     p->next=First;
15     First=p;
16     return First;
17 }
18 
19 void order(Node* First)
20 {
21     Node* p=First;
22     while(p!=NULL)
23     {
24         printf("%d ",p->val);
25         p=p->next;
26     }
27 }
28 
29 int cnt[101];
30 
31 Node* Delete_Same(Node* First)
32 {
33     Node* p=First;
34     Node* pre,*r;
35     while(p!=NULL)
36     {
37         ++cnt[p->val];
38         p=p->next;
39     }
40     Node* L=(Node*)calloc(1,sizeof(Node));
41     L->next=First;
42     pre=L;
43     p=First;
44     while(p!=NULL)
45     {
46         if(cnt[p->val]>1)
47         {
48             --cnt[p->val];
49             r=p;
50             p=p->next;
51             pre->next=p;
52             free(r);
53         }
54         else
55         {
56             p=p->next;
57             pre=pre->next;
58         }
59     }
60 
61     return L->next;
62 }
63 
64 int main()
65 {
66     int n,i,tem,tem2;
67     while(printf("链表长度：")&&scanf("%d",&n)!=EOF)
68     {
69         getchar();
70         Node* First=NULL;
71         printf("请插入链表：");
72         for(i=0;i<n;i++)
73         {
74             scanf("%d",&tem);
75             First=Node_Insert(First,tem);
76         }
77         printf("原链表：");
78         order(First);
79         printf("\n");
80 
81         for(i=0;i<101;i++)
82             cnt[i]=0;
83         First=Delete_Same(First);
84 
85         printf("删除后：");
86         order(First);
87         printf("\n");
88 
89     }
90     return 0;
91 }

 



11 链表拆分(将链表奇数位置上的节点构成一个新链表，偶数位置上的结点构成一个新链表)

 1 #include <stdio.h>
 2 #include<stdlib.h>
 3 struct Node
 4 {
 5     int val;
 6     Node * next;
 7 };
 8 
 9 Node* Node_Insert(Node* First,int val) 
10 {
11     Node* p=(Node*)calloc(1,sizeof(Node));
12     p->val=val;
13     p->next=First;
14     First=p;
15     return First;
16 }
17 
18 
19 void order(Node* First)
20 {
21     Node* p=First;
22     while(p!=NULL)
23     {
24         printf("%d ",p->val);
25         p=p->next;
26     }
27 }
28 
29 void Node_Cut(Node* First,Node* &First1,Node* &First2)
30 {
31     if(First==NULL) 
32         return;
33     if(First->next==NULL)
34     {
35         First1=First;
36         First1->next=NULL;
37         return;
38     }
39 
40     First1=First;
41     First2=First->next;
42 
43     Node* p1=First1;
44     Node* p2=First2;
45     while(p1!=NULL&&p2!=NULL)
46     {
47         if(p1->next==NULL) break;
48         if(p1->next->next==NULL) break;
49         p1->next=p1->next->next;
50         p1=p1->next;
51 
52         if(p2->next==NULL) break;
53         if(p2->next->next==NULL) break;
54         p2->next=p2->next->next;
55         p2=p2->next;
56     }
57     p1->next=NULL;
58     p2->next=NULL;
59 }
60 
61 int main()
62 {
63     int n,i,tem,tem2;
64     while(printf("链表长度：")&&scanf("%d",&n)!=EOF)
65     {
66         getchar();
67         Node* First=NULL;
68         Node* First1=NULL;
69         Node* First2=NULL;
70         printf("请插入链表：");
71         for(i=0;i<n;i++)
72         {
73             scanf("%d",&tem);
74             First=Node_Insert(First,tem);
75         }
76         printf("原链表：");
77         order(First);
78         printf("\n");
79 
80         Node_Cut(First,First1,First2);
81         printf("拆分后：\n");
82         order(First1);
83         printf("\n");
84         order(First2);
85         printf("\n");
86 
87     }
88     return 0;
89 }

 


12 大整数加法

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 
  4 struct Node
  5 {
  6     int val;
  7     Node * next;
  8 };
  9 
 10 Node* Node_Insert(Node* First,int val) 
 11 {
 12     Node* p=(Node*)calloc(1,sizeof(Node));
 13     p->val=val;
 14     p->next=First;
 15     First=p;
 16     return First;
 17 }
 18 
 19 
 20 void order(Node* First)
 21 {
 22     Node* p=First;
 23     while(p!=NULL)
 24     {
 25         printf("%d",p->val);
 26         p=p->next;
 27     }
 28 }
 29 
 30 int jinwei,tuiwei;
 31 
 32 Node* add1(Node* Long_Num,Node* Short_Num)// 同号整数相加
 33 {
 34     Node* p1,*p2;
 35     p1=Long_Num;p2=Short_Num;
 36     while(p2!=NULL)
 37     {
 38         p1->val+=p2->val;
 39         p1=p1->next;
 40         p2=p2->next;
 41     }
 42 
 43     Node* p3=Long_Num;
 44     while(p3!=p1)
 45     {
 46         if(p3->val>=10)
 47         {
 48             if(p3->next==NULL)
 49             {
 50                 jinwei=1;//进位
 51                 p3->val=p3->val%10;
 52             }
 53             else
 54             {
 55                 p3->next->val+=p3->val/10;
 56                 p3->val=p3->val%10;
 57             }
 58         }
 59         p3=p3->next;
 60     }
 61 
 62     return Long_Num;
 63 }
 64 
 65 Node* add2(Node* Long_Num,Node* Short_Num)//异号相加
 66 {
 67     Node* p1,*p2;
 68     p1=Long_Num;p2=Short_Num;
 69     while(p2!=NULL)
 70     {
 71         p1->val-=p2->val;
 72         p1=p1->next;
 73         p2=p2->next;
 74     }
 75     Node* p3=Long_Num;
 76     while(p3!=p1)
 77     {
 78         if(p3->val<0)
 79         {
 80 
 81             --p3->next->val;
 82             p3->val+=10;
 83         }
 84         p3=p3->next;
 85     }
 86     return Long_Num;
 87 }
 88 
 89 int My_Compare(Node* Num1,Node* Num2)
 90 {
 91     Node* p1,*p2;
 92     p1=Num1;
 93     p2=Num2;
 94     while(p1!=NULL)
 95     {
 96         if(p1->val>p2->val) return 1;
 97         if(p1->val<p2->val) return -1;
 98         p1=p1->next;
 99         p2=p2->next;
100     }
101     return 0;
102 }
103 
104 Node* Chain_Reverse(Node* First)
105 {
106     if(First!=NULL)
107     {
108         Node * pre=NULL;
109         Node * p=First;
110         Node * q=First->next;
111         while(q!=NULL)
112         {
113             p->next=pre;
114             pre=p;
115             p=q;
116             q=q->next;
117         }
118         p->next=pre;
119         return p;
120     }
121     return First;
122 
123 }
124 
125 int main()
126 {
127     printf("输入格式为：\nNum1\n+\nNum2\n");
128     while(1)
129     {
130         Node* Num1,* Num2;
131         Num1=NULL;
132         Num2=NULL;
133         char tem;
134         int fir=1;
135         int fu1,fu2;
136         int len1,len2;
137         char Highest_Val1,Highest_Val2;
138         len1=len2=0;
139         while(scanf("%c",&tem))//第一个数
140         {
141             if(tem=='\n') break;
142             if(fir)
143             {
144                 fir=0;
145                 if(tem=='-')
146                 {
147                     fu1=1;
148                     scanf("%c",&Highest_Val1);
149                     Num1=Node_Insert(Num1,Highest_Val1-'0');
150                     ++len1;
151                 }
152                 else
153                 {
154                     fu1=0;
155                     ++len1;
156                     Highest_Val1=tem;
157                     Num1=Node_Insert(Num1,tem-'0');
158                 }
159 
160             }
161             else 
162             {   ++len1;
163             Num1=Node_Insert(Num1,tem-'0');
164             }
165 
166         }
167         getchar();
168         getchar();
169 
170         fir=1;
171         while(scanf("%c",&tem))//第二个数
172         {
173             if(tem=='\n') break;
174             if(fir)
175             {
176                 fir=0;
177                 if(tem=='-') 
178                 {
179                     fu2=1;
180                     scanf("%c",&Highest_Val2);
181                     Num2=Node_Insert(Num2,Highest_Val2-'0');
182                     ++len2;
183                 }
184                 else
185                 {
186                     fu2=0;
187                     ++len2;
188                     Highest_Val2=tem;
189                     Num2=Node_Insert(Num2,tem-'0');
190                 }
191             }
192             else
193             {
194                 ++len2;
195                 Num2=Node_Insert(Num2,tem-'0');    
196             }
197         }
198         Node* result;
199         jinwei=tuiwei=0;
200         if(fu1==0&&fu2==0) //全正
201         {
202             if(len1>len2)  result=add1(Num1,Num2);
203             else  result=add1(Num2,Num1);
204             result=Chain_Reverse(result);
205             if(jinwei) printf("1");
206             order(result);
207             printf("\n");
208         }
209         else if(fu1==1&&fu2==1) //全负
210         {
211             if(len1>len2)  result=add1(Num1,Num2);
212             else  result=add1(Num2,Num1);
213             result=Chain_Reverse(result);
214             printf("-");
215             if(jinwei) printf("1");
216             order(result);
217             printf("\n");
218         }
219         else if((fu1==1&&fu2==0)||(fu1==0&&fu2==1)) //正负相加
220         {
221             int bigger=1;
222             int cmp=100;
223             if(len1>len2)  result=add2(Num1,Num2);
224             else if(len1<len2) 
225             {
226                 bigger=2;
227                 result=add2(Num2,Num1);
228             }
229             else if(len1==len2)
230             {
231                 Num1=Chain_Reverse(Num1);
232                 Num2=Chain_Reverse(Num2);
233                 cmp=My_Compare(Num1,Num2);
234                 Num1=Chain_Reverse(Num1);
235                 Num2=Chain_Reverse(Num2);
236                 if(cmp==1) result=add2(Num1,Num2);
237                 else if(cmp==-1) 
238                 {
239                     bigger=2;
240                     result=add2(Num2,Num1);
241                 }
242             }
243 
244             if(cmp==0) printf("0\n");
245             else
246             {
247                 result=Chain_Reverse(result);
248                 Node* p=result;
249                 while(p->val==0)
250                     p=p->next;
251                 if(bigger==1)
252                 {
253                     if(fu1) printf("-");
254                 }
255                 else if(bigger==2)
256                 {
257                     if(fu2)   printf("-");
258                 }
259                 while(p!=NULL)
260                 {
261                     printf("%d",p->val);
262                     p=p->next;
263                 }
264                 printf("\n");
265             }
266         }
267 
268     }
269     return 0;
270 }

 

 

小爷毛毛（卓寿杰）
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
leetcode算法题-链表操作（两数相加）
12-20
leetcode 算法题： 两数相加 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新...
常用算法整理：链表相关
言川的博客
04-24 3721
链表的考点链表很多时候都是考察基本功，因为链表题大部分都不是很复杂，主要是对指针的操作，当然也有难的。 简单的题目包括 删除/插入节点、翻转、去重、排序等，难度高一些的题目依然是这些，不过会有一些条件，比如多个链表或者局部操作。对链表题的两个技巧： - 如果不确定最终结果的head，比如对两个链表进行排序，那么新建一个 dummy node。 - 可以通过快慢指针的方式取中间节点入门题：第一题
常用链表操作算法
kavenyang的专栏
11-11 326
链表操作在面试中会经常出现，下面列举的链表操作方法是比较典型的。 问题1：输入一个单向链表，输出该链表中倒数第k个结点 一个单向链表无法像数组一样可以直接索引，那么要找到链表的倒数第K个节点该怎么操作呢，其实思路非常简单，我们只需要设置两个指针p1,p2，首先p1和p2都指向链表的头部head，然后p2向前走k步，这样p1和p2之间就间隔k个节点，最后p1和p2同时向前移动，直至p2走
将一个链式链表L分成2个链表，一个存储L的奇数位置的元素，一个存储L偶数位置的元素
u013721481的专栏
04-01 1683
//将一个链式链表L分成2个链表，一个存储L的奇数位置的元素，一个存储L偶数位置的元素#include using namespace std; typedef struct node { int data; struct node *next; }L; void Initial_List(L * &h) { L *p;///用于插入 L *r;//尾节点 h=(L *)malloc
2021真题回忆版1
08-04
第二题考的是迪杰斯特拉算法求最短路径和求解过程 常规题 第三题平衡二叉树 第二个内存连续存储的方法和回收方法 第三个磁盘调度的方法和优缺点 第四个是成组链接法概
数据结构与算法面试题整理
09-12
数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、...
数据结构与算法-练习题
05-19
A、所有的操作算法简单B、便于插入和删除C、便于利用零散的存储空间D、便于随机存取正确答案： B 9在一个单链表中， 若删除 p 所指结点的后续结点， 则执行（ ）A、s->next=p;p->next=s;B、s->next=p->next;p=s;C、s...
数据结构与算法练习题.zip
最新发布
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
链表面试题带解析（超全超赞）
专注游戏研发
07-29 498
链表面试题
单链表的表示以及基本操作函数
qq_38846633的博客
07-23 1万+
    引言       本文是我学习清华大学出版社《数据结构》课程有关单链表知识点的感悟，主要在于课本上算法伪代码的实现，仅作学习交流之用     正文      线性表的顺序存储结构要求在逻辑顺序上相邻的两个结构物理位置也必须相邻，这就造成了一个后果，即插入删除一个元素时可能会移动大量的指针，进而导致程序的时间复杂度迅速上升。因此为了尽可能减少程序存储的时间复杂度，就有了链式存储结构这有...
链表算法面试问题？看我就够了！
程序员吴师兄的博客
03-02 1661
1 引言 单链表的操作算法是笔试面试中较为常见的题目。本文将着重介绍平时面试中常见的关于链表的应用题目。本文大概一万五千字，建议阅读时间为一个小时，请先收藏再阅读，平...
C：单链表的查找(超详细图解）
qq_53293179的博客
05-17 4386
求表长： 【样例】 从键盘依次输入某班学生的姓名和成绩并保存。输出表长。 【输入样例】 3 a 50 b 70 c 65 【输出样例】 3 【分析】 int getLength(node * first) //求链表表长函数 { node *s=first; int n=0; while(s->next!=NULL) { n++; s=s->next; } return n; } 【完整代码】 #include <
将一个链表分为奇偶两个链表
二哈
06-30 9183
1. 问题描述： 设计一个算法，将一个头结点为A的单链表（其数据域为整数）分解成两个单链表A和B，使得A链表只含有原来链表data域为奇数的节点，而B链表只含有原链表中data域为偶数的节点，而且保持原来的顺序 2. 思路分析： ① 这个问题不是在线网上评测系统上的，所以没有标准的输入和输出数据，只能够通过简单的数据来判断程序的逻辑是否正确，首先在将原来的链表分开之前，我们需要将创建出一个单...
单链表的基本操作
热门推荐
meng_lemon的博客
08-25 2万+
链表：一种链式存储的线性表，用一组地址任意的存储单元存放线性表的数据元素，称为存储单元为一个节点。 单链表的存储结构 typedef int DataType; typedef struct ListNode { DataType _data; //当前节点中所保存的元素 struct ListNode* _pNext; //指向...
链表操作算法
ShutingChen的专栏
07-27 576
链表操作算法合辑
数据结构算法题pdf
11-17
这类题目通常涉及到数组、链表、栈、队列、树、图等数据结构的操作，以及常见的排序、查找、动态规划等算法的应用。这些题目通常用于编程练习和算法竞赛中，是程序员和计算机专业学生进行练习和学习的重要材料。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小爷毛毛（卓寿杰）

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值