二叉树创建及遍历

1. 二分搜索树

2. 平衡二叉树(最大深度和最小深度差为1)：AVL树，红黑树

3. 完全二叉树(二叉堆)：除了最高层以外，其余层节点个数都达到最大值，并且最高层节点都优先集中在最左边。

4. 满二叉树： 除了最高层有叶子节点，其余层无叶子，并且非叶子节点都有2个子节点。

5. 堆，并查集：对数据进行特殊的操作产生高效的结果

6. 线段树，Trie(字典树，前缀树)
。

二分搜索树

二分搜索树是一种二叉树。每个结点的值大于其左子树所有结点的值，小于其右子树所有结点的值。每一棵子树也是一个二叉搜索树。

性质：

1. 任意结点，左子树的值小于当前结点的值，右子树的值大于当前结点的值。
2. 没有父节点的称为根结点。
3. 每一个非根节点都有一个父节点。
4. 第i层上最多有2^(n-1)个结点。
5. 包含n个结点的二叉树高度至少为long2(n+1)
6. 存储的元素必须有可比性。

二叉树的创建：

public class BST> {
	private class Node{
		private E e;
		private Node left;
		private Node right;
		public Node(E e) {
			this.e = e;
			left = null;
			right = null;
		}
	}
	
	private Node root;
	private int size;
	
	public BST() {
		root = null;
		size = 0;
	}
}

二叉树的遍历

前序遍历：

由于递归算法比较简单，主要描述下非递归算法。

第一种：利用栈的原理，打印当前栈中弹出的元素，将弹出元素的右结点先压入栈中，再将左结点压入栈中，遍历到栈空为止

Stack stack = new Stack<>();
		stack.push(node);
		while(!stack.isEmpty()) {
			Node cur = stack.pop();
			
			System.out.println(cur.e);
			if(cur.right != null)
				stack.push(node.right);
			if(cur.left != null)
				stack.push(node.left);
		}

第二种：打印当前结点，将当前结点压入栈中，遍历当前元素左结点，直到遍历到左结点为空，再弹出元素，遍历弹出元素的右结点，遍历到栈空为止。

p = root;
while(p!=null||!stack.isEmpty()){
        if(p!=null){
            System.out.print(p.data.toString()+" ");
            stack.push(p);
            p = p.left;
        }else{
            System.out.print("^ ");
            p = stack.pop();
            p = p.right;
        }
    }

递归遍历：

	private void preOrder(Node node) {
		if(node != null) {
			System.out.println(node.e);
			preOrder(node.left);
			preOrder(node.right);
		}
	}

中序遍历

先把当前结点压入栈中，遍历当前结点的左结点，直到为空，弹出栈中的元素进行打印，再将弹出元素的右子树进行入栈，直到栈为空为止。

p = root;
while(p!=null||!stack.isEmpty()){//p非空或栈为空
        if(p!=null){
            stack.push(p);//p节点入栈
            p=p.left;//进入左子树
        }else{//p为空栈非空
            System.out.print("^ "); 
            p = stack.pop();//p指向出栈节点
            System.out.print(p.data.toString()+" ");//访问节点
            p=p.right;  //进入右子树
        }
    }

递归遍历：

	private void inOrder(Node node) {
		if(node != null) {
			inOrder(node.left);
			System.out.println(node.e);	
			inOrder(node.right);
		}
	}

后序遍历

需要两个栈，一个操作栈，一个代操作栈。操作栈进行遍历，先进右子树，遍历到空为止，弹出操作栈中的元素，遍历左子树，直到操作栈为空为止。然后将代操作中元素依次遍历。

Stack stack = new Stack<>(); //辅助栈
		Stack output = new Stack<>();//将元素全部压入栈中进行输出
		Node p = node;
		while(p != null || !stack.isEmpty()) {
			if(p != null) {
				stack.push(p);
				output.push(p);//进入代操作栈
				p = p.right;//先进右子树
			}else {
				//添加空元素结点对空节点进行标记
				output.push(new Node(null));
				p = stack.pop();
				p = p.left;
			}
		}
		//依次出栈
		while(!output.isEmpty()) {
			Node cur = output.pop();
			if(cur.e == null)
				System.out.println("null");
			else
				System.out.println(cur.e);
		}
		

递归遍历：

private void porOrder(Node node) {
		if(node != null) {
			porOrder(node.left);
			porOrder(node.right);
			System.out.println(node.e);
		}
	}

层次遍历

非递归使用队列进行遍历：

public void levelOrder() {
		Queue queue = new LinkedList<>();
		queue.add(root);
		while(!queue.isEmpty()) {
			Node cur = queue.remove();
			System.out.println(cur.e);
			if(cur.left != null) {
				queue.add(cur.left);
			}
			if(cur.right != null) {
				queue.add(cur.right);
			}
		}
	}

递归遍历：

public void levelOrder(Node node) {
		if(node == null)
			return;
		int depth = depth(node);
		for(int i = 1; i <= depth;i++) {
			levelOrder(node,i);
		}
	}
	private void levelOrder(Node node, int level) {
		if(node == null || level < 1) {
			return;
		}
		if(level == 1) {
			System.out.println(node.e);
			return;
		}
		//左子树
		levelOrder(node.left, level-1);
		//右子树
		levelOrder(node.right, level-1);
	}
	/**
	 * 计算二叉树的层数
	 * @param node
	 * @return
	 */
	private int depth(Node node) {
		if(node == null) {
			return	0;
		}
		int left = depth(node.left);
		int right = depth(node.right);
		return	left > right ? left+1 : right+1;
	}

向二叉树添加元素：

public void add(E e) {
			root = add(root,e);
	}
	
	/**
	 * 向以node为结点的二分搜索树插入元素
	 * @param node
	 * @param e
	 */
	private Node add(Node node,E e) {
		//如果传入的结点为空 则进行插入
		if(node == null) {
			size++;
			return	new Node(e);
		}
		//如果小于则进行左子树进行递归
		if(e.compareTo(node.e) < 0) {
			node.left = add(node.left,e);
		}else if(e.compareTo(node.e) > 0){
			node.right = add(node.right,e);
		}
		//相等则不进行操作 直接返回
		return	node; 
	}

二叉树删除元素：

/**
	 * 删除任意元素
	 * @param e
	 */
	public void remove(E e) {
		root = remove(root,e);
	}
	private Node remove(Node node, E e) {
	    //当node为空 直接返回
		if(node == null) {
			return null;
		}
		if(e.compareTo(node.e) < 0) {
			node.left = remove(node.left,e);
		}else if(e.compareTo(node.e) > 0){
			node.right = remove(node.right,e);
		}else {//e==node.e
		    //当左子树为空 返回右子树
			if(node.left == null) {
				Node rightNode = node.right;
				node.right = null;
				size--;
				return	rightNode;
			}
			//当右子树为空 返回左子树
			if(node.right == null) {
				Node leftNode = node.left;
				node.left = null;
				size--;
				return	leftNode;
			}
			//找到待删结点右子树的最小值(也可以将左子树的最大值替代待删结点)
			Node min = minimum(node.right);
			//删除最小值，并让最小值的右子树指向返回值
			min.right = removeMin(node.right);
			min.left = node.left;
			node.left = node.right = null;
		}
		return	node;
	}