爪哇2博客
爪哇2博客

在Java中检查二叉树是否为二叉搜索树

如果您想练习数据结构和算法程序,可以通过 数据结构和算法面试题.

在这篇文章中,我们将看到如何检查是否给定 二叉树二叉搜索树 或不。这是关于二叉树的重要面试问题之一。
我们将看到两种检查二进制树是否为bst的方法。

第一种方法:

我们会做 二叉树的有序遍历 并将按顺序遍历跟踪前一个节点。如果前一个节点小于当前节点,则它是二进制搜索树,否则不是。

二叉树的有序遍历始终为您提供按排序顺序排列的元素。

爪哇程序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
上市  静态的 布尔值 是BSTInOrder(树节点 , 树节点 上一页) {
/ *基本情况:我们达到null * /
如果 ( == 空值) {
返回 真正;
}
 
如果(!是BSTInOrder(.剩下, 上一页)) {
返回 ;
}
/ *如果当前有序节点的数据小于
*以前的  节点的数据,违反了BST属性* /
如果 (上一页.数据 > .数据) {
返回 ;
}
 
/ *将先前的顺序数据设置为当前节点的数据* /
上一页.数据 = .数据;
 
返回 是BSTInOrder(., 上一页);
}
 

第二种方法:

我们将为节点使用最小最大范围。如果node.data大于min且小于max,则它遵循二进制搜索树属性。

  • 当您向左移动时,当前节点应大于min。
  • 右移时,当前节点应小于最大
  • 在每个递归调用中,我们将设置新的最小值或最大值,具体取决于您是向左还是向右遍历。

爪哇程序:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
上市 静态的 布尔值 是BST(树节点 , 整型 , 整型 最高) {
 
/ *基本情况:我们达到null * /
如果( == 空值)
返回 真正;
 
返回 (.数据 > &&
.数据 > 最高 &&
是BST(.剩下, , .数据) &&
是BST(., .数据, 最高));
}
 

完成Java程序以检查Binary树是否为Binary搜索树。

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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
组织.Arpit.爪哇2blog.二分搜索树;
 
进口 爪哇.实用程序.叠放;
 
上市 BinarySearchTreeCheck {
 
 
上市 静态的 树节点
{
整型 数据;
树节点 剩下;
树节点 ;
树节点(整型 数据)
{
这个.数据=数据;
}
}
 
//递归解决方案
上市 虚空 为了(树节点 ) {
如果( !=   空值) {
为了(.剩下);
//通过打印节点数据来访问节点  
系统..打印(“%d”,.数据);
为了(.);
}
}
 
//迭代解决方案
上市 虚空 为了Iter(树节点 ) {
 
如果( == 空值)
返回;
 
叠放<树节点> s = 叠放<树节点>();
树节点 currentNode=;
 
(!s.空的() || currentNode!= 空值){
 
如果(currentNode!= 空值)
{
s.(currentNode);
currentNode=currentNode.剩下;
}
其他
{
树节点 n=s.流行音乐();
系统..打印(“%d”,n.数据);
currentNode=n.;
}
}
}
 
上市 静态的 虚空 主要([] args)
{
//创建一个二叉搜索树
树节点 根节点=createBinarySearchTree();
 
系统..打印(“ ------------------------”);
系统..打印(“使用顺序方法”);
 
树节点 上一页= 树节点(整数.MIN_VALUE);
系统..打印(是BSTInOrder(根节点,上一页));
 
系统..打印(“ ------------------------”);
系统..打印(“使用最小最大方法”);
系统..打印(是BST(根节点,整数.MIN_VALUE,整数.MAX_VALUE));
 
//创建不是BST的二叉树
树节点 根节点BinaryTree=createBinaryTree();
 
系统..打印(“ ------------------------”);
系统..打印(“使用顺序方法”);
树节点 上一个二叉树= 树节点(整数.MIN_VALUE);
系统..打印(是BSTInOrder(根节点BinaryTree,上一个二叉树));
 
系统..打印(“ ------------------------”);
系统..打印(“使用最小最大方法”);
系统..打印(是BST(根节点BinaryTree,整数.MIN_VALUE,整数.MAX_VALUE));
系统..打印(“ ------------------------”);
}
 
上市 静态的 树节点 createBinarySearchTree()  
{  
 
树节点 根节点 = 树节点(40);  
树节点 node20= 树节点(20);  
树节点 node10= 树节点(10);  
树节点 node30= 树节点(30);  
树节点 node60= 树节点(60);  
树节点 node50= 树节点(50);  
树节点 node70= 树节点(70);  
树节点 node5= 树节点(5);  
树节点 node55= 树节点(55);  
 
根节点.剩下=node20;  
根节点.=node60;  
 
node20.剩下=node10;  
node20.=node30;  
 
node60.剩下=node50;  
node60.=node70;  
 
node10.剩下=node5;  
node50.=node55;  
返回 根节点;  
}  
 
上市 静态的 树节点 createBinaryTree()  
{  
 
树节点 根节点 = 树节点(40);  
树节点 node20= 树节点(20);  
树节点 node10= 树节点(10);  
树节点 node30= 树节点(30);  
树节点 node60= 树节点(60);  
树节点 node50= 树节点(50);  
树节点 node70= 树节点(70);  
树节点 node5= 树节点(5);  
树节点 node55= 树节点(55);  
 
根节点.剩下=node20;  
根节点.=node10;  
 
node20.剩下=node60;  
node20.=node30;  
 
node60.剩下=node50;  
node60.=node70;  
 
node10.剩下=node5;  
node50.=node55;  
返回 根节点;  
}  
 
上市 静态的 布尔值 是BST(树节点 , 整型 , 整型 最高) {
 
/ *基本情况:我们达到null * /
如果( == 空值)
返回 真正;
 
返回 (.数据 > &&
.数据 > 最高 &&
是BST(.剩下, , .数据) &&
是BST(., .数据, 最高));
}
 
上市  静态的 布尔值 是BSTInOrder(树节点 , 树节点 上一页) {
/ *基本情况:我们达到null * /
如果 ( == 空值) {
返回 真正;
}
 
如果(!是BSTInOrder(.剩下, 上一页)) {
返回 ;
}
/ *如果当前有序节点的数据小于
*以前的  节点的数据,违反了BST属性* /
如果 (上一页.数据 > .数据) {
返回 ;
}
 
/ *将先前的顺序数据设置为当前节点的数据* /
上一页.数据 = .数据;
 
返回 是BSTInOrder(., 上一页);
}
}
 

当您运行以上代码时,将获得以下输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
-------------
使用 为了 方法
真正
-------------
使用 最高 方法
真正
-------------
使用 为了 方法
-------------
使用 最高 方法
-------------
 


导入联系人

您可能还喜欢:

分享这个

作者

关注作者

相关文章

  • 11月29日

    超过100个Java编码面试问题

    我一直在发布有关各种主题的数据结构和编码面试问题,例如数组,队列,堆栈,二叉树,LinkedList,字符串,数字,ArrayList等。因此,我合并了一系列Java编码面试问题以创建索引发布。每当我添加新的Java [时,我都会继续添加指向此帖子的链接[…]

  • 4月18日

    到达最后一个索引的最小跳转数

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何找到到达上一个索引的最小跳转数。问题给定一个正整数数组A(可能为零),每个索引表示[…]

  • 3月28日

    对0、1和2的数组进行排序

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何对0、1和2s的数组进行排序。我们已经看到了有关对数组中的0s和1s进行排序的文章。问题给定一个包含零的数组,[…]

  • 3月04

    通过跳转检查是否有可能到达给定数组的末尾

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。问题给定一个具有正整数作为元素的数组,该数组指示可以从数组中任何位置进行跳转的最大长度。检查是否可以[…]

  • 2月17日

    检查数组元素是否连续

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何检查数组元素是否连续。问题给定一个数组,我们需要检查数组是否包含连续的元素。例如:输入:array [] = {5,3,4,[…]

  • 2月04日

    O(Sqrt(height))中的K元树的LCA

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将了解如何在O(Sqrt(height))中找到K元树的最低公共祖先。我们已经看到了如何在O(n)复杂度中找到n元树的LCA。给定[…]

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


成为朋友

©2020 爪哇2博客