剑指offer01

• 重建二叉树
• 两个栈实现队列
• 旋转数组的最小数字:折半查找
• 斐波那契数列
• 青蛙跳台阶
• 矩形覆盖
• 二进制中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.矩形中的路径