正文

Java数据结构二叉树难点解析

︶ㄣ速达网 メ
米米素材网V管理员 / 阅读
0709

树是一种重要的非线性数据结构，直观地看，它是数据元素（在树中称为结点）按分支关系组织起来的结构，很象自然界中的树那样。树结构在客观世界中广泛存在，如人类社会的族谱和各种社会组织机构都可用树形象表示

前言

本章，我们主要需要了解以下内容

  • 什么是线索二叉树
  • 怎么去把二叉树线索化
  • 怎么通过线索二叉树查找某个数的后继结点
  • 二叉树的查看——二叉树怎们遍历

 什么是线索二叉树

首先我们来了解一下什么是线索二叉树？

定义：一个二叉树通过如下的方法“穿起来”：所有原本为空的右(孩子)指针改为指向该节点在中序序列中的后继，所有原本为空的左(孩子)指针改为指向该节点的中序序列的前驱。

再看一下为什么要有线索二叉树？

顾名思义，线索二叉树，肯定是根据线索查找，查找速度肯定更快。

  • 线索二叉树能线性地遍历二叉树，从而比递归的中序遍历更快。使用线索二叉树也能够方便的找到一个节点的父节点，这比显式地使用父亲节点指针或者栈效率更高。这在栈空间有限，或者无法使用存储父节点的栈时很有作用（对于通过深度优先搜索来查找父节点而言)。

那线索仅仅是这样吗？当然不，我们都是懒的，能等待解决的问题，为什么会去想新的办法。我们要解决的是:

  • 为了解决无法直接找到该结点在某种遍历序列中的前驱和后继结点的问题
  • 但是同时出现了二叉链表找左、右孩子困难的问题，即在构建线索二叉树之后，链表的原来遍历方式会出问题。

最后看一下什么线索二叉树的图解

在我们的线索二叉树的书上，基本上都有以下这张图：

Java数据结构二叉树难点解析

大家看到上面这张图还是有点懵的叭，我们一起看一下我下面手画的图

怎么去把二叉树线索化

哦！在着之前献给大家提一下，二叉树的遍历方式，有这样的几种

  • 前序遍历二叉树的递归定义(根左右)
  • 中序遍历二叉树的递归定义(左根右)
  • 后续遍历二叉树的递归意义(左右根)

本博文主要讨论的是中序遍历
它的中序遍历结果就是abcde f ghi

Java数据结构二叉树难点解析

它的中序线索二叉树遍历如下

先画线索二叉树

Java数据结构二叉树难点解析

虚线箭头为线索指针，对于所有左指针指向空的节点：将该节点的左指针指向该节点在中序遍历中的上一节点；对于所有右指针指向空的节点，将该节点的右指针指向该节点在中序遍历中的下一结点。最后一个末尾结点除外。
中序图解线索二叉树

Java数据结构二叉树难点解析

怎么通过线索二叉树查找某个数的后继结点

即形成了一个特殊的双向链表，之所以特殊，以f–>e为例，f–>e并不是直接到达，而是通过f–>b–>d–>e间接到达。

我们尝试用java去构建一颗线索二叉树叭

先申明，我从未使用java构建过树，二叉树都没有，若有错误，请指出

数据结点类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
package com.testtree;
 
/**
 * @author pier
 */
public class treenode {
    /**数据域**/
    private int data;
    /**左指针**/
    private treenode left;
    /** 左孩子是否为线索，采用布尔类型主要是判断是否未null足以**/
    private boolean leftisthread;
    /**右指针**/
    private treenode right;
    /** 右孩子是否为线索**/
    private boolean rightisthread;
 
    /**根据数据域来确定所在的指针对应位置**/
    public treenode(int data)
    {
        this.data = data;
        this.left = null;
        this.leftisthread = false;
        this.right = null;
        this.rightisthread = false;
    }
 
    public int getdata()
    {
        return data;
    }
 
    public void setdata(int data)
    {
        this.data = data;
    }
 
    public treenode getleft()
    {
        return left;
    }
 
    public void setleft(treenode left)
    {
        this.left = left;
    }
 
    public boolean isleftisthread()
    {
        return leftisthread;
    }
 
    public void setleftisthread(boolean leftisthread)
    {
        this.leftisthread = leftisthread;
    }
 
    public treenode getright()
    {
        return right;
    }
 
    public void setright(treenode right)
    {
        this.right = right;
    }
 
    public boolean isrightisthread()
    {
        return rightisthread;
    }
 
    public void setrightisthread(boolean rightisthread)
    {
        this.rightisthread = rightisthread;
    }
 
    @override
    public boolean equals(object obj)
    {
        if (obj instanceof treenode )
        {
            treenode temp = (treenode) obj;
            if (temp.getdata() == this.data)
            {
                return true;
            }
        }
        return false;
    }
 
    @override
    public int hashcode()
    {
        return super.hashcode() + this.data;
    }
}

二叉树类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
package com.testtree;
/*author:pier
2021/10/12
*/
 
public class bitree {
    /** 根节点 **/
    private treenode root;
    /** 大小 **/
    private int size;
    /** 线索化的时候保存前驱 **/
    private treenode pre = null;
 
    public bitree()
    {
        this.root = null;
        this.size = 0;
        this.pre = null;
    }
 
    public bitree(int[] data)
    {
        this.pre = null;
        this.size = data.length;
        // 创建二叉树
        this.root = createtree(data, 1);
    }
 
    /**
     * 创建二叉树
     *
     */
    public treenode createtree(int[] data, int index)
    {
        if (index > data.length)
        {
            return null;
        }
        treenode node = new treenode(data[index - 1]);
        treenode left = createtree(data, 2 * index);
        treenode right = createtree(data, 2 * index + 1);
        node.setleft(left);
        node.setright(right);
        return node;
    }
    /**中序遍历**/
    public void inlist(treenode root)
    {
        if (root != null)
        {
            inlist(root.getleft());
            system.out.print(root.getdata() + ",");
            inlist(root.getright());
        }
    }
 
    public treenode getroot()
    {
        return root;
    }
 
    public void setroot(treenode root)
    {
        this.root = root;
    }
 
    public int getsize()
    {
        return size;
    }
 
    public void setsize(int size)
    {
        this.size = size;
    }
    /**线索化二叉树**/
    public void inthread(treenode root) {
        if ( root != null ) {
            // 线索化左孩子
            inthread(root.getleft());
            // 左孩子为空
            if ( null == root.getleft() )
            {
                // 将左孩子设置为线索
                root.setleftisthread(true);
                root.setleft(pre);
            }
            // 右孩子为空
            if ( pre != null && null == pre.getright() )
            {
                pre.setrightisthread(true);
                pre.setright(root);
            }
            pre = root;
            // 线索化右孩子
            inthread(root.getright());
        }
    }
    /**
     * 中序遍历线索二叉树
     *
     */
    public void inthreadlist(treenode root)
    {
        if (root != null)
        {
            // 如果左孩子不是线索
            while (root != null && !root.isleftisthread())
            {
                root = root.getleft();
            }
 
            do
            {
                // 如果右孩子是线索
                system.out.print(root.getdata() + ",");
                if (root.isrightisthread())
                {
                    root = root.getright();
                }
                // 有右孩子
                else
                {
                    root = root.getright();
                    while (root != null && !root.isleftisthread())
                    {
                        root = root.getleft();
                    }
                }
            } while (root != null);
        }
    }
}

测试类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.testtree;
 
/**
 * @author pier
 */
public class test {
    public static void main(string[] args) {
    //不要问我为什么设置这么大，结尾看我效果截图
        int[] arr = new int[10000];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=i+1;
        }
        //创建一颗二叉树
        bitree bitree = new bitree(arr);
        //中序遍历二叉树
        system.out.println("中序遍历结果如下:");
        long start1 = system.currenttimemillis();
        bitree.inlist(bitree.getroot());
        long end1 = system.currenttimemillis();
        system.out.println();
        system.out.println("普通遍历时间为:"+(end1-start1)+"毫秒");
        system.out.println("\n");
        //中序遍历将二叉树线索化
        bitree.inthread(bitree.getroot());
        system.out.println("线索二叉树中序遍历如下:");
        long start2 = system.currenttimemillis();
        bitree.inthreadlist(bitree.getroot());
        long end2 = system.currenttimemillis();
        system.out.println();
        system.out.println("线索二叉树的遍历时间为:"+(end2-start2)+"毫秒");
 
    }
}

运行结果

Java数据结构二叉树难点解析


当我使用1-10的时候效果截图

Java数据结构二叉树难点解析

完全看不出来差距，所以，哈哈才设置那么大，能够实践出来线索二叉树的遍历速度确实更快的。

ps：看完这篇文章，你不来点个赞吗？不来个三连吗？重点是，你今天get到了吗？别之后alt+insert自动生成get哟，用你那看起来不聪明的小脑袋瓜想一想。

到此这篇关于java数据结构二叉树难点解析的文章就介绍到这了,更多相关java 二叉树内容请搜索米米素材网以前的文章或继续浏览下面的相关文章希望大家以后多多支持米米素材网！

原文链接：https://blog.csdn.net/qq_43325476/article/details/120716127