linked-list

Author: vegetabledogg

141-Linked-List-Cycle.c

@@ -0,0 +1,24 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    bool hasCycle(ListNode *head) {
+        ListNode *slow = head, *fast = head;
+        while (nullptr != fast && nullptr != fast->next)
+        {
+            fast = fast->next->next;
+            slow = slow->next;
+            if (fast == slow)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+};

141-Linked-List-Cycle.cpp

@@ -0,0 +1,45 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *detectCycle(ListNode *head) {
+        ListNode *slow = head, *fast = head;
+        while (nullptr != fast && nullptr != fast->next)
+        {
+            fast = fast->next->next;
+            slow = slow->next;
+            if (fast == slow)
+            {
+                break;
+            }
+        }
+        if (nullptr == fast || nullptr == fast->next)
+        {
+            return nullptr;
+        }
+        while (head != fast)
+        {
+            slow = fast;
+            while (1)
+            {
+                slow = slow->next;
+                if (slow == head)
+                {
+                    return head;
+                }
+                if (slow == fast)
+                {
+                    break;
+                }
+            }
+            head = head->next;
+        }
+        return fast;
+    }
+};

142-Linked-List-Cycle-II.cpp

@@ -0,0 +1,48 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* insertionSortList(ListNode* head) {
+        if (nullptr == head || nullptr == head->next)
+        {
+            return head;
+        }
+        ListNode *lastNode = head;
+        ListNode *insertNode, *pNode;
+        while (nullptr != lastNode->next)
+        {
+            insertNode = lastNode->next;
+            int tempVal = insertNode->val;
+            if (tempVal >= lastNode->val)
+            {
+                lastNode = insertNode;
+                continue;
+            }
+            lastNode->next = insertNode->next;
+            if (tempVal <= head->val)
+            {
+                insertNode->next = head;
+                head = insertNode;
+                continue;
+            }
+            pNode = head;
+            while (pNode->next != lastNode->next)
+            {
+                if (pNode->next->val >= tempVal)
+                {
+                    insertNode->next = pNode->next;
+                    pNode->next = insertNode;
+                    break;
+                }
+                pNode = pNode->next;
+            }
+        }
+        return head;
+    }
+};

147-Insertion-Sort-List.cpp

@@ -0,0 +1,26 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* deleteDuplicates(ListNode* head) {
+        ListNode *pNode = head;
+        while (nullptr != pNode && nullptr != pNode->next)
+        {
+            if (pNode->val == pNode->next->val)
+            {
+                pNode->next = pNode->next->next;
+            }
+            else
+            {
+                pNode = pNode->next;
+            }
+        }
+        return head;
+    }
+};

83-Remove-Duplicates-from-Sorted-List.cpp

@@ -0,0 +1,53 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* partition(ListNode* head, int x) {
+        ListNode *frontHead = nullptr, *frontTail, *backHead = nullptr, *backTail;
+        while (nullptr != head)
+        {
+            if (head->val < x)
+            {
+                if (nullptr == frontHead)
+                {
+                    frontHead = head;
+                    frontTail = head;
+                }
+                else
+                {
+                    frontTail->next = head;
+                    frontTail = frontTail->next;
+                }
+                head = head->next;
+                frontTail->next = nullptr;
+            }
+            else
+            {
+                if (nullptr == backHead)
+                {
+                    backHead = head;
+                    backTail = head;
+                }
+                else
+                {
+                    backTail->next = head;
+                    backTail = backTail->next;
+                }
+                head = head->next;
+                backTail->next = nullptr;
+            }
+        }
+        if (nullptr == frontHead)
+        {
+            return backHead;
+        }
+        frontTail->next = backHead;
+        return frontHead;
+    }
+};

86-Partition-List.cpp

@@ -0,0 +1,41 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* reverseBetween(ListNode* head, int m, int n) {
+        ListNode *tempNode, *pNode = head, *firstNode;
+        if (1 == m)
+        {
+            firstNode = head;
+            for (int i = 0; i < n - m; i++)
+            {
+                tempNode = firstNode->next;
+                firstNode->next = tempNode->next;
+                tempNode->next = head;
+                head = tempNode;
+            }
+        }
+        else
+        {
+            for (int i = 1; i < m - 1; i++)
+            {
+                pNode = pNode->next;
+            }
+            firstNode = pNode->next;
+            for (int i = 0; i < n - m; i++)
+            {
+                tempNode = firstNode->next;
+                firstNode->next = tempNode->next;
+                tempNode->next = pNode->next;
+                pNode->next = tempNode;
+            }
+        }
+        return head;
+    }
+};