leetcode刷题-链表#1

82. Remove Duplicates from Sorted List II [medium]

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

Example 1:

Input: 1->2->3->3->4->4->5
Output: 1->2->5

Example 2:

Input: 1->1->1->2->3
Output: 2->3

• 思路1：相同的数都是相邻的。所以一个fast指针来寻找。如果当前和下一个节点数值相同，就记录这个值，让fast指针走到下一个不为这个值的地方。否则就可以把当前节点加入返回链表之中。最后fast如果不为NULL，说明走到最后一个节点，而且最后一个节点数值不重复，把最后一个节点也要加入返回链表中。
• 注意：
  • 可以添加一个头节点，这样会方便一点。
  • 新创建节点会简单一点。

/**
 * 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) {
        if (head == NULL || head->next == NULL)
            return head;
        ListNode* ret, *fast = head, *dummy = new ListNode(-1), *slow = dummy;
        int same;
        while(fast != NULL and fast->next != NULL) {
            if (fast->val == fast->next->val) {
                same = fast->val;
                while(fast && fast->val == same) {
                    fast = fast->next;
                }
            } else {
                slow->next = new ListNode(fast->val);
                slow = slow->next;
                slow->next = NULL;
                fast = fast->next;
            }
        }
        if (fast) {
            slow->next = new ListNode(fast->val);
            slow = slow->next;
            slow->next = NULL;
            fast = fast->next;
        }
        return dummy->next;
    }
};

• 思路2：看到别人还有一种递归的方法。如果当前和下一个相同，就一直往下找到不同的。否则把这个节点加到返回链表之中。然后再递归处理下一个节点。
• 注意：比较tricky。

/**
 * 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) {
        if (head == NULL || head->next == NULL)
            return head;
        if(head->val == head->next->val) {
            while(head->next && head->val == head->next->val) {
                head = head->next;
            }
            return deleteDuplicates(head->next);
        } else {
            head->next = deleteDuplicates(head->next);
        }
        return head;
    }
};

83. Remove Duplicates from Sorted List [easy]

Given a sorted linked list, delete all duplicates such that each element appear only once.

Example 1:

Input: 1->1->2
Output: 1->2

Example 2:

Input: 1->1->2->3->3
Output: 1->2->3

• 思路：保存上一个数字，如果当前数字发生重复了，跳过删除就好。
• 注意：可能会只删除一个，注意如果是重复就删除。不是的话才往下走。

/**
 * 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 *ptr = head, *next = NULL;
        while(ptr != NULL && ptr->next != NULL) {
            next = ptr->next;
            if (ptr->val == next->val) {
                // skip duplicat node
                ptr->next = next->next;
                delete(next);
            } else {
                ptr = ptr->next;    
            }
        }
        return head;
    }
};

 

19. Remove Nth Node From End of List [medium]

Given a linked list, remove the n-th node from the end of list and return its head.

Example:

Given linked list: 1->2->3->4->5, and n = 2.

After removing the second node from the end, the linked list becomes 1->2->3->5.

Note:

Given n will always be valid.

Follow up:

Could you do this in one pass?

• 思路：去除倒数第二个数字，而且要一遍。不过保证n是有效的。所以考虑就两个指针。第一个指针走了n步之后第二个开始走。第一个指针走到底的时候，第二个指针也就走到倒数第二个位置了。这个时候删除就可以。
• 注意:
  • 链表是没有头节点的。
  • 如果只有一个元素，或者说要删除第一个元素。这样第一个节点走n步之后就到头了。这个时候直接返回head->next。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
         ListNode* ptr1 = head, *ptr2 = head;
        for(int i = 0; i < n; i++) {
            ptr1 = ptr1->next;
        }
        if(ptr1 == NULL) {
            // ptr1 at the end of the array, so return [1:]of list
            return head->next;
        }
        while(ptr1->next != NULL && ptr2->next != NULL) {
            ptr1 = ptr1->next;
            ptr2 = ptr2->next;
        }
        ListNode* next = ptr2->next;
        ptr2->next = next->next;
        delete(next);
        return head;
    }
};