学习数据结构笔记 --- [二叉树学习(BinaryTree)]

Posted 2021-12-10 小智RE0

B站学习传送门–>尚硅谷Java数据结构与java算法（Java数据结构与算法）

---

ml

• • 1.初步学习二叉树
  • 2.初步实现二叉树的前序,中序,后序遍历
  • • 图解
    • 简易实现前中后序遍历
  • 3.初步实现二叉树的前序查找,中序查找;后序查找;
  • 4. 初步实现二叉树的删除
  • 5.顺序存储二叉树(完成前中后序遍历)
  • 6. 线索化二叉树

1.初步学习二叉树

注意,从二叉树的基础开始

二叉树;在根节点的基础上;

• 根节点左边的节点一般称为左子树;
• 根节点右边的节点一般称为右子树;
• 每一部分单独取出都能看做一颗二叉树

满二叉树:所有的根结点都挂有左子树和右子树

2.初步实现二叉树的前序,中序,后序遍历

本次先手动创建二叉树; 主要是学习二叉树的前序,中序,后序遍历思想

图解

先对之前这个图进行分析;

前序遍历:

获取输出顺序: 根结点(中间的节点) —> 左子树 —>右子树

例如:刚才创建的二叉树进行前序遍历的话;
就得输出 13 --> 11 --> 8 --> 12 --> 75 --> 14 --> 100

中序遍历:
获取输出顺序; 左子树 —> 中心节点 —> 右子树
例如刚才的二叉树进行中序遍历就是;
8 --> 11 --> 12 --> 13 --> 14 --> 75 --> 100

后序遍历;
输出顺序: 左子树 —> 右子树 —> 中心节点

刚才的二叉树输出顺序为;

8 --> 12 --> 11 --> 14 --> 100 --> 75 --> 13

简易实现前中后序遍历

/**
 * @author by CSDN@小智RE0
 * @date 2021-11-10 18:10
 */
public class DemoTree {
    public static void main(String[] args) {

        //手动创建二叉树;
        BinarTree  btree = new BinarTree();
        //先创建节点;
        Node root  = new Node(13);
        Node node1 = new Node(11);
        Node node2 = new Node(75);
        Node node3 = new Node(8);
        Node node4 = new Node(12);
        Node node5 = new Node(14);
        Node node6 = new Node(100);

       //手动挂接子节点;
        root.setLeft(node1);
        root.setRight(node2);
        node1.setLeft(node3);
        node1.setRight(node4);
        node2.setLeft(node5);
        node2.setRight(node6);
        btree.setRoot(root);

        System.out.println("简易的前序遍历---");
        btree.prefixList();
        System.out.println("简易的中序遍历---");
        btree.infixList();
        System.out.println("简易的后序遍历---");
        btree.suffixList();
    }
}


//二叉树;
class BinarTree {
    //根结点;
    public Node root;

    //设置根结点;
    public void setRoot(Node root) {
        this.root = root;
    }

    //前序遍历;
    public void prefixList() {
        if (root == null) {
            System.out.println("空树,不遍历");
        } else {
            this.root.prefixList();
        }
    }

    //中序遍历;
    public void infixList() {
        if (root == null) {
            System.out.println("空树,不遍历");
        } else {
            this.root.infixList();
        }
    }

    //后序遍历;
    public void suffixList() {
        if (root == null) {
            System.out.println("空树,不遍历");
        } else {
            this.root.suffixList();
        }
    }
}

//节点;
class Node {
    //节点的值;
    private int val;
    //左子树,右子树;
    private Node left;
    private Node right;

    public Node(int val) {
        this.val = val;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public Node getLeft() {
        return left;
    }

    public void setLeft(Node left) {
        this.left = left;
    }

    public Node getRight() {
        return right;
    }

    public void setRight(Node right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "Node{" + "val=" + val + '}';
    }

    //前序遍历;  中-->左-->右;
    public void prefixList() {
        //中心节点先输出;
        System.out.println(this);

        if (this.left != null) {
            //去左子树;
            this.left.prefixList();
        }

        if (this.right != null) {
            //去右子树;
            this.right.prefixList();
        }
    }

    //中序遍历;  左-->中-->右;
    public void infixList() {
        //先去左子树;
        if (this.left != null) {
            this.left.infixList();
        }
        //中心节点;
        System.out.println(this);
        //在去右子树;
        if (this.right != null) {
            this.right.infixList();
        }
    }

    //后序遍历;  左-->右-->中;
    public void suffixList() {
        //左子树;
        if (this.left != null) {
            this.left.suffixList();
        }
        //右子树;
        if (this.right != null) {
            this.right.suffixList();
        }
        //中心点输出
        System.out.println(this);
    }

}

测试结果;

简易的前序遍历---
Node{val=13}
Node{val=11}
Node{val=8}
Node{val=12}
Node{val=75}
Node{val=14}
Node{val=100}
简易的中序遍历---
Node{val=8}
Node{val=11}
Node{val=12}
Node{val=13}
Node{val=14}
Node{val=75}
Node{val=100}
简易的后序遍历---
Node{val=8}
Node{val=12}
Node{val=11}
Node{val=14}
Node{val=100}
Node{val=75}
Node{val=13}

3.初步实现二叉树的前序查找,中序查找;后序查找;

那么这个前序查找,中序查找,后序查找时,就得根据他这个遍历时的顺序一样;一步步查找即可;

前序查找

• 首先就判断当前的这个结点是否符合;
• 若当前结点不符合,就先判断左子树是否为空;若不为空则在左子树向下进行递归;
• 若在左子树递归后找到要查找的节点;就直接返回,
• 若没有在左子树下找到,就去判断右子树是否为空,不为空就去递归查找;
• 最终若还是没有找到,返回一个空节点.

中序查找

• 首先判断当前结点的左子树是否为空;不为空就进行递归;
• 若在左子树递归找到就直接返回;
• 判断当前结点是否符合;
• 再去判断当前结点的右子树是否为空,不为空就进行递归;
• 最终还未找到,返回一个空节点;

后序查找

• 首先判断当前结点的左子树是否为空,不为空就进行递归;
• 若在左子树递归找到就直接返回;
• 再去判断当前结点的右子树是否为空;不为空就进行递归;
• 若在右子树递归找到就直接返回;
• 判断当前结点是否符合;
• 最终还未找到,返回一个空节点.

/**
 * @author by CSDN@小智RE0
 */
public class DemoTree {
    public static void main(String[] args) {
        //手动创建二叉树;
        BinarTree btree = new BinarTree();
        //先创建节点;
        Node root = new Node(13);
        Node node1 = new Node(11);
        Node node2 = new Node(75);
        Node node3 = new Node(8);
        Node node4 = new Node(12);
        Node node5 = new Node(14);
        Node node6 = new Node(100);

        //手动挂接子节点;
        root.setLeft(node1);
        root.setRight(node2);
        node1.setLeft(node3);
        node1.setRight(node4);
        node2.setLeft(node5);
        node2.setRight(node6);
        btree.setRoot(root);

        System.out.println("前序查找测试--->");
        btree.prefixSearch(14);
        System.out.println("中序查找测试--->");
        btree.infixSearch(14);
        System.out.println("后序查找测试--->");
        btree.suffixSearch(14);
    }
}


//二叉树;
class BinarTree {
    //根结点;
    public Node root;

    //设置根结点;
    public void setRoot(Node root) {
        this.root = root;
    }

    //前序查找;
    public void prefixSearch(int val) {
        if (root == null) {
            System.out.println("空树,不用查找");
        } else {
            Node node = this.root.prefixSearch(val);
            if (node == null) {
                System.out.println("没有找到");
            } else {
                System.out.println("已找到节点" + node.getVal());
            }
        }
    }

    //中序查找;
    public void infixSearch(int val) {
        if (root == null) {
            System.out.println("空树,不用查找");
        } else {
            Node node = this.root.infixSearch(val);
            if (node == null) {
                System.out.println("没有找到");
            } else {
                System.out.println("已找到节点" + node.getVal());
            }
        }
    }

    //后序查找;
    public void suffixSearch(int val) {
        if (root == null) {
            System.out.println("空树,不用查找");
        } else {
            Node node = this.root.suffixSearch(val);
            if (node == null) {
                System.out.println("没有找到");
            } else {
                System.out.println("已找到节点" + node.getVal());
            }
        }
    }
}

//节点;
class Node {
    //节点的值;
    private int val;
    //左子树,右子树;
    private Node left;
    private Node right;

    public Node(int val) {
        this.val = val;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public Node getLeft() {
        return left;
    }

    public void setLeft(Node left) {
        this.left = left;
    }

    public Node getRight() {
        return right;
    }

    public void setRight(Node right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "Node{" + "val=" + val + '}';
    }

    //前序查找步骤;
    public Node prefixSearch(int val) {
        //前序遍历时, 中-->左-->右;
        System.out.println("正在前序查找中------>");
        //1.先判断当前结点是否为空;
        if (this.val == val) {
            return this;
        }
        Node resultNode = null;
        //若不符合,则先看左子树是否为null; 不为空则向左一直递归;
        if (this.left != null) {
            resultNode = this.left.prefixSearch(val);
        }
        //在左子树找到就提前返回;
        if (resultNode != null) {
            return resultNode;
        }
        //若左子树未找到则在右子树递归查找;
        //看右子树是否为空;
        if (this.right != null) {
            resultNode = this.right.prefixSearch(val);
        }
        //最终再返回这个查询的节点;若为null就是没找到;
        return resultNode;
    }

    //中序查找步骤;
    public Node infixSearch(int val) {
        //中序遍历时;左-->中-->右;
        Node resultNode = null;
        //先判断左子树是否为空;不为空再去查找;
        if (this.left != null) {
            resultNode = this.left.infixSearch(val);
        }
        //若已找到,就提前返回;
        if (resultNode != null) {
            return resultNode;
        }
        System.out.println("正在中序查找中------>");
        //判断当前节点是否符合;
        if (this.val == val) {
            return this;
        }
        //判断右子树是否为空,再去递归查找;
        if (this.right != null) {
            resultNode = this.right.infixSearch(val);
        }
        //最终返回结果节点;若为null则就是没找到;
        return resultNode;
    }

    //后序查找步骤;
    public Node suffixSearch(int val) {
        //后序遍历时,左-->右 -->中;
        Node resultNode = null;
        //同样地,先判断左子树是否为空;
        if (this.left != null) {
            resultNode = this.left.suffixSearch(val);
        }
        以上是关于学习数据结构笔记 --- [二叉树学习(BinaryTree)]的主要内容，如果未能解决你的问题，请参考以下文章
 
 数据结构与算法学习笔记 树
 数据结构与算法学习笔记 树
 数据结构学习笔记（二叉树）总结与整理
 数据结构学习笔记（二叉树）总结与整理
 数据结构学习笔记（二叉树）OJ题总结与整理
 数据结构学习笔记（二叉树）OJ题总结与整理