【LEETCODE】60、数组分类，适中级别，题目：7五、560、105

package y2019.Algorithm.array.medium;

/**
 * @ProjectName: cutter-point
 * @Package: y2019.Algorithm.array.medium
 * @ClassName: SortColors
 * @Author: xiaof
 * @Description: TODO 75. Sort Colors
 * Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent,
 * with the colors in the order red, white and blue.
 * Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
 *
 * Input: [2,0,2,1,1,0]
 * Output: [0,0,1,1,2,2]
 *
 * 给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
 * 此题中，咱们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
 * 来源：力扣（LeetCode）
 * 连接：https://leetcode-cn.com/problems/sort-colors
 * 著做权归领扣网络全部。商业转载请联系官方受权，非商业转载请注明出处。
 *
 * 大神答案参考：https://leetcode.com/problems/sort-colors/discuss/26472/Share-my-at-most-two-pass-constant-space-10-line-solution
 *
 * @Date: 2019/7/19 9:03
 * @Version: 1.0
 */
public class SortColors {

    public void solution(int[] nums) {
        //这里进行hash放置的话，可能会产生冲突，那么就须要把hash值依次日后排，而后和对应的值交换位置
        //针对这题，由于只有三类数据，那么0再最开头，2再最末尾，其他的就会被放到中间
        int index0 = 0, index2 = nums.length - 1;
        for(int i = 0; i <= index2; ++i) {
            while(nums[i] == 2 && i < index2) {
                //当指定位置是2,那么咱们吧他交换到指定的2的位置
                //而且这里赋值字后，若是值改变了，那么就会跳出while循环，NB
                nums[i] = nums[index2];
                nums[index2--] = 2;
            }
            //而后交换0的位置
            while(nums[i] == 0 && i > index0) {
                nums[i] = nums[index0];
                nums[index0++] = 0;
            }
        }

    }

    public static void main(String[] args) {
        int data[] = {2,0,2,1,1,0};
        SortColors fuc = new SortColors();
        fuc.solution(data);
        System.out.println();
    }
}

 

package y2019.Algorithm.array.medium;

import java.util.HashMap;
import java.util.Map;

/**
 * @ProjectName: cutter-point
 * @Package: y2019.Algorithm.array.medium
 * @ClassName: SubarraySum
 * @Author: xiaof
 * @Description: TODO 560. Subarray Sum Equals K
 *
 * Given an array of integers and an integer k, you need to find the total number of continuous subarrays whose sum equals to k.
 * Input:nums = [1,1,1], k = 2
 * Output: 2
 *
 * @Date: 2019/7/19 9:50
 * @Version: 1.0
 */
public class SubarraySum {

    public int solution(int[] nums, int k) {
        //查子串和，那么咱们遍历这个数组，而后求子串值，若是和超了，那么就把最前面的数剔除掉，而后再比较，小了就日后
        int sum = 0, count = 0;
        Map<Integer, Integer> sumMap = new HashMap();
        sumMap.put(0, 1); //和为0的状况那么就是单独一个元素
        //因为是求子串，子串是连续的，那么咱们只要求出i->j连续的和是k便可
        //而i->j = 0->j - 0->i 的差值,转而言之，咱们须要把k + {0->i} = {0->j}求出来个数便可
        for(int i = 0; i < nums.length; ++i) {
            sum += nums[i];
            //这里不须要考虑后面没有put进去的sum，由于咱们要求i->j的和，只要判断前面的数据就能够了，后面的和放在后面比较
            if(sumMap.containsKey(sum - k)) {
                //那么就是存在
                count += sumMap.get(sum - k);
            }
            //若是不包含，那么就把值放入，进行下一个子串的遍历
            sumMap.put(sum, sumMap.getOrDefault(sum, 0) + 1);
        }


        return count;
    }
}

 

package y2019.Algorithm.array.medium;

/**
 * @ProjectName: cutter-point
 * @Package: y2019.Algorithm.array.medium
 * @ClassName: BuildTree
 * @Author: xiaof
 * @Description: TODO 105. Construct Binary Tree from Preorder and Inorder Traversal
 *  Given preorder and inorder traversal of a tree, construct the binary tree.
 *
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 *
 * preorder = [3,9,20,15,7]
 * inorder = [9,3,15,20,7]
 *
 *      3
 *    / \
 *   9  20
 *     /  \
 *    15   7
 *
 * @Date: 2019/7/19 10:31
 * @Version: 1.0
 */
public class BuildTree {

    public class TreeNode {
        private int value;
        private TreeNode left;
        private TreeNode right;

        public TreeNode(int x) {
            this.value = x;
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        public TreeNode getLeft() {
            return left;
        }

        public void setLeft(TreeNode left) {
            this.left = left;
        }

        public TreeNode getRight() {
            return right;
        }

        public void setRight(TreeNode right) {
            this.right = right;
        }
    }

    public TreeNode solution(int[] preorder, int[] inorder) {
        //根据前序遍历和中序组建一颗树
        //探索类，考虑递归
        return backTrack(preorder, 0, inorder, 0, inorder.length - 1);

    }

    public TreeNode backTrack(int[] preorder, int preLeft, int[] inorder, int inLeft, int inRight) {
        if(preLeft > preorder.length - 1 || inLeft > inRight) {
            return null;
        }
        //若是没有，咱们能够吧当前树的前序遍历第一个当成根
        TreeNode curRoot = new TreeNode(preorder[preLeft]);
        int midIndex = 0;
        //而后咱们去中序寻找中间点
        for(int i = inLeft; i <= inRight; ++i) {
            if(preorder[preLeft] == inorder[i]) {
                //找到位置
                midIndex = i;
            }
        }

        //中分两边中序
        //左子树
        curRoot.setLeft(backTrack(preorder, preLeft + 1, inorder, inLeft, midIndex - 1));
        curRoot.setRight(backTrack(preorder, preLeft + midIndex + 1 - inLeft, inorder, midIndex + 1, inRight));
        return curRoot;
    }


    public static void main(String[] args) {
        int preorder1[] = {3,9,20,15,7};
        int inorder1[] = {9,3,15,20,7};
        BuildTree fuc = new BuildTree();
        fuc.solution(preorder1, inorder1);
        System.out.println();
    }
}