24. Swap Nodes in Pairs
https://leetcode.com/problems/linked-list-cycle/
Given a linked list, swap every two adjacent nodes and return its head.
You may not modify the values in the list's nodes, only nodes itself may be changed.
Example:
Given 1->2->3->4, you should return the list as 2->1->4->3.
C 实现：
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * struct ListNode *next;
6 * };
7 */
8
9 struct ListNode* swapPairs(struct ListNode* head){
10 if(head == NULL || head->next == NULL)
11 return head;
12
13 struct ListNode* pNode = head;
14
15 while(pNode && pNode->next)
16 {
17 int val = 0;
18
19 val = pNode->val;
20 pNode->val = pNode->next->val;
21 pNode->next->val = val;
22
23 pNode = pNode->next->next;
24 }
25 return head;
26 }
C++实现：
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode() : val(0), next(nullptr) {}
7 * ListNode(int x) : val(x), next(nullptr) {}
8 * ListNode(int x, ListNode *next) : val(x), next(next) {}
9 * };
10 */
11 class Solution {
12 public:
13 ListNode* swapPairs(ListNode* head) {
14 ListNode* pNode = head;
15
16 if(head == NULL || head->next == NULL)
17 return head;
18
19 while(pNode && pNode->next)
20 {
21 int iVal = 0;
22
23 iVal = pNode->val;
24 pNode->val = pNode->next->val;
25 pNode->next->val = iVal;
26
27 pNode = pNode->next->next;
28 }
29 return head;
30 }
31 };
141. Linked List Cycle
https://leetcode.com/problems/linked-list-cycle/
Given a linked list, determine if it has a cycle in it.
To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.
Example 1:
Input: head = [3,2,0,-4], pos = 1
Output: true
Explanation: There is a cycle in the linked list, where tail connects to the second node.
Example 2:
Input: head = [1,2], pos = 0
Output: true
Explanation: There is a cycle in the linked list, where tail connects to the first node.
Example 3:
Input: head = [1], pos = -1
Output: false
Explanation: There is no cycle in the linked list.
Follow up:
Can you solve it using O(1) (i.e. constant) memory?
C 实现：
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * struct ListNode *next;
6 * };
7 */
8 bool hasCycle(struct ListNode *head) {
9 if(head == NULL || head->next == NULL)
10 return false;
11
12 struct ListNode *pLast = head;
13 struct ListNode *pFast = head->next;
14
15 while(pFast && pFast->next)
16 {
17 if(pFast == pLast)
18 return true;
19 pLast = pLast->next;
20 pFast = pFast->next->next;
21 }
22 return false;
23 }
C++实现：
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 bool hasCycle(ListNode *head) {
12 if(!head || !head->next)
13 {
14 return false;
15 }
16 ListNode *pLast = head;
17 ListNode *pFast = head->next;
18
19 while(pFast && pFast->next)
20 {
21 if(pLast == pFast)
22 {
23 return true;
24 }
25 pLast = pLast->next;
26 pFast = pFast->next->next;
27 }
28 return false;
29 }
30 };
206. Reverse Linked List
https://leetcode.com/problems/linked-list-cycle/
Reverse a singly linked list.
Example:
Input: 1->2->3->4->5->NULL
Output: 5->4->3->2->1->NULL
Follow up:
A linked list can be reversed either iteratively or recursively. Could you implement both?
C 实现：
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * struct ListNode *next;
6 * };
7 */
8
9
10 struct ListNode* reverseList(struct ListNode* head){
11 struct ListNode* pCur = head;
12 struct ListNode* pRec = NULL;
13
14 while(pCur)
15 {
16 struct ListNode* pTem = NULL;
17
18 pTem = pCur->next;
19 pCur->next = pRec;
20 pRec = pCur;
21 pCur = pTem;
22 }
23 return pRec;
24 }
C++实现：
1 /**
2 * Definition for singly-linked list.
3 * struct ListNode {
4 * int val;
5 * ListNode *next;
6 * ListNode() : val(0), next(nullptr) {}
7 * ListNode(int x) : val(x), next(nullptr) {}
8 * ListNode(int x, ListNode *next) : val(x), next(next) {}
9 * };
10 */
11 class Solution {
12 public:
13 ListNode* reverseList(ListNode* head) {
14 ListNode *pNode = head;
15 ListNode *pRec = NULL;
16
17 while(pNode)
18 {
19 ListNode *pTem = NULL;
20
21 pTem = pNode->next;
22 pNode->next = pRec;
23 pRec = pNode;
24 pNode = pTem;
25 }
26 return pRec;
27 }
28 };