二叉树 DFS BFS

满二叉树：

在一颗二叉树中，如果所有分支结点都有左子结点和右子结点，并且叶结点都集中在二叉树的最底层，这样的二叉树称为满二叉树。

完全二叉树：

完全二叉树是由满二叉树而引出来的，若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数(即1~h-1层为一个满二叉树)，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

二叉树遍历

1、四种基本的遍历思想

前序遍历：根结点 -->左子树–>右子树；

中序遍历：左子树 -->根结点–>右子树；

后续遍历：左子树 -->右子树–>根结点；

层次遍历：仅仅需按成次遍历即可；

二叉树的深度优先遍历（DFS）与广度优先遍历（BFS）

对于一颗二叉树，深度优先搜索(Depth First Search)是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。

以上面二叉树为例，深度优先搜索的顺序

深度优先搜索二叉树是先访问根结点，然后遍历左子树接着是遍历右子树，因此我们可以利用堆栈的先进后出的特点

DFS：ABDECFG
BFS：ABCDEFG

DFS实现：数据结构：栈；遍历操作：父节点入栈，父节点出栈，先右子节点入栈，后左子节点入栈，递归遍历全部节点。

BFS实现：数据结构：队列；遍历操作：父节点入队列，父节点出队列，先左子节点入队列，后右子节点处队列，递归遍历全部节点。

public class Node {
	char data;
	Node leftChild;
	Node rightChild;
}

//深度优先遍历
public void depthFirstSearch(Node rNode){
	Stack stack = new Stack();
	stack.push(rNode);
	Node node = null;
	while(!stack.empty()){
		node = stack.pop();
		System.out.print(node.data);//遍历根结点
		if(node.rightChild != null){
			stack.push(node.rightChild);//先将右子树压栈
		}
		if(node.leftChild != null){
			stack.push(node.leftChild);//再将左子树压栈
		}
	}
}

//广度优先遍历
public void breadFirstSearch(Node rNode){
	LinkedList queue = new LinkedList<Node>();
	queue.offer(rNode);
	Node node = null;
	while(!queue.empty()){
		node = queue.poll();
		System.out.print(node.data);//遍历根结点
		if(node.leftChild() != null){
			queue.offer(node.leftChild);//先将左子树入队
		}
		if(node.rightChild() != null){
			queue.offer(node.rightChild);//再将右子树入队
		}
	}
}

1. 堆有序
   二叉堆是一种特殊的堆，二叉堆是完全二元树（二叉树）。

二叉堆有两种：最大堆和最小堆。

最大堆：父节点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。

2. 二叉堆的表示方法

二叉堆虽然是一颗完全二叉树，但它的存储方式并不是链式存储，而是顺序存储。换句话说，二叉堆的所有节点都存储在数组当中

3. 节点位置关系

假设父节点的下标是parent，那么它的左孩子下标就是 2parent+1；它的右孩子下标就是 2parent+2 。

7 = 32+1、8 = 32+2

下沉调整

/**
     * 下沉调整
     * @param array     待调整的堆
     * @param parentIndex    要下沉的父节点
     * @param length    堆的有效大小
     */
    public static void downAdjust(int[] array, int parentIndex, int length) {
        // temp保存父节点值，用于最后的赋值
        int temp = array[parentIndex];
        int childIndex = 2 * parentIndex + 1;
        while (childIndex < length) {
            // 如果有右孩子，且右孩子小于左孩子的值，则定位到右孩子
            if (childIndex + 1 < length && array[childIndex + 1] < array[childIndex]) {
                childIndex++;
            }
            // 如果父节点小于任何一个孩子的值，直接跳出
            if (temp <= array[childIndex])
                break;
            //无需真正交换，单向赋值即可
            array[parentIndex] = array[childIndex];
            parentIndex = childIndex;
            childIndex = 2 * childIndex + 1;
        }
        array[parentIndex] = temp;
    }

上浮调整

    /**
     * 上浮调整
     * @param array     待调整的堆
     */
    public static void upAdjust(int[] array) {
        int childIndex = array.length-1;
        int parentIndex = (childIndex-1)/2;
        // temp保存插入的叶子节点值，用于最后的赋值
        int temp = array[childIndex];
        while (childIndex > 0 && temp < array[parentIndex])
        {
            //无需真正交换，单向赋值即可
            array[childIndex] = array[parentIndex];
            childIndex = parentIndex;
            parentIndex = (parentIndex-1) / 2;
        }
        array[childIndex] = temp;
    }

构建二叉堆

/**
     * 构建堆
     * 
     * @param array 待调整的堆
     */
    public static void buildHeap(int[] array) {
        // 从最后一个非叶子节点开始，依次下沉调整
        for (int i = (array.length - 2) / 2; i >= 0; i--) {
            downAdjust(array, i, array.length);
        }
    }

    public static void main(String[] args) {
        int[] array = new int[] { 1, 3, 2, 6, 5, 7, 8, 9, 10, 0 };
        upAdjust(array);
        System.out.println(Arrays.toString(array));

        array = new int[] { 7, 1, 3, 10, 5, 2, 8, 9, 6 };
        buildHeap(array);
        System.out.println(Arrays.toString(array));
    }