剑指offer笔记

27.二叉搜索树与双向链表

    递归：使用中序遍历，找到最左边的节点（即最小的节点，作为节点头）作为当前头节点，返回，上一节作为当前节点，当前节点指向头节点，头节点也指向当前节点，当前节点作为头节点；递归到右子树最大节点。

    循环：使用中序遍历的非递归方法，在第二层循环外调整两个节点相互指向，最后返回第一个节点。

30.栈最小数min函数

    引入辅助栈，第一个数入两栈，其余数比较辅助栈的栈顶元素大小，较小入辅助栈。因此辅助栈栈顶总是栈中最小元素。

31.栈的压入和弹出序列

    思路1:弹出序列的第一个数字，确定之前需要压入的数字，即在压入队列中的第一个弹出的数字及之前的数字都需要被压入，然后根据弹出序列；根据出栈序列，元素在栈顶，则直接出栈，不在栈顶，压入再出栈，在栈中且不在栈顶，则不符合要求。

    思路2:弹出序列第一个数字出现之前，压入栈连续入辅助栈，直到辅助栈顶等于第一个数字，辅助栈出栈，循环判断栈顶是否等于下一个弹出数，直到所有压入栈顶数字都压入辅助栈。辅助栈空，则符合，非空，则不符合。

32.从上到下打印二叉树

    打印根节点，子树入队列，队列非空，出队打印，子树入队列，循环。

33.二叉搜索树大后续遍历序列

    序列最后一个数字为根，比根小的为左树，比根大的为右树，如果右子树有小于根的，则返回false，递归判断子树。

34.二叉树路径

    从上到下，压入节点值，符合要求，则加入结果中，不符合则返回，并删除当前节点。

35.复杂链表复制

    先复制顺序链表。

    思路1:用hashmao存储原节点和新节点，原节点random指向哪个，新节点的random也指向hashmap.get(原节点.random)

 

扑克牌顺子数

1）排序；2）遍历排序后的数组；3）是癞子，癞子数+1，continue；4）不是癞子，比较当前数和下一个数的差，用癞子填补，癞子减少；5）遍历结束，癞子是否为>=0则牌为顺子。

public static boolean Solution(int[] numbers) {
		if (numbers==null) {
			return false;
		}
		if (numbers.length!=5) {
			return false;
		}
		Arrays.sort(numbers);
		int numsOfZero = 0;
		for(int i = 0; i < numbers.length-1; i++) {
			if (numbers[i] == 0) {
				numsOfZero++;
				continue;
			}
			if (numbers[i] == numbers[i+1]) {
				return false;
			}
			numsOfZero -= numbers[i+1] - numbers[i] - 1;
		}
		return numsOfZero >= 0;
	}

滑动窗口最大数

两种解法：最大堆和双端队列

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;

public class MaxValueOfSlideWindow {
	public static void main(String[] args) {
		int[] nums = {3,5,6,2,1,2,3,4,5,6,7,9};
		System.out.println(MaxInWindows(nums, 3));
		System.out.println(MaxInWindows2(nums, 3));
	}
	public static ArrayList<Integer> MaxInWindows(int [] num, int size){
		ArrayList<Integer> res = new ArrayList<>();
		if (num==null||size<=0||num.length<size) {
			return res;
		}
		PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(size, new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				// TODO Auto-generated method stub
				return o2-o1;
			}
		});
		for(int i = 0; i < size; i++) {
			priorityQueue.add(num[i]);
		}
		res.add(priorityQueue.peek());
		for(int i  = 0, j = size + i; j < num.length; i++, j++) {
			priorityQueue.add(num[j]);
			priorityQueue.remove(num[i]);
			res.add(priorityQueue.peek());
		}
		return res;
	}
	
	public static ArrayList<Integer> MaxInWindows2(int [] num, int size){
		ArrayList<Integer> res = new ArrayList<>();
		if (num==null||size<=0||num.length<size) {
			return res;
		}
		int begin;
		ArrayDeque<Integer> windows = new ArrayDeque<>();
		for(int i = 0; i < num.length; i++) {
			begin = i + 1 - size;
			if (windows.isEmpty()) {
				windows.add(i);
			}
			else if(begin > windows.peekFirst()) {
				windows.pollFirst();
			}
			while(!windows.isEmpty()&&num[windows.peekLast()]<=num[i]) {
				windows.pollLast();
			}
			windows.add(i);
			if (begin >= 0 ) {
				res.add(num[windows.peekFirst()]);
			}
		}
		return res;
	}
}