CodeTop每日系列三题------------------2021.12.22

LC55. 跳跃游戏
//贪心算法，保存n - 1个元素可以跳跃的最长距离长度，不断循环迭代更新第i个元素当前最长可以到达的距离长度是多少

public static boolean canJump(int[] nums) {
        if (nums == null) {
            return false;
        }
        //前n-1个元素能够跳到的最远距离
        int k = 0;
        for (int i = 0; i <= k; i++) {
            //第i个元素能够跳到的最远距离
            int temp = i + nums[i];
            //更新最远距离
            k = Math.max(k, temp);
            //如果最远距离已经大于或等于最后一个元素的下标,则说明能跳过去,退出. 减少循环
            if (k >= nums.length - 1) {
                return true;
            }
        }
        //最远距离k不再改变,且没有到末尾元素
        return false;
    }

LC86. 分隔链表
//虚拟头节点然后迭代遍历即可

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode dummysmall = new ListNode(0);
        ListNode spoint = dummysmall;
        ListNode dummylarge = new ListNode(0);
        ListNode lpoint = dummylarge;
        while(head != null){
            if(head.val < x){
                spoint.next = head;
                spoint = spoint.next;
            }else{
                lpoint.next = head;
                lpoint = lpoint.next;
            }
            head = head.next;
        }
        lpoint.next = null;
        spoint.next = dummylarge.next;
        return dummysmall.next;
    }
}

LC114. 二叉树展开为链表
//其实就是先序遍历用一个list保存过后，通过先序递归遍历的结果然后循环遍历list当中的每一个节点将下一个节点放到上一个节点的右孩子上面去

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void flatten(TreeNode root) {
        List<TreeNode> list = new ArrayList<TreeNode>();
        preorderTraversal(root, list);
        int size = list.size();
        //通过list将下一个孩子一个个放到右节点中去
        for (int i = 1; i < size; i++) {
            TreeNode prev = list.get(i - 1), curr = list.get(i);
            prev.left = null;
            prev.right = curr;
        }
    }
    //通过先序遍历将树先保存到list当中
    public void preorderTraversal(TreeNode root, List<TreeNode> list) {
        if (root != null) {
            list.add(root);
            preorderTraversal(root.left, list);
            preorderTraversal(root.right, list);
        }
    }
}