题解5

402. 移除k位数字

方法一：

class Solution {
    public String removeKdigits(String num, int k) {
        if (num.length() == k)
            return "0";

        /*
        String类是不可变类，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。
        StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法
            可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。
        StringBuilder类也代表可变字符串对象。实际上，StringBuilder和StringBuffer基本相似，两个类的构造器和方法也基本相同。
            不同的是：StringBuffer是线程安全的，而StringBuilder则没有实现线程安全功能，所以性能略高。
        */
        
        StringBuilder s = new StringBuilder(num);
        /*
        从左到右扫描，找到第一个大于自身左边数的数删除，若没有找到，则证明字符串中的数是按照从大到小排序的，删除第一个即可。
        每次删除数后，清除字符串前面的0
        重复k次
        */
        for (int i = 0; i < k; i++) {
            int idx = 0;
            for (int j = 1; j < s.length() && s.charAt(j) >= s.charAt(j - 1); j++)
                idx = j;
            s.delete(idx, idx + 1);
            while (s.length() > 1 && s.charAt(0) == '0')
                s.delete(0, 1);
        }
        return s.toString();
    }
}

方法二：

class Solution {
    public String removeKdigits(String num, int k) {
        if(num.length() == k) {
            return "0";
        }
        StringBuilder s = new StringBuilder();
        int n = num.length() - k;  //n记录结果应该有几个数字
        /*
        类似于维护一个最小栈
        扫描num的每一个数，如果s的最后一个元素大于当前元素，则删除最后一个元素加入新的
        这样s中的元素就按照从小到大的顺序排序，这时有可能删除的数不够k个，
        所以s只保留前n个元素即可
        */
        for (char c : num.toCharArray()) {
            while (k != 0 && s.length() > 0 && s.charAt(s.length() - 1) > c) {
                s.deleteCharAt(s.length() - 1);
                k --;
            }
            s.append(c);
        }
        s.delete(n, s.length());

        while (s.length() > 1 && s.charAt(0) == '0') {
            s.delete(0, 1);
        }
        return s.toString();
    }
}

56. 合并区间

class Solution {
    public int[][] merge(int[][] intervals) {
        List<int[]> res = new ArrayList<>();
        if (intervals.length == 0 || intervals == null)
            return res.toArray(new int[0][]);
        //对起点进行排序
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
        //遍历每个集合，如果有重叠，合并后放入res，无重叠则直接放入
        for(int i = 0; i < intervals.length; i++) {
            int left = intervals[i][0];
            int right = intervals[i][1];
            //如果有重叠，扫描后面的区间，如果起点小于等于当前区间的终点，则更新终点
            while (i < intervals.length - 1 && intervals[i + 1][0] <= right) {
                i++;
                right = Math.max(right, intervals[i][1]);
            }
            //将现在的区间放进res里面
            res.add(new int[]{left, right});
        }
        return res.toArray(new int[0][]);
    }
}

622. 设计循环队列

class MyCircularQueue {
    private int maxSize;  //数组的最大容量
    private int head;  //队列头，指向队列的第一个元素
    private int tail;  //队列尾，指向队列的最后一个元素的下一个位置
    private int[] arr;  //队列
    
    public MyCircularQueue(int k) {
        maxSize = k+1;  //因为数组中始终有一个位置是空的，所以需要多创建一个位置
        arr = new int[maxSize];
    }
    
    public boolean enQueue(int value) {
        if(isFull()){
            return false;
        }
        arr[tail] = value;
        tail = (tail + 1) % maxSize;
        return true;
    }

    public boolean deQueue() {
        if(isEmpty()){
            return false;
        }
        head = (head + 1) % maxSize;
        return true;
    }

    public int Front() {
        if(isEmpty()){
            return -1;
        }
        return arr[head];
    }
	//因为队列尾是最后一个元素的下一个元素，如果队列尾正好是0，那么最后一个元素的下标应该是arr.length-1
    public int Rear() {
        if(isEmpty()){
            return -1;
        }
        if(tail == 0)
            return arr[arr.length-1];
        return arr[tail - 1];
    }
	//如果队列首等于队列尾，则证明队列位空
    public boolean isEmpty() {
        return head == tail;
    }
	//如果队列尾的下一个是队列首，则证明队列满
    public boolean isFull() {
        return (tail + 1) % maxSize == head;
    }
}