力扣爆刷第152天之TOP100五连刷16-20（买卖股票、回溯、公共祖先、环形链表）

力扣爆刷第152天之TOP100五连刷16-20（买卖股票、回溯、公共祖先、环形链表）

一、121. 买卖股票的最佳时机

题目链接：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/description/
思路：本题可以使用动态规划或者贪心算法来做。
动态规划：动态规划就是状态与选择，每一天都有两种状态，即持有股票和不持有股票，而持有股票又分为之前就持有和今天才持有，不持有股票也分为之前就不持有和今天才不持有。以此可以得到状态转移方程。

class Solution {
    public int maxProfit(int[] prices) {
        int[] dp = new int[2];
        dp[0] = -prices[0];
        for(int i = 1; i < prices.length; i++) {
            dp[0] = Math.max(dp[0], -prices[i]);
            dp[1] = Math.max(dp[1], dp[0] + prices[i]);
        }
        return dp[1];
    }
}

贪心算法：因为只能买卖一次，所以只需要从前往后遍历，然后不停的记录最大和最小值。即可。

class Solution {
    public int maxProfit(int[] prices) {
        int max = -Integer.MIN_VALUE, min = prices[0];
        for(int i = 0; i < prices.length; i++) {
            min = Math.min(min, prices[i]);
            max = Math.max(max, prices[i] - min);
        }
        return max;
    }
}

二、88. 合并两个有序数组

题目链接：https://leetcode.cn/problems/merge-sorted-array/description/
思路：归并排序，没啥好说的，如果不想使用新数组，可以从大到小进行归并。

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int[] temp = new int[nums1.length];
        int k = 0, i = 0, j = 0;
        while(i < m && j < n) {
            if(nums1[i] <= nums2[j]) temp[k++] = nums1[i++];
            else temp[k++] = nums2[j++];
        }
        while(i < m) temp[k++] = nums1[i++];
        while(j < n) temp[k++] = nums2[j++];
        i = 0;
        while(i < n+m) {
            nums1[i] = temp[i];
            i++;
        }
    }
}

三、141. 环形链表

题目链接：https://leetcode.cn/problems/linked-list-cycle/description/
思路：求链表是否有环，很经典的快慢指针，慢指针每次只走一步，快指针每次走两步，如果可以相遇说明有环，无法相遇说明没环。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;`在这里插入代码片`
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode slow = head, fast = head;
        while(fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if(slow == fast) return true;
        }
        return false;
    }
}

四、46. 全排列

题目链接：https://leetcode.cn/problems/permutations/description/
思路：经典回溯题目，是求排列，不是组合。求排列的话，递归不需要起始位置，但是需要避免同一个元素纵向重复使用，故使用一个标记数组，递归进入标记，递归返回清楚，故只影响纵向，不影响横向。

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    boolean[] flag;
    public List<List<Integer>> permute(int[] nums) {
        flag = new boolean[nums.length];
        backTracking(nums);
        return result;
    }
    
    void backTracking(int[] nums) {
        if(list.size() == nums.length) {
            result.add(new ArrayList(list));
            return;
        }
        for(int i = 0; i < nums.length; i++) {
            if(flag[i]) continue;
            flag[i] = true;
            list.add(nums[i]);
            backTracking(nums);
            flag[i] = false;
            list.remove(list.size()-1);
        }
    }
    
}

五、236. 二叉树的最近公共祖先

题目链接：https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/description/
思路：经典题目，求二叉树的最近公共祖先，因为是求父节点，所以得通过子节点来确认，故需要使用后序遍历，通过递归的返回拿到子节点的信息。在每次进行递归时都先判断一下，当前节点是否是q或者p，是的话就返回。然后我们就可以通过左右子树的递归返回，看看是否为Null，谁不为null就返回谁，都不为null，则说明此时的父节点即为最近公共祖先。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null || root == p || root == q) return root;
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if(left == null && right == null) return null;
        if(left == null && right != null) return right;
        if(left != null && right == null) return left;
        return root;
    }
}