九章算法强化

第一节：follow up问题

1.两数之和 II

--给一组整数，问能找出多少对整数，他们的和大于一个给定的目标值。

解析：与two sum类似，先排序，再两指针。

class Solution {
public:
    /**
     * @param nums: an array of integer
     * @param target: an integer
     * @return: an integer
     */
    int twoSum2(vector<int> &nums, int target) {
        // Write your code here
        sort(nums.begin(), nums.end());
        int left = 0; 
        int right = nums.size() - 1;
        int ans = 0;
        while (left < right)
        {
            if (nums[left] + nums[right] > target)
            {
                ans += right - left;
                right--;
            } else 
            {
                left++;
            }
        }
        return ans;
    }
};

2.三角形计数

--给定一个整数数组，在该数组中，寻找三个数，分别代表三角形三条边的长度，问，可以寻找到多少组这样的三个数来组成三角形？

解析：two sumII的follow up ，卡在怎么同时证明三个数任意两个之和大于第三个数，其实数组排序了之后，只要证明两个小的数之和大于大的数就可以了。

class Solution {
public:
    /**
     * @param S: A list of integers
     * @return: An integer
     */
    int triangleCount(vector<int> &S) {
        // write your code here
        sort(S.begin(), S.end());
        int ans = 0;
        for (int i = 2; i < S.size(); i++) 
        {
            int left = 0;
            int right = i - 1;
            while (left < right)
            {
                if (S[left] + S[right] > S[i])
                {
                    ans += right - left;
                    right--;
                } else
                {
                    left++;
                }
            }
        }
        return ans;
    }
};

3.排序矩阵中的从小到大第k个数

--在一个排序矩阵中找从小到大的第 k 个整数。排序矩阵的定义为：每一行递增，每一列也递增。

解析：优先级队列往右和下两个方向遍历，记住两个方向遍历的小技巧，还有上下左右四个方向遍历的技巧，int posX = {0,1,0,-1};int posY = {-1,0,1,0};

public class Solution {
    /**
     * @param matrix: a matrix of integers
     * @param k: an integer
     * @return: the kth smallest number in the matrix
     */
    public int kthSmallest(int[][] matrix, int k) {
        // write your code here
        if (matrix == null || k < 1) {
            return 0;
        }
        int m = matrix.length;
        int n = matrix[0].length;
        if (m == 0 || n == 0) {
            return 0;
        }
        boolean[][] visited = new boolean[m][n];
        PriorityQueue<Element> pq = new PriorityQueue<>(k, new MyComparator());
        pq.offer(new Element(0, 0, matrix[0][0]));
        visited[0][0] = true;
        //向右和向下两个方向遍历
        int[] posX = {0,1};
        int[] posY = {1,0};
        
        for (int i = 0; i < k - 1; i++) {
            Element cur = pq.poll();
            for (int j = 0; j < 2; j++) {
                int x_next = cur.x + posX[j];
                int y_next = cur.y + posY[j];
                if (x_next < m && y_next < n && !visited[x_next][y_next]) {
                    pq.offer(new Element(x_next, y_next, matrix[x_next][y_next]));
                    visited[x_next][y_next] = true;
                }
            }
        }
        return pq.poll().val;
    }
    public class Element {
        int x = 0;
        int y = 0;
        int val = 0;
        public Element(int x, int y, int val) {
            this.x = x;
            this.y = y;
            this.val = val;
        }
    }
    public class MyComparator implements Comparator<Element> {
        public int compare(Element e1, Element e2) {
            return e1.val - e2.val;
        }
    }
}

4.排序矩阵中的从小到大第k个数follow up ---两个排序数组和的第k小

--给定两个排好序的数组 A, B，定义集合 sum = a + b ，求 sum 中第k小的元素。

解析：这题跟第3题其实是一样的，给出 A = [1,7,11] B = [2,4,6]，可以得出和的表格

A\B	2	4	6
1	3	5	7
7	9	11	13
11	13	16	17

 

 

 

 

其实和的矩阵就是第三题的行列递增的矩阵，所以解法与第三题是相同的。

第二节-- 高级数据结构

1.并查集

并查集的两个基本操作，查询与合并。

查询--找到这个节点的最终父节点，使用带压缩路径的递归，可以做到O(1)平均时间复杂度。

合并--合并两个集合，方法是将两个集合的根结点连接起来，O(1)平均时间复杂度。

并查集原生题

a.connecting graph 

题意：

Given n nodes in a graph labeled from 1 to n. There is no edges in the graph at beginning.

You need to support the following method:
1. connect(a, b), add an edge to connect node a and node b. 
2.query(a, b)`, check if two nodes are connected


样例
5 // n = 5
query(1, 2) return false
connect(1, 2)
query(1, 3) return false
connect(2, 4)
query(1, 4) return true

解法：

public class ConnectingGraph { 
    int[] father;
    public ConnectingGraph(int n) {
        // initialize your data structure here.
        father = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            father[i] = i;
        }
    }

    public void connect(int a, int b) {
        // Write your code here
        int fa = find(a);
        int fb = find(b);
        if (fa != fb) {
            father[fa] = fb;
        }
    }
        
    public boolean  query(int a, int b) {
        // Write your code here
        if (find(a) == find(b)) {
            return true;
        }
        return false;
    }
    public int find(int a) {
        // Write your code here
        if (father[a] == a) {
            return a;
        }
        return father[a] = find(father[a]);
    }
}

b.connecting graph II

题意：

Given n nodes in a graph labeled from 1 to n. There is no edges in the graph at beginning.

You need to support the following method:
1. connect(a, b), an edge to connect node a and node b
2. query(a), Returns the number of connected component nodes which include node a.

样例
5 // n = 5
query(1) return 1
connect(1, 2)
query(1) return 2
connect(2, 4)
query(1) return 3
connect(1, 4)
query(1) return 3

解法：

public class ConnectingGraph2 {

    int[] father;
    int[] size;
    public ConnectingGraph2(int n) {
        // initialize your data structure here.
        father = new int[n + 1];
        size = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            father[i] = i;
            size[i] = 1;
        }
    }

    public void connect(int a, int b) {
        // Write your code here
        int fa = find(a);
        int fb = find(b);
        if (fa != fb) {
            father[fa] = fb;
            size[fb] += size[fa];
        }
    }
        
    public int query(int a) {
        // Write your code here
        return size[find(a)];
    }
    public int find(int a) {
        if (father[a] == a) {
            return a;
        }
        return father[a] = find(father[a]);
    }
}

c.connecting graph III

题意：

Given n nodes in a graph labeled from 1 to n. There is no edges in the graph at beginning.

You need to support the following method:
1. connect(a, b), an edge to connect node a and node b
2. query(), Returns the number of connected component in the graph

样例
5 // n = 5
query() return 5
connect(1, 2)
query() return 4
connect(2, 4)
query() return 3
connect(1, 4)
query() return 3

解法：

public class ConnectingGraph3 {

    int[] father;
    int count;
    public ConnectingGraph3(int n) {
        father = new int[n + 1];
        count = n;
        for (int i = 1; i <= n; i++) {
            father[i] = i;
        }
    }

    public void connect(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        if (root_a != root_b) {
            father[root_a] = root_b;
            count--;
        }
    }
        
    public int query() {
        return count;
    }
    public int find(int x) {
        if (father[x] == x) {
            return x;
        }
        return father[x] = find(father[x]);
    }
}

 衍生题--Number of Islands II

题意：

给定 n，m，分别代表一个2D矩阵的行数和列数，同时，给定一个大小为 k 的二元数组A。起初，2D矩阵的行数和列数均为 0，即该矩阵中只有海洋。二元数组有 k 个运算符，每个运算符有 2 个整数 A[i].x, A[i].y，你可通过改变矩阵网格中的[A[i].x，[A[i].y] 来将其由海洋改为岛屿。请在每次运算后，返回矩阵中岛屿的数量。

 注意事项
0 代表海，1 代表岛。如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。

样例
给定 n = 3, m = 3， 二元数组 A = [(0,0),(0,1),(2,2),(2,1)].

返回 [1,1,2,2].

解法：其实就是求集合的个数，然后在新的岛屿生成后，将上下左右的集合合并就好。

/**
 * Definition for a point.
 * class Point {
 *     int x;
 *     int y;
 *     Point() { x = 0; y = 0; }
 *     Point(int a, int b) { x = a; y = b; }
 * }
 */
public class Solution {
    /**
     * @param n an integer
     * @param m an integer
     * @param operators an array of point
     * @return an integer array
     */
    private int[] father;
    public List<Integer> numIslands2(int n, int m, Point[] operators) {
        // Write your code here
        if (n == 0 || m == 0 || operators == null || operators.length == 0) {
            return new ArrayList<>();
        }
        father = new int[n * m];
        for (int i = 0; i < n * m; i++) {
            father[i] = -1;
        }
        int num = 0;
        int len = operators.length;
        int[] posX = {0, 1, -1, 0};
        int[] posY = {1, 0, 0, -1};
        List<Integer> ans = new ArrayList<>();
        for (int i = 0; i < len; i++) {
            int x = operators[i].x;
            int y = operators[i].y;
            if (father[x * m + y] != -1) {
                ans.add(num);
                continue;
            }
            father[x * m + y] = x * m + y;
            num++;
            for (int j = 0; j < 4; j++) {
                int nX = x + posX[j];
                int nY = y + posY[j];
                if (nX >= 0 && nX < n && nY >= 0 && nY < m && father[nX * m + nY] != -1) {
                    num = union(x * m + y, nX * m + nY, num);
                }
            }
            ans.add(num);
        }
        return ans;
    }
    public int find(int a) {
        if (father[a] == a) {
            return a;
        }
        return father[a] = find(father[a]);
    }
    public int union(int a, int b, int num) {
        int fa = find(a);
        int fb = find(b);
        if (fa != fb) {
            father[fa] = fb;
            num--;
        }
        return num;
    }
}

 判断图是否是树

题意：

给出 n 个节点，标号分别从 0 到 n - 1 并且给出一个 无向 边的列表 (给出每条边的两个顶点), 写一个函数去判断这张｀无向｀图是否是一棵树

 注意事项

你可以假设我们不会给出重复的边在边的列表当中. 无向边　[0, 1] 和 [1, 0]　是同一条边， 因此他们不会同时出现在我们给你的边的列表当中。


样例
给出n = 5 并且 edges = [[0, 1], [0, 2], [0, 3], [1, 4]], 返回 true.

给出n = 5 并且 edges = [[0, 1], [1, 2], [2, 3], [1, 3], [1, 4]], 返回 false.

--图是连通图，并且不存在环。那么这个图是树

解法：并查集。并查集用来判断是否存在环，同时记下连通块的个数，最后只剩一个连通块并且没有环，则就是树。

public class Solution {
    /**
     * @param n an integer
     * @param edges a list of undirected edges
     * @return true if it's a valid tree, or false
     */
    int[] father = null;
    public boolean validTree(int n, int[][] edges) {
        // Write your code here
        if (edges == null || n == 0) {
            return false;
        }
        father = new int[n];
        for (int i = 0; i < n; i++) {
            father[i] = i;
        }
        int count = n;
        for (int i = 0; i < edges.length; i++) {
            int fa = find(edges[i][0]);
            int fb = find(edges[i][1]);
            //fa == fb存在环
            if (fa == fb) {
                return false;
            }
            father[fa] = fb;
            count--;
        }
        //count==1说明是连通
        return count == 1;
    }
    public int find(int x) {
        if (father[x] == x) {
            return x;
        }
        return father[x] = find(father[x]);
    }
}

2.trie tree

1.Implement trie tree

--实现trie tree

解法：这里用hashmap+非递归的方法，其他实现见http://www.cnblogs.com/fisherinbox/p/6073183.html

/**
 * Your Trie object will be instantiated and called as such:
 * Trie trie = new Trie();
 * trie.insert("lintcode");
 * trie.search("lint"); will return false
 * trie.startsWith("lint"); will return true
 */
class TrieNode {
    // Initialize your data structure here.
    HashMap<Character,TrieNode> children = null; 
    boolean wordEnd;
    public TrieNode() {
        children = new HashMap<>();
        wordEnd = false;
    }
}

public class Trie {
    private TrieNode root;

    public Trie() {
        root = new TrieNode();
    }

    // Inserts a word into the trie.
    public void insert(String word) {
        if (word == null || word.length() == 0) {
            return;
        }
        TrieNode cur = root;
        for (int i = 0; i < word.length(); i++) {
            TrieNode next = null;
            if (cur.children.containsKey(word.charAt(i))) {
                next = cur.children.get(word.charAt(i));
            } else {
                next = new TrieNode();
                cur.children.put(word.charAt(i), next);
            }
            if (i == word.length() - 1) {
                next.wordEnd = true;
            }
            cur = next;
        }
    }

    // Returns if the word is in the trie.
    public boolean search(String word) {
        if (word == null || word.length() == 0) {
            return false;
        }
        TrieNode cur = root;
        for (int i = 0; i < word.length(); i++) {
            if (!cur.children.containsKey(word.charAt(i))) {
                return false;
            }
            if (i == word.length() - 1 && cur.children.get(word.charAt(i)).wordEnd) {
                return true;
            }
            cur = cur.children.get(word.charAt(i));
        }
        return false;
    }

    // Returns if there is any word in the trie
    // that starts with the given prefix.
    public boolean startsWith(String prefix) {
        if (prefix == null || prefix.length() == 0) {
            return false;
        }
        TrieNode cur = root;
        for (int i = 0; i < prefix.length(); i++) {
            if (!cur.children.containsKey(prefix.charAt(i))) {
                return false;
            }
            cur = cur.children.get(prefix.charAt(i));
        }
        return true;
    }
}

 2.单词搜索II

题意：

给出一个由小写字母组成的矩阵和一个字典。找出所有同时在字典和矩阵中出现的单词。一个单词可以从矩阵中的任意位置开始，可以向左/右/上/下四个相邻方向移动。

您在真实的面试中是否遇到过这个题？ Yes
样例
给出矩阵：
doaf
agai
dcan
和字典：
{"dog", "dad", "dgdg", "can", "again"}

返回 {"dog", "dad", "can", "again"}

解法：利用trie 树+dfs，先将字典中的单词插入到trie tree中，再dfs遍历矩阵，这样的好处是避免无效的遍历，利用trie tree可以判断当前位置的字符是否在trie tree的当前节点的孩子节点中，如果在就往下遍历，不在就无需遍历了。输出结果不能有重复的单词。

public class Solution {
    /**
     * @param board: A list of lists of character
     * @param words: A list of string
     * @return: A list of string
     */
    public ArrayList<String> wordSearchII(char[][] board, ArrayList<String> words) {
        // write your code here
        if (board == null || words == null) {
            return new ArrayList<>();
        }
        TrieTree trie = new TrieTree();
        for (String word : words) {
            trie.insert(word);
        }
        Set<String> set = new HashSet<>();
        ArrayList<String> ans = new ArrayList<>();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                if (trie.root.children.containsKey(board[i][j])) {
                    helper(board, i, j, trie.root, set, sb);
                }
            }
        }
        for (String word : set) {
            ans.add(word);
        }
        return ans;
    }
    public void helper(char[][] board, int i, int j, TrieNode cur, Set<String> ans, StringBuffer sb) {
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] == '#') {
            return;
        }
        char curChar = board[i][j];
        board[i][j] = '#';
        if (cur.children.containsKey(curChar)) {
            sb.append(curChar);
            if (cur.children.get(curChar).wordEnd) {
                ans.add(new String(sb));
            }
            cur = cur.children.get(curChar);
            helper(board, i + 1, j, cur, ans, sb);
            helper(board, i - 1, j, cur, ans, sb);
            helper(board, i, j - 1, cur, ans, sb);
            helper(board, i, j + 1, cur, ans, sb);
            sb.deleteCharAt(sb.length() - 1);
        }
        board[i][j] = curChar;
    }
}
class TrieNode {
    HashMap<Character, TrieNode> children = null;
    boolean wordEnd;
    public TrieNode() {
        children = new HashMap<>(); 
        wordEnd = false;
    }
}
class TrieTree {
    TrieNode root = null;
    public TrieTree() {
        root = new TrieNode();
    }
    public void insert(String word) {
        if (word == null || word.length() == 0) {
            return ;
        }
        TrieNode cur = root;
        for (int i = 0; i < word.length(); i++) {
            if (!cur.children.containsKey(word.charAt(i))) {
                cur.children.put(word.charAt(i), new TrieNode());
            } 
            cur = cur.children.get(word.charAt(i));
            if (i == word.length() - 1) {
                cur.wordEnd = true;
            }
        }
    }
}

 第三节 高级数据结构II

1.Trapping Rain Water

题意：

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

Example

Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.

解法：两指针解法，分别初始化位头和尾，始终移动高度较小的一端，并且在移动的同时，计算储水量。较小的高度是储水量的上界（木桶原理类似），在移动的同时保存一个储水上界，遇到较低的高度则计算高度差则是储水量，遇到较高的高度则更新储水上界为这个高度。

public class Solution {
    /**
     * @param heights: an array of integers
     * @return: a integer
     */
    public int trapRainWater(int[] heights) {
        // write your code here
        if (heights == null || heights.length < 3) {
            return 0;
        }
        int left = 0;
        int right = heights.length - 1;
        int cur = Math.min(heights[left], heights[right]);
        int ans = 0;
        while(left < right) {
            if (heights[left] <= heights[right]) {
                ans += Math.max(cur - heights[left], 0);
                cur = Math.max(cur, heights[left]);
                left++;
            } else {
                ans += Math.max(cur - heights[right], 0);
                cur = Math.max(cur, heights[right]);
                right--;
            }
        }
        return ans;
    }
}

2. Trapping Rain Water II--pq

题意：

Given n x m non-negative integers representing an elevation map 2d where the area of each cell is 1 x 1, compute how much water it is able to trap after raining.

 

样例

例如，给定一个 5*4 的矩阵： 

[
  [12,13,0,12],
  [13,4,13,12],
  [13,8,10,12],
  [12,13,12,12],
  [13,13,13,13]
]

返回 14.

解法：pq ，与上一题不同，这题立体化了。我们需要由外向内遍历，并且使用pq来给柱子高度排序，以最小高度向内灌水，遇到高度比当前最小高度小的，则将当前高度替换实际高度加入pq中。注意pq中存的是自定义类，因为要保存位置信息。可以将已经加入pq中的单元格值至为-1，用来去重，并且可以保证是由外向内遍历的。

public class Solution {
    /**
     * @param heights: a matrix of integers
     * @return: an integer
     */
    public int trapRainWater(int[][] heights) {
        // write your code here
        if (heights == null || heights.length < 3 || heights[0].length < 3) {
            return 0;
        }
        int m = heights.length;
        int n = heights[0].length;
        PriorityQueue<Cell> pq = new PriorityQueue<Cell>(2*(m+n),new MyComparator());
        for (int i = 0; i < n; i++) {
            pq.offer(new Cell(0, i, heights[0][i]));
            pq.offer(new Cell(m - 1, i, heights[m - 1][i]));
            heights[0][i] = -1;
            heights[m - 1][i] = -1;
        }
        for (int i = 1; i < m - 1; i++) {
            pq.offer(new Cell(i, 0, heights[i][0]));
            pq.offer(new Cell(i, n - 1, heights[i][n - 1]));
            heights[i][0] = -1;
            heights[i][n - 1] = -1;
        }
        int[] dx = {0, 1, -1, 0};
        int[] dy = {1, 0, 0, -1};
        int ans = 0;
        while (!pq.isEmpty()) {
            Cell cur = pq.poll();
            for (int i = 0; i < 4; i++) {
                int nx = cur.x + dx[i];
                int ny = cur.y + dy[i];
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && heights[nx][ny] != -1) {
                    ans += Math.max(0, cur.val - heights[nx][ny]);
                    pq.offer(new Cell(nx, ny, Math.max(cur.val, heights[nx][ny])));
                    heights[nx][ny] = -1;
                }
            }
        }
        return ans;
    }
public class Cell{
    int x;
    int y;
    int val;
    public Cell(int x, int y, int val) {
        this.x = x;
        this.y = y;
        this.val = val;
    }
}
public class MyComparator implements Comparator<Cell> {
    public int compare(Cell c1, Cell c2) {
        return c1.val - c2.val;
    }
}
};

3.实时数据流的中位数

思路：用一个最大堆和一个最小堆。将数据流平均分成两个部分，最大堆中的数都小于最小堆中的数，当前数据流个数是偶数的时候，中位数则是最大堆与最小堆堆顶元素之和/2;当前数据流个数是奇数的时候，中位数是最大堆的堆顶。所以当数据流个数是偶数时，最大堆与最小堆数据个数相等，反之，最大堆的数据个数比最小堆多一个。

1.当最大堆与最小堆长度相等时，新来一个数据，本应该加入最大堆，但是如果这个数据比最小堆的最小值要大，就要加入最小堆，再将最小堆的堆顶元素pop出来加入最大堆中。

2.当最大堆长度大于最小堆时，新来一个数据，本应该加入最小堆，但是如果这个数据比最大堆最大值要小，则应该加入最大堆，并且将最大堆的最大值pop加入最小堆。

通过上面两步保证最大堆的所有元素小于最小堆。

插入时间复杂度为O(logn),获取中位数的时间复杂度为O(1);

代码使用c++写的，注意priority_queue的pop函数返回void，并不会返回数值。最小堆的实现没有自定义比较器，而是将数值取负号放入最大堆，相当于形成了一个最小堆。这时候用long类型就比较安全，因为最小负整数加负号之后会越界int的。

class MedianFinder {
    priority_queue<long> small, large;
public:
    /** initialize your data structure here. */
    MedianFinder() {
        
    }
    
    void addNum(int num) {
        if (small.size() == large.size()) {
            if (large.size() != 0 && num > -large.top()) {
                large.push(-num);
                small.push(-large.top());
                large.pop();
            } else {
                small.push(num);
            }
        }
        if (small.size() > large.size()) {
            if (num < small.top()) {
                small.push(num);
                large.push(- small.top());
                small.pop();
            } else {
                large.push(- num);
            }
        }
    }
    
    double findMedian() {
        return small.size() > large.size() ? small.top() : (small.top() - large.top()) / 2.0;
    }
};

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

4.滑动窗口的中位数

题意：

给定一个包含 n 个整数的数组，和一个大小为 k 的滑动窗口,从左到右在数组中滑动这个窗口，找到数组中每个窗口内的中位数。(如果数组个数是偶数，则在该窗口排序数字后，返回第 N/2 个数字。)
样例
对于数组 [1,2,7,8,5], 滑动大小 k = 3 的窗口时，返回 [2,7,7]
最初，窗口的数组是这样的：

[ | 1,2,7 | ,8,5] , 返回中位数 2;

接着，窗口继续向前滑动一次。

[1, | 2,7,8 | ,5], 返回中位数 7;

接着，窗口继续向前滑动一次。

[1,2, | 7,8,5 | ], 返回中位数 7;

解法：与上一题类似，利用两个堆，但是这里是滑动窗口，所以每一步需要删除掉出窗口的元素，而pq的删除操作时间复杂度是O(n)，不适合，这里用treeset，内部结构式平衡二叉搜索树，删除操作时间复杂度是O(logn).

public class Solution {
    /**
     * @param nums: A list of integers.
     * @return: The median of the element inside the window at each moving.
     */
    public ArrayList<Integer> medianSlidingWindow(int[] nums, int k) {
        // write your code here
        if (nums == null || nums.length == 0 ||  k <= 0) {
            return new ArrayList<Integer>();
        }
        ArrayList<Integer> ans = new ArrayList<>();
        TreeSet<Node> minHeap = new TreeSet<>();
        TreeSet<Node> maxHeap = new TreeSet<>();
        int size = (k + 1) / 2;
        for (int i = 0; i < k - 1; i++) {
            add(minHeap, maxHeap, size, new Node(i, nums[i]));
        }
        for (int i = k - 1; i < nums.length; i++) {
            add(minHeap, maxHeap, size, new Node(i, nums[i]));
            ans.add(maxHeap.last().val);
            remove(minHeap, maxHeap, new Node(i - k + 1, nums[i - k + 1]));
        }
        return ans;
    }
    public void add(TreeSet<Node> minHeap, TreeSet<Node> maxHeap, int size, Node node) {
        if (maxHeap.size() < size) {
            maxHeap.add(node);
        } else {
            minHeap.add(node);
        }
        if (maxHeap.size() == size) {
            if (minHeap.size() > 0 && maxHeap.last().val > minHeap.first().val) {
                Node min = minHeap.first();
                Node max = maxHeap.last();
                minHeap.remove(min);
                maxHeap.remove(max);
                minHeap.add(max);
                maxHeap.add(min);
            }
        }
    }
    public void remove(TreeSet<Node> minHeap, TreeSet<Node> maxHeap, Node node) {
        if (minHeap.contains(node)) {
            minHeap.remove(node);
        } else {
            maxHeap.remove(node);
        }
    }
    public class Node implements Comparable<Node>{
        int pos = 0;
        int val = 0;
        public Node (int pos, int val) {
            this.pos = pos;
            this.val = val;
        }
        public int compareTo(Node other) {
            if (this.val == other.val) {
                return this.pos - other.pos;
            }
            return this.val - other.val;
        }
    }
}

5.滑动窗口的最大值

思路：利用双端队列。队列头部始终保存当前滑动窗口的最大值。遍历数组，如果当前数值大于队列尾部数值，则删除所有小于当前数字的队列尾部数字，并在尾部加入当前数值，如果当前数值小于队列尾部，则加入尾部。如果当前索引号与队列头部索引号之差大于等于滑动窗口大小k，则删除头部，因为头部已经不属于当前滑动窗口。注意队列中存的是数值的索引号。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> max;
        if (nums.size() < k || k < 1) {
            return max;
        }
        deque<int> dq;
        for (int i = 0; i < k; i++) {
            while (!dq.empty() && nums[i] > nums[dq.back()]) {
                dq.pop_back();
            }
            dq.push_back(i);
        }
        max.push_back(nums[dq.front()]);
        for (int i = k; i < nums.size(); i++) {
            while (!dq.empty() && nums[i] >= nums[dq.back()]) {
                dq.pop_back();
            }
            if (!dq.empty() && dq.front() <= i - k) {
                dq.pop_front();
            }
            dq.push_back(i);
            max.push_back(nums[dq.front()]);
        }
        return max;
    }
};