文章目录
- 重建二叉树
- 两个栈实现队列
- 旋转数组的最小数字:折半查找
- 斐波那契数列
- 青蛙跳台阶
- 矩形覆盖
- 二进制中1的个数
- 调整数组顺序使奇数位于偶数前面
- 13.链表中的倒数第K个节点
- 14.反转链表
- 15.合并两个有序链表
- 16.树的子结构
重建二叉树
两个栈实现队列
旋转数组的最小数字:折半查找
斐波那契数列
7.斐波那契数列
递归
优化存储
青蛙跳台阶
8/9.青蛙跳台阶
动态规划问题
矩形覆盖
10.矩形覆盖
public int RectCover(int n) {
if (n <= 2) return n;
int pre2 = 1, pre1 = 2;
int result = 0;
for (int i = 3; i <= n; i++) {
result = pre2 + pre1;
pre2 = pre1;
pre1 = result;
}
return result;
}
二进制中1的个数
11.二进制中1的个数
public int NumberOf1(int n) {
int cnt = 0;
while (n != 0) {
cnt++;
n &= (n - 1);
}
return cnt;
}
public int NumberOf1(int n) {
return Integer.bitCount(n);
}
调整数组顺序使奇数位于偶数前面
12.调整数组顺序使奇数位于偶数前面
13.链表中的倒数第K个节点
13.链表中的倒数第K个节点
14.反转链表
14.反转链表
15.合并两个有序链表
15.合并两个有序链表
16.树的子结构
16.树的子结构
17.二叉树的镜像
18.顺时针打印矩阵
19.包含min函数的栈
private Stack<Integer> dataStack = new Stack<>();
private Stack<Integer> minStack = new Stack<>();
public void push(int node) {
dataStack.push(node);
minStack.push(minStack.isEmpty() ? node : Math.min(minStack.peek(), node));
}
public void pop() {
dataStack.pop();
minStack.pop();
}
public int top() {
return dataStack.peek();
}
public int min() {
return minStack.peek();
}
20.栈的压入、弹出序列
public boolean IsPopOrder(int[] pushSequence, int[] popSequence) {
int n = pushSequence.length;
Stack<Integer> stack = new Stack<>();
for (int pushIndex = 0, popIndex = 0; pushIndex < n; pushIndex++) {
stack.push(pushSequence[pushIndex]);
while (popIndex < n && !stack.isEmpty() && stack.peek() == popSequence[popIndex]) {
stack.pop();
popIndex++;
}
}
return stack.isEmpty();
}
21.从上到下打印二叉树
22.二叉搜索树的后续遍历序列
23.二叉树中和为某一值的路径
24.复杂链表的复制
public class RandomListNode {
int label;
RandomListNode next = null;
RandomListNode random = null;
RandomListNode(int label) {
this.label = label;
}
}
public RandomListNode Clone(RandomListNode pHead) {
if (pHead == null)
return null;
// 插入新节点
RandomListNode cur = pHead;
while (cur != null) {
RandomListNode clone = new RandomListNode(cur.label);
clone.next = cur.next;
cur.next = clone;
cur = clone.next;
}
// 建立 random 链接
cur = pHead;
while (cur != null) {
RandomListNode clone = cur.next;
if (cur.random != null)
clone.random = cur.random.next;
cur = clone.next;
}
// 拆分
cur = pHead;
RandomListNode pCloneHead = pHead.next;
while (cur.next != null) {
RandomListNode next = cur.next;
cur.next = next.next;
cur = next;
}
return pCloneHead;
}
25.二叉搜索树与双向链表
26.字符串的排列
27.数组中出现次数超过一半的数字
28.最小的K个数
31.把数组排成最小的数
32.丑数
33.第一个只出现一次的字符
35.两个链表的公共节点
36.数字在排序数组中出现的次数
binarySearch(int[] a, int key):使用二分搜索法来搜索指定的 int 型数组,以获得指定的值。
37/38.二叉树的深度/平衡二叉树
平衡二叉树:左右子树深度差不大于一
39.只出现一次的数字
40/41.和为S的连续正数序列/和为S的两个数字乘积最小
42.左旋转字符串
43.反转单词顺序列
44.孩子们的游戏(约瑟夫环)
48.数组中重复的数字
52.字符流中的第一个不重复元素
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如,当从字符流中只读出前两个字符 “go” 时,第一个只出现一次的字符是 “g”。当从该字符流中读出前六个字符“google" 时,第一个只出现一次的字符是 “l”。
private int[] cnts = new int[256];
private Queue<Character> queue = new LinkedList<>();
public void Insert(char ch) {
cnts[ch]++;
queue.add(ch);
while (!queue.isEmpty() && cnts[queue.peek()] > 1)
queue.poll();
}
public char FirstAppearingOnce() {
return queue.isEmpty() ? '#' : queue.peek();
}
53.链表中环的入口节点
public ListNode EntryNodeOfLoop(ListNode pHead) {
if (pHead == null || pHead.next == null)
return null;
ListNode slow = pHead, fast = pHead;
do {fast = fast.next.next;
slow = slow.next;
} while (slow != fast);
fast = pHead;
while (slow != fast) {
slow = slow.next;
fast = fast.next;
}
return slow;
}
66.剪绳子
55.删除链表中的重复节点
56.二叉树的下一个节点
public TreeLinkNode GetNext(TreeLinkNode pNode) {
if (pNode.right != null) {
TreeLinkNode node = pNode.right;
while (node.left != null)
node = node.left;
return node;
}
else {
while (pNode.next != null) {
TreeLinkNode parent = pNode.next;
if (parent.left == pNode)
return parent;
pNode = pNode.next;
}
}
return null;
}
61.二叉搜索树的第K个节点
62.数据流中的中位数
63.滑动窗口的最大值
64.矩形中的路径