算法分析与设计第十三周

本周做了两题
第一题：

此题比较简单，直接上代码

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {

        int index = 0;
        vector<int> tmp(nums.size(), 0);

        for (int i = 0; i < nums.size(); ++i)
        {
            if (index < 2 || nums[i - 2] < nums[i])
                tmp[index++] = nums[i];
        }

        nums = tmp;
        return index; 
    }
};

通过截图：

第二题：

分析：此题主要考对链表的理解，指针的操作比较烦，调试了好久。看了看讨论，发现可以用递归做，代码写起来简单很多。先上我的代码

/**
 * 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 && head->next->next == NULL)
            return NULL;
        ListNode* newHead;
    ListNode* curr = head;
    ListNode* newCurr = new ListNode(head->val);
    newHead = newCurr;

    while (curr != NULL && curr->next != NULL)
    {
        int flag = curr->val;

        if (flag != curr->next->val)
        {
            newCurr->next = new ListNode(flag);
            newCurr = newCurr->next;
            curr = curr->next;
        }

        else
            while (curr != NULL && flag == curr->val)
                curr = curr->next;

    }

    if (curr != NULL)
        newCurr->next = curr;
    return newHead->next;
    }
};

通过截图：

附上别人的递归代码,比我的代码简洁很多：

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if (!head) return 0;
        if (!head->next) return head;

        int val = head->val;
        ListNode* p = head->next;

        if (p->val != val) {
            head->next = deleteDuplicates(p);
            return head;
        } else {
            while (p && p->val == val) p = p->next;
            return deleteDuplicates(p);
        }
    }
};