leetcode21-30

21 Merge Two Sorted Lists
思路：新建一个链表，比较l1和l2中的值，哪个小就把它加到新的链表中去，最后总会有一个链表先到尾部，那么直接把剩下的链表接到新链表尾部就可以啦，注意链表为空问题判断，必须先初始化。

 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode temp(0);
        ListNode* dummy = &temp; //如果只写ListNode* dummy,会报错。
        ListNode* cur;
        cur = dummy;
        while(l1 && l2) {
            if (l1->val < l2->val) {
                cur->next = l1;
                l1 = l1->next;
            }
            else {
                cur->next = l2;
                l2 = l2->next;
            }
            cur = cur->next;
        }
        cur->next = l1 ? l1 : l2;
        return dummy->next;
    }

思路2：递归算法

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (!l1) return l2;
        if (!l2) return l1;
        if (l1->val < l2->val) {
            l1->next = mergeTwoLists(l1->next,l2);
            return l1;
        }
        else {
            l2->next = mergeTwoLists(l1,l2->next);
            return l2;
        }
    }

22.Generate Parentheses
思路：我在这里用递归和回溯法，卡住了半个月，这一段时间，一直没绕过来这个弯，什么递归啦，回溯法，DFS，虽然现在也不是特别懂，但是我想，还是多多刷题，找感觉。
left表示剩余左括号数，right表示剩余右括号数，首先遵循原则：先生成左括号，然后右括号 ，右括号剩余个数必须要比左括号多。当左右括号剩余都为0时，结束。

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> v;
        helper(v,"",n,n);
        return v;
    }
    void helper(vector<string> &v,string temp,int left,int right) {
       if (left == 0 && right == 0) {
           v.push_back(temp);
           return;
       }
        if (left > 0 ) {
            helper(v,temp+"(",left-1,right);
        }
        if (right > left) {
            helper(v,temp+")",left,right-1);
        }
    }
};

23.Merge k Sorted Lists
思路：k个链表进行合并，可以用归并，先写一个合并两个链表的函数mergeTwo(l1,l2),比较l1和l2的val，最后如果其中一个链表为空，则指向另外一个链表。

ListNode* mergeKLists(vector<ListNode*>& lists) {
        if (lists.size() == 0)
            return NULL;
        int n = lists.size();
        while(n > 1) {
            int k = (n + 1) / 2;
            for (int i = 0;i < n/2;i++) {
                lists[i] = mergeTwo(lists[i],lists[i+k]);
            }
            n = k;
        }
        return lists[0];
    }
    ListNode* mergeTwo(ListNode* l1,ListNode* l2) {
        ListNode* dummy = new ListNode(-1);
        ListNode* pre = dummy;
        while(l1 && l2) {
            if (l1->val < l2->val) {
                pre->next = l1;
                l1 = l1->next;
            }
            else {
                pre->next = l2;
                l2 = l2->next;
            }
            pre = pre->next;
        }
        if (l1) pre->next = l1;
        if (l2) pre->next = l2;
        return dummy->next;
    }

24.Swap Nodes in Pairs
思路1：需要一个假节点，指向head，首先判断head是否为NULL，如果NULL，则返回NULL，然后进行pre,head,head->next之间的交换，最主要就是各节点之间的指向关系变换。

ListNode* swapPairs(ListNode* head) {
        if (!head)
            return NULL;
        ListNode* pre = new ListNode(-1);
        pre->next = head;
        ListNode* temp = pre;
        while (temp->next&& temp->next->next) {
            ListNode* t = temp->next->next;
            temp->next->next = t->next;
            t->next = temp->next;
            temp->next = t;
            temp = temp->next->next;
        }
        return pre->next;
    }

思路2：递归。判断head和head->next是否为空，为空的话，返回head。否则，t = head->next,然后swapPairs(t->next)递归调用，返回的值相当于是第三个节点，然后让head指向它，t指向head，返回t.

ListNode* swapPairs(ListNode* head) {
        if (!head || !head->next) {
            return head;
        }
        ListNode* t = head->next;
        head->next = swapPairs(t->next);
        t->next = head;
        return t;
    }

26.Remove Duplicates from Sorted Array
思路：要求在原址上进行删除操作，但是并不是实际上的删除重复元素。比如说，数组为【0，0，0，1，1，2，2，3】，我们只需要得到数组为【0，1，2，3，0，0，1，2】就可以啦，返回前边非重复的数字个数4，并且可以通过下标进行访问，下标就是0-3.所以用双指针，i表示慢的那个指针，j表示快的指针，初始化j=i+1，然后如果nums[j] == nums[i],那就说明重复项，跳过，j+1,再进行比较，如果nums[i] != nums[j]，说明不是重复项，可以接在i后面，也就是让i+1,swap(nums[i],nums[j])。最后返回的是i的值。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.empty())
            return 0;
        int i = 0;
        for (int j = i + 1; j < nums.size(); j++) {
            if (nums[j] != nums[i]) {
                i++;
                swap(nums[i],nums[j]);
            }
        }
        return i+1;
    }
};

27.Remove Element
思路：这题和上一道题差不多，还是要用两个指针，比较和val值是否相等，如果不相等就放入nums[i]

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int i = 0;
        for (int j = 0; j < nums.size(); j++) {
            if (nums[j] != val) {
                nums[i] = nums[j];
                i++;
            }
        }
        return i;
    }
};

28.Implement strStr()
思路：这道题是找子字符串在原字符串中出现的位置，用到了C++中的substr函数。首先判断needle是否为空，然后判断haystack的长度是否比needle小；从 i = 0开始，到haystack.size() - needle.size()+1结束，判断从i开始长度为needle.size() 的字符串是否和needle一样，如果相等，直接输出i。

class Solution {
public:
    int strStr(string haystack, string needle) {
        if (needle.empty()) 
            return 0;
        if (needle.size() > haystack.size()) 
            return -1;
        for (int i = 0; i < haystack.size() - needle.size() + 1; i++) {
            if (haystack.substr(i,needle.size()) == needle)
                return i;
        }
        return -1;
    }
};

29. Divide Two Integers
思路：计算除法，不能用乘法，取模等，所以这时候用到位运算。首先，除数被除数都变成long long 类型绝对值，最后用符号判断是否乘-1；如果除数为0，返回INT_MAX；如果m >= n,这时候count = 1，p赋值为n,判断m和p<<1的大小，如果大的话count也扩大两倍也就是count<<1.当m < p<<1的时候，退出内层循环，m = m - p,继续进行上面的循环判断。最后return 判断的是被除数是比如被除数是-2147483648，在int范围内，当除数是-1时，结果就超出了int范围，需要返回INT_MAX这种情况。

int divide(int dividend, int divisor) {
        long long m = abs((long long) dividend);
        long long n = abs((long long) divisor);
        long long res = 0;
        if (divisor == 0 )
            return INT_MAX;

        while (m >= n) {
            long long p = n;
            long long count = 1;
            while (m >= p<<1) {
                count <<= 1;
                p <<= 1;
            }
            m = m - p;
            res += count;
        }
        res = (dividend < 0) ^ (divisor < 0) ? -res : res;
        return res > INT_MAX ? INT_MAX : res;
    }

30.Next Permutation
思路：求下一个全排列。首先，我们要清楚全排列是怎么生成的。1.从增序开始，（1，2，3，4，5）2.从末尾元素向前找，找到第一个非递减元素，标记i；3.然后从末尾向前找，第一个比nums[i]大的元素j，swap(nums[i],nums[j]);4.从i+1到末尾，进行reverse（）.5.如果是54321，那么下一个排列是reverse（）–>12345.

void nextPermutation(vector<int>& nums) {
        int n = nums.size();
        for (int i = n - 2; i >= 0; i--) {
            if (nums[i] <= nums[i+1]) {
                for (int j = n - 1; j > i; j--) {
                    if (nums[j] > nums[i]) {
                        swap(nums[i],nums[j]);
                        reverse(nums.begin()+i+1,nums.end());
                        return;
                    }
                }
            }
        }
        reverse(nums.begin(),nums.end());
    }