红黑树

一 .二叉查找树

左子节点的值比父节点的值小，右子节点的值比父节点的值大。二叉树的的高度决定了它的查找效率()

(1).二叉树的完美平衡

每条从根节点到叶节点的路径的高度都是一样的

树的常用术语

1.路径 2.根 3.父节点 4.子节点 5.兄弟节点 6.叶节点 7.子树 8.节点的层次 9.深度 10.高度

二叉树

二叉树：树的每个节点最多只能有两个子节点

二叉搜索树要求：若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；若它的右子树不空，则右子树上所有节点的值均大于它的根节点值；它的左右子树也为二叉搜索树。

二叉树的查找

• 查找某个节点，我们必须从根节点开始遍历。
• 查找值比当前节点值大，则搜索右子树；
• 查找值等于当前节点值，停止搜索（终止条件）；
• 查找值小于当前节点值，则搜索左子树；

二叉树的插入

在二叉搜索树中插入新元素时，必须先检测该元素是否在书中已经存在。如果已经㛮，则不进行插入，否则将新元素加入到搜索停止的地方。

树的效率：查找节点的时间取决于这个节点所在的层数，每一层最多有2的n次方-1节点，总共N层共有2的n次方-1节点，那么时间复杂度为O(logn),底数为2。

二叉树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回，否则哟是拿出的节点可以能分下面四种情况：

1. 1. 要删除的节点无孩子节点
   2. 要删除的节点只有左孩子节点
   3. 要删除的节点只有有孩子节点
   4. 要删除的节点有左右孩子节点
   

情况1可归类到2或者3

对于上述情况，相应的删除方法如下：

1. 1. 直接删除该节点
   2. 删除该节点且使被删除节点的双亲节点只想被删除节点的左孩子节点
   3. 删除该节点且是被删除节点的栓亲节点只想被伤处节点的有孩子节点
   4. 在它的右子树中寻找中序下的第一个节点（关键码最小），用它的值填补到被是拿出节点中，在来处理该节点的删除问题
   

删除有必要吗？

通过上面的删除分类讨论，我们发现删除其实是挺复杂的，那么其实我们可以不用真正的删除该节点，只需要在Node类总增加一个标识自断isDelete，当该字段为ture时，表示该节点已经删除，反正没有删除，那么我们在做比如find()等操作的时候，要先判断isDelete字段是否为true。这样删除的节点并不会改变树的结构。

二叉树接口的实现

public interface BinaryTreeInterface<T> {
    public T getRootData();
    public int getHeight();
    public int getNumberOfRoot();
    public void clear();

    public void setTree(T rootData); // 用rootData设置树
    public void setTree(T rootData,BinaryTreeInterface<T> left,BinaryTreeInterface<T> right); //设置树，用左右子节点
}

二叉树的属性

private Node root;//根节点

二叉树节点类

package com.jimmy.impl;

public class BinaryNode<T> {
    private T data;
    private BinaryNode<T> left;  //左子节点
    private BinaryNode<T> right; //右子节点
    public BinaryNode(){
        this(null);
    }
    public BinaryNode(T data){
        this(data,null,null);
    }
    public BinaryNode(T data,BinaryNode<T> left,BinaryNode<T> right){
        this.data=data;
        this.left=left;
        this.right=right;
    }
    public T getData()
    {
        return data;
    }
    public void setData(T data)
    {
        this.data= data;
    }
    public BinaryNode<T> getLeft() {
        return left;
    }
    public void setLeft(BinaryNode<T> left) {
        this.left = left;
    }
    public BinaryNode<T> getRight() {
        return right;
    }
    public void setRight(BinaryNode<T> right) {
        this.right = right;
    }

    public boolean hasLeft()
    {return left!=null;

    }
    public boolean hasRight()
    {return right!=null;

    }
    public boolean isLeaf()
    {return (left==null)&&(right==null);

    }
    public int getHeight()
    {
        return getHeight(this);
    }
    public int getHeight(BinaryNode<T> node)
    {
        int h=0;
        if(node!=null)
            h=1+Math.max(node.getHeight(node.left),node.getHeight(node.right));

        return h;
    }
    public int getNumOfNodes(){
        int lnum=0,rnum=0;
        if(left!=null)
            lnum=left.getNumOfNodes();
        if(right!=null)
            rnum=right.getNumOfNodes();
        return lnum+rnum+1;
    }

}

二叉树的实现

   package com.jimmy.impl;
 
import java.util.Stack;
 
import com.jimmy.BinaryTreeInterface;

    public class Binarytree<T> implements BinaryTreeInterface<T> {

        private BinaryNode<T> root;    //只要一个数据节点就够了
        // 构造空树
        public Binarytree(){
            root=null;
        }


        // 用rootData构造树（有个根）
        public Binarytree(T rootdata){
            root=new BinaryNode<T>(rootdata) ;
        }
        // 用其他树构造树
        public Binarytree(T rootdata,Binarytree<T> leftTree,Binarytree<T> rightTree){
            root=new BinaryNode<T>(rootdata) ;
            if(leftTree!=null){
                root.setLeft(leftTree.root);
            }

            if(rightTree!=null){
                root.setRight(rightTree.root);
            }
        }
        // 用rootData设置树（有个根）
        @Override
        public void setTree(T rootData) {
            root=new BinaryNode<T>(rootData) ;

        }
        // 用其他树设置树
        public void setTree(T rootData, BinaryTreeInterface<T> left,BinaryTreeInterface<T> right) {
            root=new BinaryNode<T>(rootData) ;
            Binarytree leftTree=null;
            Binarytree rightTree=null;
            if((leftTree=(Binarytree)left)!=null){
                root.setLeft(leftTree.root);
            }

            if((rightTree=(Binarytree)right)!=null){
                root.setRight(rightTree.root);
            }
        }

        @Override
        public void clear() {
            root=null;
        }

        @Override
        public int getHeight() {
            // TODO Auto-generated method stub
            return root.getHeight();
        }

        @Override
        public int getNumberOfRoot() {
            // TODO Auto-generated method stub
            return 0;
        }

        @Override
        public T getRootData() {
            if (root!=null)
                return root.getData();
            else
                return null;
        }

        public BinaryNode<T> getRoot() {
            return root;
        }

        public void setRoot(BinaryNode<T> root) {
            this.root = root;
        }


        public int getNumOfNodes(){
            return root.getNumOfNodes();
        }

        public void inOrderTraverse(){

            inOrderTraverse(root);
        }

        //用栈方法遍历
        public void inOrderStackTraverse(){

            Stack<BinaryNode> stack=new Stack<BinaryNode>();
            BinaryNode cur=root;
            //stack.push(root);
            while(!stack.isEmpty()||(cur!=null)){
                while(cur!=null)
                {

                    stack.push(cur);
                    cur=cur.getLeft();


                }
                if(!stack.isEmpty())
                {
                    BinaryNode tmp=stack.pop();
                    if(tmp!=null)
                    {System.out.println(tmp.getData());
                        cur=tmp.getRight();

                    }

                }
            }
        }
        // 递归遍历
        public void inOrderTraverse(BinaryNode<T> node){

            if(node!=null)
            {inOrderTraverse(node.getLeft());
                System.out.println(node.getData());

                inOrderTraverse(node.getRight());
            }
        }

        public static void main(String[] args) {
            Binarytree<String> t=new Binarytree<String>();
            Binarytree<String> t8=new Binarytree<String>("8");
            Binarytree<String> t7=new Binarytree<String>("7");
            t.setTree("6",t7,t8); //用t7,t8设置树t

            t.inOrderStackTraverse();
            System.out.println(t.getHeight());
        }
    }

总结

树是由边和节点构成，根节点是树最顶端的节点，它没有父节点；二叉树中，最多有两个子节点；某个节点的左子树每个节点都比该节点的关键字值小，右子树的每个节点都比该节点的关键字值大，那么这种树称为二叉搜索树，其查找、插入、删除的时间复杂度都为logN；可以通过前序遍历、中序遍历、后序遍历来遍历树，前序是根节点-左子树-右子树，中序是左子树-根节点-右子树，后序是左子树-右子树-根节点；删除一个节点只需要断开指向它的引用即可；哈夫曼树是二叉树，用于数据压缩算法，最经常出现的字符编码位数最少，很少出现的字符编码位数多一些。