数据结构与算法-09（二叉树）

最新推荐文章于 2022-08-26 19:20:44 发布
最新推荐文章于 2022-08-26 19:20:44 发布
阅读量614 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 二叉树 树堆 遍历 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43260996/article/details/119335510
版权

                                                           二叉树

                                                                                             个人博客：www.xiaobeigua.icu 

1.1树的基本定义

树是我们计算机中非常重要的一种数据结构，同时使用树这种数据结构，可以描述现实生活中的很多事物，例如家 谱、单位的组织架构、等等。

树是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就 是说它是根朝上，而叶朝下的。

            

 

树具有以下特点：

        1.每个结点有零个或多个子结点；

        2.没有父结点的结点为根结点；

        3.每一个非根结点只有一个父结点；

        4.每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树；

 1.2 树的相关术语

 结点的度：

        一个结点含有的子树的个数称为该结点的度；

叶结点：

        度为0的结点称为叶结点，也可以叫做终端结点

分支结点：

        度不为0的结点称为分支结点，也可以叫做非终端结点

结点的层次：

        从根结点开始，根结点的层次为1，根的直接后继层次为2，以此类推

结点的层序编号：

        将树中的结点，按照从上层到下层，同层从左到右的次序排成一个线性序列，把他们编成连续的自然数。

树的度：

        树中所有结点的度的最大值

树的高度(深度)：

         树中结点的最大层次

森林：

         m（m>=0）个互不相交的树的集合，将一颗非空树的根结点删去，树就变成一个森林；给森林增加一个统一的根 结点，森林就变成一棵树

                  

去掉了根结点：

                        

 孩子结点：

        一个结点的直接后继结点称为该结点的孩子结点

双亲结点(父结点)：

         一个结点的直接前驱称为该结点的双亲结点

兄弟结点：

        同一双亲结点的孩子结点间互称兄弟结点

1.3 二叉树的基本定义 

 二叉树就是度不超过2的树(每个结点最多有两个子结点)

                          

 满二叉树：

一个二叉树，如果每一个层的结点树都达到最大值，则这个二叉树就是满二叉树    

                       

  

 完全二叉树：

叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树

                               

1.4 二叉查找树的创建 

 1.4.1二叉树的结点类

根据对图的观察，我们发现二叉树其实就是由一个一个的结点及其之间的关系组成的，按照面向对象的思想，我们 设计一个结点类来描述结点这个事物。

结点类API设计：

 代码实现：

private class Node<Key,Value>{
 
   //存储键
    public Key key;
    //存储值
    private Value value;
    //记录左子结点
    public Node left;
    //记录右子结点
    public Node right;

    public Node(Key key, Value value, Node left, Node right) {
        this.key = key;
        this.value = value;
        this.left = left;
        this.right = right;
    }

}

1.4.2 二叉查找树API设计

1.4.3 二叉查找树实现

插入方法put实现思想：

1.如果当前树中没有任何一个结点，则直接把新结点当做根结点使用

2.如果当前树不为空，则从根结点开始：

        2.1如果新结点的key小于当前结点的key，则继续找当前结点的左子结点；

        2.2如果新结点的key大于当前结点的key，则继续找当前结点的右子结点；

        2.3如果新结点的key等于当前结点的key，则树中已经存在这样的结点，替换该结点的value值即可。

图解：

 

  

查询方法get实现思想：

从根节点开始：

1.如果要查询的key小于当前结点的key，则继续找当前结点的左子结点；

2.如果要查询的key大于当前结点的key，则继续找当前结点的右子结点；

3.如果要查询的key等于当前结点的key，则树中返回当前结点的value。

 删除方法delete实现思想：

1.找到被删除结点；

2.找到被删除结点右子树中的最小结点minNode

3.删除右子树中的最小结点

4.让被删除结点的左子树称为最小结点minNode的左子树，让被删除结点的右子树称为最小结点minNode的右子树

5.让被删除结点的父节点指向最小结点minNode

                

                

                

  

 代码：

//二叉树代码
public class BinaryTree<Key extends Comparable<Key>, Value> {
    //记录根结点
    private Node root;
    //记录树中元素的个数
    private int N;
    
    //获取树中元素的个数
    public int size() {
        return N;
    }

    //向树中添加元素key-value
    public void put(Key key, Value value) {
        root = put(root, key, value);
    }

    //向指定的树x中添加key-value,并返回添加元素后新的树
    private Node put(Node x, Key key, Value value) {
        if (x == null) {
            //个数+1
            N++;
            return new Node(key, value, null, null);
        }
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            //新结点的key大于当前结点的key，继续找当前结点的右子结点
            x.right = put(x.right, key, value);
        } else if (cmp < 0) {
            //新结点的key小于当前结点的key，继续找当前结点的左子结点
            x.left = put(x.left, key, value);
        } else {
            //新结点的key等于当前结点的key，把当前结点的value进行替换
            x.value = value;
        }
        return x;
    }

    //查询树中指定key对应的value
    public Value get(Key key) {
        return get(root, key);
    }

    //从指定的树x中，查找key对应的值
    public Value get(Node x, Key key) {
        if (x == null) {
            return null;
        }
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
            //如果要查询的key大于当前结点的key，则继续找当前结点的右子结点；
            return get(x.right, key);
        } else if (cmp < 0) {
            //如果要查询的key小于当前结点的key，则继续找当前结点的左子结点；
            return get(x.left, key);
        } else {
            //如果要查询的key等于当前结点的key，则树中返回当前结点的value。
            return x.value;
        }
    }

    //删除树中key对应的value
    public void delete(Key key) {
            root = delete(root, key);
    }

    //删除指定树x中的key对应的value，并返回删除后的新树
    public Node delete(Node x, Key key) {
        if (x == null) {
            return null;
        }
        int cmp = key.compareTo(x.key);
        if (cmp > 0) {
        //新结点的key大于当前结点的key，继续找当前结点的右子结点
            x.right = delete(x.right, key);
        } else if (cmp < 0) {
        //新结点的key小于当前结点的key，继续找当前结点的左子结点
            x.left = delete(x.left, key);
        } else {
            //新结点的key等于当前结点的key,当前x就是要删除的结点
            //1.如果当前结点的右子树不存在，则直接返回当前结点的左子结点
            if (x.right == null) {
                return x.left;
            }
            //2.如果当前结点的左子树不存在，则直接返回当前结点的右子结点
            if (x.left == null) {
                return x.right;
            }
            //3.当前结点的左右子树都存在
            //3.1找到右子树中最小的结点
            Node minNode = x.right;
            while (minNode.left != null) {
                minNode = minNode.left;
            }
            //3.2删除右子树中最小的结点
            Node n = x.right;

            while (n.left != null) {
                if (n.left.left == null) {
                    n.left = null;
                } else {
                    n = n.left;
                }
            }
            //3.3让被删除结点的左子树称为最小结点minNode的左子树，让被删除结点的右子树称为最小结点minNode的右子树
            minNode.left = x.left;
            minNode.right = x.right;
            //3.4让被删除结点的父节点指向最小结点minNode
            x = minNode;
            //个数-1
            N--;
        }
        return x;
    }



    //节点类
    private class Node {
        //存储键
        public Key key;
        //存储值
        private Value value;
        //记录左子结点
        public Node left;
        //记录右子结点
        public Node right;

        public Node(Key key, Value value, Node left, Node right) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }


}

 测试代码：

//测试代码
public class Test {
    public static void main(String[] args) throws Exception {

        BinaryTree<Integer, String> bt = new BinaryTree<>();

        bt.put(4, "二哈");
        bt.put(1, "张三");
        bt.put(3, "李四");
        bt.put(5, "王五");

        System.out.println(bt.size());
        bt.put(1,"老三");
        System.out.println(bt.get(1));
        System.out.println(bt.size());
        bt.delete(1);
        System.out.println(bt.size());
    }
}

1.5 二叉树的基础遍历

很多情况下，我们可能需要像遍历数组数组一样，遍历树，从而拿出树中存储的每一个元素，由于树状结构和线性 结构不一样，它没有办法从头开始依次向后遍历，所以存在如何遍历，也就是按照什么样的搜索路径进行遍历的问 题。

                                            

我们把树简单的画作上图中的样子，由一个根节点、一个左子树、一个右子树组成，那么按照根节点什么时候被访 问，我们可以把二叉树的遍历分为以下三种方式：

1.前序遍历：

        先访问根结点，然后再访问左子树，最后访问右子树

2.中序遍历：

        先访问左子树，中间访问根节点，最后访问右子树

3.后序遍历：

        先访问左子树，再访问右子树，最后访问根节点 如果我们分别对下面的树使用三种遍历方式进行遍历，得到的结果如下： 

                                              

1.5.1 前序遍历

我们在4.4中创建的树上，添加前序遍历的API：

public Queue preErgodic()：使用前序遍历，获取整个树中的所有键

private void preErgodic(Node x,Queue keys)：使用前序遍历，把指定树x中的所有键放入到keys队列中

实现过程中，我们通过前序遍历，把,把每个结点的键取出，放入到队列中返回即可。  

实现步骤：

1.把当前结点的key放入到队列中;

2.找到当前结点的左子树，如果不为空，递归遍历左子树

3.找到当前结点的右子树，如果不为空，递归遍历右子树

代码： 

//使用前序遍历，获取整个树中的所有键
public Queue<Key> preErgodic(){
    Queue<Key> keys = new Queue<>();
    preErgodic(root,keys);
    return keys;
}

//使用前序遍历，把指定树x中的所有键放入到keys队列中
private void preErgodic(Node x,Queue<Key> keys){
    if (x==null){
        return;
    }
    //1.把当前结点的key放入到队列中;
    keys.enqueue(x.key);
    //2.找到当前结点的左子树，如果不为空，递归遍历左子树
    if (x.left!=null){
        preErgodic(x.left,keys);
    }
    //3.找到当前结点的右子树，如果不为空，递归遍历右子树
    if (x.right!=null){
        preErgodic(x.right,keys);
    }
}

测试代码：

//测试代码
public class Test {
    public static void main(String[] args) throws Exception {
        
        BinaryTree<String, String> bt = new BinaryTree<>();

        bt.put("E", "5");
        bt.put("B", "2");
        bt.put("G", "7");
        bt.put("A", "1");
        bt.put("D", "4");
        bt.put("F", "6");
        bt.put("H", "8");
        bt.put("C", "3");

        Queue<String> queue = bt.preErgodic();

        for (String key : queue) {
                System.out.println(key+"="+bt.get(key));
        }
    }

}

1.5.2 中序遍历

我们在4.4中创建的树上，添加前序遍历的API：

public Queue<Key> midErgodic()：使用中序遍历，获取整个树中的所有键
private void midErgodic(Node x,Queue<Key> keys)：使用中序遍历，把指定树x中的所有键放入到keys队列中

实现步骤：

1.找到当前结点的左子树，如果不为空，递归遍历左子树

2.把当前结点的key放入到队列中

3.找到当前结点的右子树，如果不为空，递归遍历右子树

代码：

//使用中序遍历，获取整个树中的所有键
public Queue<Key> midErgodic(){
    Queue<Key> keys = new Queue<>();
    midErgodic(root,keys);
    return keys;
}

//使用中序遍历，把指定树x中的所有键放入到keys队列中
private void midErgodic(Node x,Queue<Key> keys){
    if (x==null){
        return;
    }
    //1.找到当前结点的左子树，如果不为空，递归遍历左子树
    if (x.left!=null){
        midErgodic(x.left,keys);
    }
    //2.把当前结点的key放入到队列中;
    keys.enqueue(x.key);
    //3.找到当前结点的右子树，如果不为空，递归遍历右子树
    if (x.right!=null){
        midErgodic(x.right,keys);
    }
}

测试代码：

//测试代码
public class Test {
    public static void main(String[] args) throws Exception {
      
            BinaryTree<String, String> bt = new BinaryTree<>();

            bt.put("E", "5");
            bt.put("B", "2");
            bt.put("G", "7");
            bt.put("A", "1");
            bt.put("D", "4");
            bt.put("F", "6");
            bt.put("H", "8");
            bt.put("C", "3");

            Queue<String> queue = bt.midErgodic();
            for (String key : queue) {
                System.out.println(key+"="+bt.get(key));
            }
        }
}

1.5.3 后序遍历

我们在4.4中创建的树上，添加前序遍历的API：

public Queue afterErgodic()：使用后序遍历，获取整个树中的所有键 
private void afterErgodic(Node x,Queue keys)：使用后序遍历，把指定树x中的所有键放入到keys队列中

实现步骤：

1.找到当前结点的左子树，如果不为空，递归遍历左子树

2.找到当前结点的右子树，如果不为空，递归遍历右子树

3.把当前结点的key放入到队列中;

代码：

//使用后序遍历，获取整个树中的所有键
public Queue<Key> afterErgodic(){
    Queue<Key> keys = new Queue<>();
    afterErgodic(root,keys);
    return keys;
}

//使用后序遍历，把指定树x中的所有键放入到keys队列中
private void afterErgodic(Node x,Queue<Key> keys){
    if (x==null){
        return;
    }
    //1.找到当前结点的左子树，如果不为空，递归遍历左子树
    if (x.left!=null){
        afterErgodic(x.left,keys);
    }
    //2.找到当前结点的右子树，如果不为空，递归遍历右子树
    if (x.right!=null){
        afterErgodic(x.right,keys);
    }
    //3.把当前结点的key放入到队列中;
    keys.enqueue(x.key);
}

测试代码:

//测试代码
public class Test {
    public static void main(String[] args) throws Exception {
    
        BinaryTree<String, String> bt = new BinaryTree<>();

        bt.put("E", "5");
        bt.put("B", "2");
        bt.put("G", "7");
        bt.put("A", "1");
        bt.put("D", "4");
        bt.put("F", "6");
        bt.put("H", "8");
        bt.put("C", "3");

        Queue<String> queue = bt.afterErgodic();

        for (String key : queue) {
            System.out.println(key+"="+bt.get(key));
        }
    }
}

1.6 二叉树的层序遍历

所谓的层序遍历，就是从根节点（第一层）开始，依次向下，获取每一层所有结点的值，有二叉树如下：

                                               

 

那么层序遍历的结果是：EBGADFHC

我们在4.4中创建的树上，添加层序遍历的API： 

public Queue<Key> layerErgodic()：使用层序遍历，获取整个树中的所有键

实现步骤：

1.创建队列，存储每一层的结点；

2.使用循环从队列中弹出一个结点：

        2.1获取当前结点的key；

        2.2如果当前结点的左子结点不为空，则把左子结点放入到队列中

        2.3如果当前结点的右子结点不为空，则把右子结点放入到队列中

                                             

 代码：

//使用层序遍历得到树中所有的键
public Queue<Key> layerErgodic(){

    Queue<Key> keys = new Queue<>();
    Queue<Node> nodes = new Queue<>();
    nodes.enqueue(root);
    while(!nodes.isEmpty()){
        Node x = nodes.dequeue();
        keys.enqueue(x.key);
        if (x.left!=null){
            nodes.enqueue(x.left);
        }
        if (x.right!=null){
            nodes.enqueue(x.right);
        }
    }
    return keys;
}

 测试代码：

//测试代码
public class Test {
    public static void main(String[] args) throws Exception {
       
        BinaryTree<String, String> bt = new BinaryTree<>();
      
        bt.put("E", "5");
        bt.put("B", "2");
        bt.put("G", "7");
        bt.put("A", "1");
        bt.put("D", "4");
        bt.put("F", "6");
        bt.put("H", "8");
        bt.put("C", "3");

        Queue<String> queue = bt.layerErgodic();

        for (String key : queue) {
            System.out.println(key+"="+bt.get(key));
        }
    }
}

小北呱
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构_树和二叉树
qq_2210007943的博客
07-27 468
数据结构_数组和广义表
数据结构与算法-二叉树的排序
最新发布
05-08
用递归的方法实现以下算法： 1．以二叉链表表示二叉树，建立一棵二叉树； 2．输出二叉树的中序遍历结果； 3．输出二叉树的前序遍历结果； 4．输出二叉树的后序遍历结果； 5．计算二叉树的深度； 6．统计二叉树的结点...
数据结构--树型结构
linkedin_21843693的博客
07-01 2207
数据结构--树型结构，其中二叉树是最为典型的树结构，也是初学者必须掌握和理解的知识点。
求结点x在二叉树中的双亲结点算法
qq_46504622的博客
12-26 1814
#include <stdio.h> #include <stdlib.h> #define N 50 //2020真题 struct student { char name[20]; float score[5]; double average,weighted_average; }stu[N],temp; int main() { int a,b,c,d,e; void sort(struct student s[]); struct student *p = s
数据结构——树（二叉树）
Superpig的博客
04-13 1681
树的存储 满二叉树 & 完全二叉树（编号和满二叉树编号相同） 二叉树性质： 1）在二叉树的第i层上至多有2^(i-1)个结点 2）深度为k的二叉树至多有2^k-1个结点 3）任意二叉树，若叶子数为n0，度为2的结点数为n2，则n0=n2+1； 4）具有n个结点的完全二叉树的深度为 完全二叉树编号的性质：【floor-向下取整，ceil-向上取整】 1）若编号i=1，则i是根结点；若i&g...
树、二叉树
weixin_52308754的博客
11-11 617
二叉树不是一种特殊的树，二叉树可以为空，树不能为空。 树和二叉树的2个主要差别： 树中结点的最大度数没有限制，而二叉树结点的最大度数为2。 树的结点无左、右之分，而二叉树的结点有左右之分。 注意：尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形。 一棵深度为k,且有2^k-1个结点的二叉树，称为满二叉树。这种树的特点是每一层上的结点数都是最大结点数。 在一棵二叉树中，除最后一层外，若其余层都是满的，并且或者最后一层是满的，或者是在右边缺少连续若干结点，则此二叉树为完全二叉树。 具有
数据结构域算法-二叉树的查找
05-08
用递归的方法实现以下算法： 1．以二叉链表表示二叉树，建立一棵二叉树； 2．输出二叉树的中序遍历结果； 3．输出二叉树的前序遍历结果； 4．输出二叉树的后序遍历结果； 5．计算二叉树的深度； 6．统计二叉树的结点...
数据结构与算法-对二叉树的操作.pdf
11-12
。。。
数据结构与算法-对二叉树的操作.docx
11-12
。。。
数据结构与算法-二叉树的创建与操作
04-21
压缩包里两个h文件，一个cpp文件，稳稳的，老铁！
输出二叉树中某结点的双亲结点
11-22
采用先序法建立一棵二叉树，设计输出某结点数据为x的双亲结点的数据的程序，二叉树的数据域类型为字符型， 扩展二叉树的叶子结点用‘#’表示，要求可以求一棵二叉树中多个结点的双亲。
数据结构之二叉树基本概念
lspdd的博客
02-13 1874
二叉树的基本概念 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分 来自百度词条 二叉树的基本形态： 1.空的二叉树： 其实就是指向空的指针 2.只有根节点的二叉树： 也就是一个指针指向一个节点，这个节点是根节点 3.只有左子树和右子树： 只有左子树和右子树（又称斜树，其实也就成了链表）：如下图：
二叉树：二叉树的定义，性质及存储结构
weixin_65244004的博客
08-26 2000
二叉树：二叉树的定义，性质及存储结构
二叉树查找双亲结点
热门推荐
qq_43527713的博客
11-15 1万+
//递归实现查找双亲结点 void Find_Father(BiTNode *(&T),ElemType data) { if(T ==NULL) return; if(T->lchild != NULL)//当左孩子存在的时候才进行判断，否则程序出错 { if(T->lchild->data == data)...
数据结构-满m叉树中编号为i的结点的双亲结点（若存在）的编号是多少
Hillbox
09-06 7929
二叉树如何实现双亲结点及求树的高度
钟真龙的博客
12-08 7994
求二叉树的高度，可以用递归的思想去求解，也可以用非递归的思想去求解，只不过，递归的代码简单明了，但是总的来说，递归有递归的好处，非递归当然也有非递归的好处。 求树的高度的递归思想和递归建树的思想差不多：                                                                 从最底层的子树（结点）开始，求每颗子树（个结点）的左子树和右子树
寻找二叉树双亲结点
gy77
02-25 3821
/* * @Issue: 寻找X结点的双亲结点 * @Author: 一届书生 * @LastEditTime: 2020-02-25 16:50:27 */ #include<iostream> using namespace std; #define type char typedef struct node{ type data; node ...
数的双亲表示法结点结构定义
sunny_girl_123的博客
07-25 1271
//数的双亲表示法结点结构定义 #define MAX_TREE_SIZE 100 type int ElemType; typedef struct PTNode { ElemType data; //结点数据 int parent; //双亲位置 即数组的下标 } PTNode; typedef struct { PTNode nodes[MAX_TREE_SI
《数据结构与算法》(二叉树)家谱管理系统.docx
06-15
《数据结构与算法》(二叉树)家谱管理系统.docx是一份课程设计说明书，旨在帮助学生理解和应用数据结构与算法的知识，以及设计并实现一个家谱管理系统。随着计算机科学技术的迅速发展，计算机应用已经深入到人类社会...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值