ソートされたリンクリストが重複ノードリストを削除し、重複ノードにおいて、ノードは、繰り返しを保持しない、ヘッド・ポインタ・リストを返します。例えば、リスト1-> 2-> 3-> 3-> 4-> 4-> 5扱われ1-> 2-> 5
1 / *
2 構造体ListNode {
3 int型のval;
4 次構造体ListNode *;
5 ListNode（INT X）：
6 のval（x）は、次の（NULL）{
7 }
8 }。
9 * /
10 クラスソリューション{
11 公共：
12 ListNode * deleteDuplication（ListNode * PHEAD）
13 {
14 であれば（PHEAD == NULL || pHead->次== NULL）
15 {
16 リターンPHEAD。
17 }
18 ListNode * newhead = 新しい ListNode（ - 1 ）;
19 newhead->次= PHEAD。
20 ListNode *プリ= newhead。
21 ListNode * CUR = PHEAD。
22 ListNode *次= NULL;
23 一方（CUR = NULL && cur->次=！NULL）
24 {
25 次= cur-> 次。
26 であれば（cur->ヴァル==ネクスト> ヴァル）
27 {
28 ながら（次！= NULL &&ネクスト>ヴァル== cur-> val）で
29 {
30 次=ネクスト> 次。
31
32 }
33 プレ>次= 次回。
34 CUR = 次回。
35 }
36 他の
37 {
38 プリ= CUR。
39 CUR = cur-> 次。
40 }
41 }
42
43 リターン newhead-> 次。
44
45 }
46 }。
書き込みコード、xの所定の値は2つの部分に分割され、基準は、すべての少ないXは先にx以上のノードのノードよりも一覧表示されます
给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。注意：分割以后保持原来的数据顺序不变。
1 /*
2 struct ListNode {
3 int val;
4 struct ListNode *next;
5 ListNode(int x) : val(x), next(NULL) {}
6 };*/
7 class Partition {
8 public:
9 ListNode* partition(ListNode* pHead, int x) {
10 // write code here
11 ListNode *small = new ListNode(0);
12 ListNode *big = new ListNode(0);
13 ListNode *smallhead = small;
14 ListNode *bighead = big;
15 while(pHead!= NULL)
16 {
17 if(pHead->val < x)
18 {
19 small->next = pHead;
20 small = small->next;
21 }
22 else
23 {
24 big->next = pHead;
25 big = big->next;
26 }
27 pHead = pHead->next;
28 }
29 big->next = NULL;
30 small->next = bighead->next;
31 return smallhead->next;
32
33 }
34 };
输入一个链表，输出该链表中倒数第k个结点。
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* FindKthToTail(ListNode* pListHead, unsigned int k)
12 {
13 if(pListHead==NULL|| k<=0)
14 {
15 return NULL;
16 }
17 vector<ListNode*> v;
18 ListNode* head = pListHead;
19 while(head)
20 {
21 v.push_back(head);
22 head = head->next;
23 }
24 if(v.size()>=k)
25 {
26 return v[v.size()-k];
27 }
28 else return NULL;
29
30 }
31 };
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* FindKthToTail(ListNode* pListHead, unsigned int k)
12 {
13 if(pListHead==NULL|| k<=0)
14 {
15 return NULL;
16 }
17 stack<ListNode*> str;
18 ListNode* tmp=pListHead;
19 while(tmp!=NULL)
20 {
21 str.push(tmp);
22 tmp=tmp->next;
23 }
24 if(str.size()>=k)
25 {
26 while((--k)>0)
27 {
28 str.pop();
29 }
30 return str.top();
31 }
32 return NULL;
33
34 }
35 };
反转链表
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode* reverseList(ListNode* head) {
12 ListNode *prev,*cur;
13 prev = NULL;
14 cur=head;
15 while(cur!=NULL)
16 {
17 ListNode *tmp=cur->next;
18 cur->next=prev;
19 prev=cur;
20 cur=tmp;
21 }
22 return prev;
23 }
24 };
链表的中间节点
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode* middleNode(ListNode* head) {
12 vector<ListNode*> v;
13 ListNode *tmp=head;
14 while(tmp)
15 {
16 v.push_back(tmp);
17 tmp=tmp->next;
18 }
19 return v[v.size()/2];
20 }
21 };
合并两个有序链表
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
12
13
14 ListNode* sum =new ListNode(1);
15 ListNode* ptr = sum;
16 while(l1!=NULL && l2!=NULL)
17 {
18 if(l1->val >= l2->val)
19 {
20 ptr->next = l2;
21 ptr=l2;
22 l2=l2->next;
23 }
24 else
25 {
26 ptr->next = l1;
27 ptr = l1;
28 l1 = l1->next;
29
30 }
31
32 }
33 ptr->next = l1==NULL ? l2 : l1;
34 sum=sum->next;
35 return sum;
36 }
37 };
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode(int x) : val(x), next(NULL) {}
7 * };
8 */
9 class Solution {
10 public:
11 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
12 vector<int> v;
13 ListNode* l1tmp = l1;
14 ListNode* l2tmp = l2;
15 while(l1tmp != NULL)
16 {
17 v.push_back(l1tmp->val);
18 l1tmp=l1tmp->next;
19 }
20 while(l2tmp != NULL)
21 {
22 v.push_back(l2tmp->val);
23 l2tmp=l2tmp->next;
24 }
25 sort(v.begin(),v.end(),less<int>());
26 ListNode* l3 = new ListNode(0);
27 ListNode* l3tmp = l3;
28 for(auto &i : v)
29 {
30 ListNode* tmp = new ListNode(i);
31 l3tmp->next = tmp;
32 l3tmp = l3tmp->next;
33 }
34 return l3->next;
35
36 }
37 };