LeetCode---Sort && Segment Tree && Greedy

307. Range Sum Query - Mutable

思路：利用线段树，注意数据结构的设计以及建树过程利用线段树，注意数据结构的设计以及建树过程
public class NumArray {

class segmentNode{
    int start;
    int end;
    segmentNode left;
    segmentNode right;
    int sum;

    public segmentNode(int start,int end){
        this.start = start;
        this.end = end;
        this.left = null;
        this.right = null;
        this.sum = 0;
    }
}

segmentNode root = null;

public NumArray(int[] nums) {
    root = buildTree(nums,0,nums.length - 1);
}

public segmentNode buildTree(int[] nums,int start,int end){
    if(start > end) return null;
    else{
        segmentNode node = new segmentNode(start,end);
        if(start == end) node.sum = nums[start];
        else{
            int middle = start + (end - start) / 2;
            node.left = buildTree(nums,start,middle);
            node.right = buildTree(nums,middle + 1,end);
            node.sum = node.left.sum + node.right.sum;
        }
        return node;
    }
}

void update(int i, int val) {
    update(i,root,val);
}

public void update(int i,segmentNode root,int val){
    if(i == root.start && i == root.end) root.sum = val;
    else{
        int middle = root.start + (root.end - root.start) / 2;
        if(i <= middle){
            update(i,root.left,val);
        }
        else{
            update(i,root.right,val);
        }
        root.sum = root.left.sum + root.right.sum;
    }
}

public int sumRange(int i, int j) {
    return sumRange(i,j,root);
}

public int sumRange(int i,int j,segmentNode root){
    if(i == root.start && j == root.end) return root.sum;
    else{
        int middle = root.start + (root.end - root.start) / 2;
        if(i > middle) return sumRange(i,j,root.right);
        else if(j <= middle) return sumRange(i,j,root.left);
        else return sumRange(i,middle,root.left) + sumRange(middle + 1,j,root.right);
    }
}
}

376. Wiggle Subsequence

思路：首先跳过前面所有相等的元素，然后确定第一个是升序还是降序，接着利用贪心算法若降序取最小，若升序取最大，统计个数
public int wiggleMaxLength(int[] nums) {
    if(nums.length <= 1) return nums.length;
    int num = nums[0];
    int k = 1;
    while(k < nums.length){
        if(nums[k] == num) k++;
        else break;
    }
    if(k == nums.length) return 1;

    int res = 2;
    //继续用k是因为要跳过之前相等的元素
    boolean flag = (nums[k] > nums[k - 1]);
    //k++;
    while(++k < nums.length){
        if(flag && nums[k] < nums[k - 1]){
            flag = false;
            res++;
        }
        else if(!flag && nums[k] > nums[k - 1]){
            flag = true;
            res++;
        }
        //k++;
    }
    return res;
}

**406. Queue Reconstruction by Height

思路：按第一元素从大到小排，第二元素从小到大排，进行插入，第二元素实际上就是 插入的索引位置  

public int[][] reconstructQueue(int[][] people) {
    if(people.length == 0) return new int[0][0];
    Arrays.sort(people,new Comparator<int[]>(){
        @Override
        public int compare(int[] a,int[] b){
            if(a[0] == b[0]){
                return a[1] - b[1];
            }
            return b[0] - a[0];
        }
    });

    List<int[]> temp = new ArrayList<int[]>();
    for(int i = 0; i < people.length; i++){
        int[] ans = people[i];
        temp.add(ans[1],new int[]{ans[0],ans[1]});
    }

    int[][] res = new int[people.length][people[0].length];
    int i = 0;
    for(int[] k : temp){
        res[i][0] = k[0];
        res[i][1] = k[1];
        i++;
    }
    return res;
}

**330. Patching Array

思路：用sum标记可达区间的右区间，若元素大于sum则补一个sum，否则扩大可达区间

public int minPatches(int[] nums, int n) {
    //sum标记可达区间的右区间，开区间
    long sum = 1;//为了防止最后越界将sum设置为long
    int i = 0;
    int count = 0;
    while(sum <= n){
        if(i < nums.length && sum >= nums[i]){
            sum += nums[i];
            i++;
        }
        else{
            //表示1---sum - 1都可达,所以要补个sum
            sum += sum;
            count++;
        }
    }
    return count;
}

总结

164. Maximum Gap:排序以后进行比较找到最大间隔
56. Merge Intervals：同57
455. Assign Cookies：两个数组排序以后进行遍历，前面判断过的不再考虑，因为绝对不会符合条件

训练

179. Largest Number:通过string排序，让a + b和b + a进行比较，谁大排在前面，注意string之间的比较用compareTo，不能直接-，另外注意特殊情况（开头为0）
**57. Insert Interval：将new Interval加入list一起根据start从小到大排序，通过判断start与end的关系进行合并，注意可以直接利用Collections.sort()
452. Minimum Number of Arrows to Burst Balloons：根据start排序，若有交集则记录最小end，若没有则计数加一
134. Gas Station:根据代数关系得知必须油的总量大于路程耗油量才行，因此只需要找到能到数组末尾站的站点即可
**435. Non-overlapping Intervals：根据end从小到大排序，然后统计留下interval的数量，再用总数去减
135. Candy：先给每个孩子发一个糖，利用Arrays.fill()，然后两趟循环分别判断左右两边的关系

提示

数组排序用Arrays.sort()，抽象数据结构排序用Collections.sort()
优先队列排序直接在声明的时候就能定义排序方式，但注意优先队列的排序方式是堆排序