数据结构与算法入门——二叉树之链式存储的二叉树、顺序存储的二叉树

链式存储的二叉树

• 创建二叉树并添加节点

//节点类
public class TreeNode {
    //节点的权
    int value;
    //左结点
    TreeNode lNode;
    //右结点
    TreeNode rNode;

    public TreeNode(int value) {
        this.value = value;
    }

    public void setlNode(TreeNode lNode) {
        this.lNode = lNode;
    }

    public void setrNode(TreeNode rNode) {
        this.rNode = rNode;
    }
}

//树类
public class Binary_Tree {
    TreeNode root;
    //获取根结点
    public TreeNode getRoot() {
        return root;
    }
    //设置根结点
    public void setRoot(TreeNode root) {
        this.root = root;
    }
}

//测试类
public class TestBinary_Tree {
    public static void main(String[] args) {
        //创建一棵树
        Binary_Tree tree = new Binary_Tree();
        //创建根结点
        TreeNode rootNode = new TreeNode(1);
        //将根结点赋给树
        tree.setRoot(rootNode);
        //创建左结点
        TreeNode leftNode = new TreeNode(1);
        //创建右结点
        TreeNode rightNode = new TreeNode(1);
        //添加左结点
        rootNode.setlNode(leftNode);
        //添加右结点
        rootNode.setrNode(rightNode);

    }
}

二叉树的遍历

• 前序遍历（根左右）：如图遍历顺序为：1 2 4 5 3 6 7

 //前序遍历
    public void frontShow() {
        // 首先遍历当前结点
        System.out.println(value);
        //然后遍历左结点
        if (lNode!=null){
            //只要左结点不为空，就打印左结点
           lNode.frontShow();
        }
        //最后遍历右结点
        if (rNode!=null){
            //只要左结点不为空，就打印左结点
            rNode.frontShow();
        }
    }

• 中序遍历（左根右）：如图遍历顺序为：4 2 5 1 6 3 7

 //中序遍历
    public void middleShow() {
        //首先遍历左结点
        if (lNode!=null){
            //只要左结点不为空，就打印左结点
            lNode.middleShow();
        }
        // 然后遍历当前结点
        System.out.print(value+" ");
        //最后遍历右结点
        if (rNode!=null){
            //只要左结点不为空，就打印左结点
            rNode.middleShow();
        }
    }

• 后序遍历（左右根）：如图遍历顺序为：4 5 2 6 7 3 1

 //后序遍历
    public void lastShow() {
        //首先遍历左结点
        if (lNode!=null){
            //只要左结点不为空，就打印左结点
            lNode.lastShow();
        }
        //然后遍历右结点
        if (rNode!=null){
            //只要左结点不为空，就打印左结点
            rNode.lastShow();
        }
        // 最后遍历当前结点
        System.out.print(value+" ");
    }

• 查找结点

 //查找就是遍历树以找到要查找的结点
    public TreeNode frontSearch(int i) {
        //创建最后返回的结点遍历
        TreeNode target = null;
        //如果当前结点的值直接等于要查找的值，则直接返回当前结点
        if (this.value == i){
            return this;
        }else {
            //如果当前结点的值不等于要查找的值，则继续遍历左结点
            if (lNode!=null){
                //如果查找到，则直接赋值target，如果查不到，target仍是null
               target = lNode.frontSearch(i);
            }
            //如果target获取到结点，则直接返回结果
            if (target != null){
                return target;
            }
            //如果还是找不到，则继续遍历右结点
            if (rNode!=null){
                //如果查找到，则直接赋值target，如果还是查不到，target仍是null，那么结果也是null
                target = rNode.frontSearch(i);
            }
            //如果target获取到结点，则直接返回结果
            if (target != null){
                return target;
            }
        }
        return null;
    }

• 删除结点

 public void delete(int i) {
        TreeNode parent = this;
        //判断左结点
        if (parent.lNode!=null&&parent.lNode.value == i){
            //如果是要删除的结点，那么清空当前结点
            parent.lNode = null;
        }
        //判断右结点
        if (parent.rNode!=null&&parent.rNode.value == i){
            //如果是要删除的结点，那么清空当前结点
            parent.rNode = null;
        }
        //递归检查并删除左结点
        parent = lNode;
        if (parent!=null){
            parent.delete(i);
        }
        //递归检查并删除右结点
        parent = rNode;
        if (parent!=null){
            parent.delete(i);
        }
    }

顺序存储的二叉树

• 性质

       1.第n个元素的左子结点：2n+1
       1.第n个元素的右子结点：2n+2
       1.第n个元素的父结点：（n-1）/2

• 遍历

//顺序存储的二叉树
public class ArrayBinary_Tree {
    int[] data;

    public ArrayBinary_Tree(int[] data) {
        this.data = data;
    }

    public void frontShow(){
        frontShow(0);
    }

    public void frontShow(int index){
        //如果当前二叉树没有值，则直接返回
        if (data == null||data.length == 0){
            return;
        }
        //如果不为0，先遍历当前节点，即根结点
        System.out.println(data[index]);
        //处理左结点
        if (2*index+1<data.length){
            //只要没有超出数组范围，就一直递归下去
            frontShow(2*index+1);
        }
        //处理右结点
        if (2*index+2<data.length){
            frontShow(2*index+2);
        }
    }
}