1. 设计循环双端队列

设计实现双端队列。

实现 MyCircularDeque 类:

MyCircularDeque(int k) ：构造函数,双端队列最大为 k 。
boolean insertFront()：将一个元素添加到双端队列头部。 如果操作成功返回 true ，否则返回 false 。
boolean insertLast() ：将一个元素添加到双端队列尾部。如果操作成功返回 true ，否则返回 false 。
boolean deleteFront() ：从双端队列头部删除一个元素。 如果操作成功返回 true ，否则返回 false 。
boolean deleteLast() ：从双端队列尾部删除一个元素。如果操作成功返回 true ，否则返回 false 。
int getFront() )：从双端队列头部获得一个元素。如果双端队列为空，返回 -1 。
int getRear() ：获得双端队列的最后一个元素。 如果双端队列为空，返回 -1 。
boolean isEmpty() ：若双端队列为空，则返回 true ，否则返回 false 。
boolean isFull() ：若双端队列满了，则返回 true ，否则返回 false 。

分析：

1. 使用Deque类来实现，比较简单。

class MyCircularDeque {
    Deque<Integer> deque;
    int k;

    public MyCircularDeque(int k) {
        this.deque = new ArrayDeque<>();
        this.k = k;
    }

    public boolean insertFront(int value) {
        if (deque.size() == k) return false;
        deque.addFirst(value);
        return true;
    }

    public boolean insertLast(int value) {
        if (deque.size() == k) return false;
        deque.addLast(value);
        return true;
    }

    public boolean deleteFront() {
        if (deque.isEmpty()) return false;
        deque.pollFirst();
        return true;
    }

    public boolean deleteLast() {
        if (deque.isEmpty()) return false;
        deque.pollLast();
        return true;

    }

    public int getFront() {
        if (deque.isEmpty()) return -1;
        return deque.getFirst();
    }

    public int getRear() {
        if (deque.isEmpty()) return -1;
        return deque.getLast();
    }

    public boolean isEmpty() {
        return deque.isEmpty();
    }

    public boolean isFull() {
        return deque.size()==k;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

2. 借用数组来实现。

class MyCircularDeque {
    int k;
    int front = 0;
    int[] Deque;

    public MyCircularDeque(int k) {
        this.k = k;
        this.Deque = new int[k];
    }

    public boolean insertFront(int value) {
        if (front==k) return false;
        Deque[front] = value;
        front++;
        return true;
    }

    public boolean insertLast(int value) {
        if (front==k) return false;
        if (front == 0){
            Deque[0] = value;
            front++;
            return true;
        }
        for (int i = front; i > 0; i--) {
            Deque[i] = Deque[i-1];
        }
        Deque[0] = value;
        front++;
        return true;
    }

    public boolean deleteFront() {
        if (front == 0) return false;
        front--;
        return true;
    }

    public boolean deleteLast() {
        if (front == 0) return false;
        for (int i = 0; i < front-1; i++) {
            Deque[i] = Deque[i+1];
        }
        front--;
        return true;
    }

    public int getFront() {
        if (front==0) return -1;
        return Deque[front-1];
    }

    public int getRear() {
        if (front==0) return -1;
        return Deque[0];
    }

    public boolean isEmpty() {
        return front==0;
    }

    public boolean isFull() {
        return front==k;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

2. 二叉搜索树中的中序后继

给定一棵二叉搜索树和其中的一个节点 p ，找到该节点在树中的中序后继。如果节点没有中序后继，请返回 null 。

节点 p 的后继是值比 p.val 大的节点中键值最小的节点，即按中序遍历的顺序节点 p 的下一个节点。

分析：

对二叉树进行中序遍历，用集合记录下中序遍历的结果。遍历完在集合中查找p，返回p的后继。

class Solution {
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        if (root == null) return null;
        List<TreeNode> list = new ArrayList<>();
        inorder(root, list);
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i) == p){
                if (i == list.size()-1) return null;
                return list.get(i+1);
            }
        }
        return null;
    }
    private void inorder(TreeNode root, List<TreeNode> list){
        if (root == null) return;
        inorder(root.left, list);
        list.add(root);
        inorder(root.right, list);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 所有大于等于节点的值之和

给定一个二叉搜索树，请将它的每个节点的值替换成树中大于或者等于该节点值的所有节点值之和。

分析：

利用逆序的中序遍历，即右子树—>root—>左子树。定义一个变量add，初始化为0，每遍历到一个节点node时，更新node.val += add，add=node.val。

class Solution {
    int add = 0;
    public TreeNode convertBST(TreeNode root) {
        if (root == null) return null;
        convertBST(root.right);
        root.val += add;
        add = root.val;
        convertBST(root.left);
        return root;
    }
}
1
2
3
4
5
6
7
8
9
10
11