二叉树

1.二叉树

具有唯一根节点
二叉树有左右两个节点
二叉树不一定是满的
一个节点也是二叉树
null也是二叉树

class Node{
	E e;
	Node left;
	Node right;
}

二叉树具有递归结构

2.二分搜索树

是二叉树
每个节点的值大于自身左子树的值
每个节点的值小于自身右子树的值
存储的元素有可比性

2.1 插入节点

 /**
     * 递归形式，添加新元素
     *
     * @param node
     * @param e
     */
    private void add(Node node, E e) {
        //终止条件
        if (e.compareTo((E) node.e) == 0) {
            return;
        }  else if (e.compareTo((E) node.e) < 0&& node.left==null) {
            node.left = new Node(e);
            size++;
            return;
        } else if (e.compareTo((E) node.e) > 0&& node.right==null) {
            node.right = new Node(e);
            size++;
            return;
        }
        if (e.compareTo((E) node.e) < 0)
            add(node.left, e);
        else
            add(node.right, e);
    }

优化后

		//调用
	    root=  add(root, e);


  /**
     * 递归形式，添加新元素
     *
     * @param node
     * @param e
     */
    private Node add(Node node, E e) {
        //终止条件
        if (node==null) {
            node = new Node(e);
            size++;
            return node;
        }
        if (e.compareTo((E) node.e) < 0 ) {
            node.left = add(node.left,e);
        } else if (e.compareTo((E) node.e) > 0 ) {
            node.right =add(node.right,e);
        }

        return node;
    }

2.2 是否包含(contains)

    public boolean contains(E e) {
        return contains(root, e);
    }

    private boolean contains(Node node, E e) {
        if (node == null) {
            return false;
        }
        if (node.e.compareTo(e) == 0) {
            return true;
        } else if (node.e.compareTo(e) > 0) {
            return contains(node.left, e);
        } else {
            return contains(node.right, e);
        }
    }

2.3 遍历

前序遍历，先访问节点内容

     public void preorder(){
        preorder(root);
    }

    private void preorder(Node node) {
        if (node==null){
            return;
        }
        // 打印节点内容
        System.out.println("--"+node.e);
        preorder(node.left);
        preorder(node.right);

    }

中序遍历，访问节点内容逻辑放到了中间

中序遍历也是带顺序的

  private void middleOrder(Node node) {
        if (node==null){
            return;
        }
        preorder(node.left);
        System.out.println("--"+node.e);
        preorder(node.right);

    }

后续遍历，访问节点内容逻辑放到了最后

    private void lastOrder(Node node) {
        if (node==null){
            return;
        }
        preorder(node.left);
        preorder(node.right);
        System.out.println("--"+node.e);

    }

2.4 非递归遍历

使用栈的形式 来打印前序遍历

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