Skip to content

Commit 969fbfa

Browse files
author
tianqing.liang
committed
集合
1 parent ae55e4c commit 969fbfa

File tree

14 files changed

+30475
-0
lines changed

14 files changed

+30475
-0
lines changed

‎10-Binary-Search-Tree/BST.dart

Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -257,7 +257,48 @@ class BST<T extends Comparable<T>> {
257257
return node;
258258
}
259259

260+
// 从二分搜索树中删除元素为e的节点
261+
remove(T e){
262+
root = _removeNode(root!, e);
263+
}
264+
265+
_removeNode(_Node node, T e){
266+
if( node == null )
267+
return null;
260268

269+
if( e!.compareTo(node.e!) < 0 ){
270+
node.left = _removeNode(node.left! , e);
271+
return node;
272+
}
273+
else if(e.compareTo(node.e) > 0 ){
274+
node.right = _removeNode(node.right!, e);
275+
return node;
276+
}
277+
else{ // e.compareTo(node.e) == 0
278+
// 待删除节点左子树为空的情况
279+
if(node.left == null){
280+
_Node rightNode = node.right!;
281+
node.right = null;
282+
size = size! - 1 ;
283+
return rightNode;
284+
}
285+
// 待删除节点右子树为空的情况
286+
if(node.right == null){
287+
_Node leftNode = node.left!;
288+
node.left = null;
289+
size = size! -1;
290+
return leftNode;
291+
}
292+
// 待删除节点左右子树均不为空的情况
293+
// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
294+
// 用这个节点顶替待删除节点的位置
295+
_Node successor = _minimum(node.right!);
296+
successor.right = _removeMinDetail(node.right!);
297+
successor.left = node.left;
298+
node.left = node.right = null;
299+
return successor;
300+
}
301+
}
261302

262303

263304
@override

‎11-Set/BST.dart

Lines changed: 342 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,342 @@
1+
import 'LinkedListStatck.dart';
2+
import 'LinkedListQueue.dart';
3+
/**
4+
* 二分搜索树
5+
*/
6+
class BST<T extends Comparable<T>> {
7+
_Node? root;
8+
9+
int? size;
10+
11+
BST() {
12+
root = null;
13+
size = 0;
14+
}
15+
16+
int? getSize() {
17+
return size;
18+
}
19+
20+
bool isEmpty() {
21+
return size == 0;
22+
}
23+
24+
//添加元素
25+
// add(T t) {
26+
// if (root == null) {
27+
// root = _Node(t);
28+
// size = size! + 1;
29+
// } else {
30+
// addNext(root, t);
31+
// }
32+
// }
33+
add(T e) {
34+
root = addNext(root, e);
35+
}
36+
37+
// 向以node为根的二分搜索树中插入元素e，递归算法
38+
// addNext(_Node? node, T? t) {
39+
// if (t! == node!.e)
40+
// return;
41+
// else if (t.compareTo(node.e) < 0 && node.left == null) {
42+
// node.left = _Node(t);
43+
// size = size! +1;
44+
// return;
45+
// } else if (t.compareTo(node.e) > 0 && node.right == null) {
46+
// node.right = _Node(t);
47+
// size = size! +1;
48+
// return;
49+
// }
50+
// if (t.compareTo(node.e) < 0)
51+
// addNext(node.left, t);
52+
// else //e.compareTo(node.e) > 0
53+
// addNext(node.right, t);
54+
// }
55+
//返回新节点后二分搜索树的根
56+
_Node addNext(_Node? node, T t) {
57+
if (node == null) {
58+
size = size! + 1;
59+
return _Node(t);
60+
}
61+
if (t.compareTo(node.e) < 0) {
62+
node.left = addNext(node.left, t);
63+
} else if (t.compareTo(node.e) > 0) {
64+
node.right = addNext(node.right, t);
65+
}
66+
return node;
67+
}
68+
69+
// 向二分搜索树中添加新的元素e，非递归写法
70+
add2(T e) {
71+
if (root == null) {
72+
root = _Node(e);
73+
size = size! + 1;
74+
return;
75+
}
76+
_Node? p = root;
77+
while (p != null) {
78+
if (e.compareTo(p.e) < 0) {
79+
if (p.left == null) {
80+
p.left = _Node(e);
81+
size = size! + 1;
82+
return;
83+
}
84+
p = p.left;
85+
} else if (e.compareTo(p.e) > 0) {
86+
if (p.right == null) {
87+
p.right = _Node(e);
88+
size = size! + 1;
89+
return;
90+
}
91+
p = p.right;
92+
} else
93+
return;
94+
}
95+
}
96+
97+
//查询元素是否包含
98+
bool contains(T t) {
99+
return _containsAll(root, t);
100+
}
101+
102+
bool _containsAll(_Node? node, T t) {
103+
if (node == null) {
104+
return false;
105+
}
106+
if (t.compareTo(node.e) == 0) {
107+
return true;
108+
} else if (t.compareTo(node.e) < 0) {
109+
return _containsAll(node.left, t);
110+
} else {
111+
return _containsAll(node.right, t);
112+
}
113+
}
114+
115+
// 二分搜索树的前序遍历
116+
preOrder() {
117+
_preOrderDetail(root!);
118+
}
119+
120+
_preOrderDetail(_Node? node) {
121+
if (node == null) {
122+
return;
123+
}
124+
print(node.e);
125+
_preOrderDetail(node.left);
126+
_preOrderDetail(node.right);
127+
}
128+
129+
inOrder() {
130+
_inOrderDetail(root);
131+
}
132+
133+
_inOrderDetail(_Node? node) {
134+
if (node == null) {
135+
return;
136+
}
137+
_inOrderDetail(node.left);
138+
print(node.e);
139+
_inOrderDetail(node.right);
140+
}
141+
142+
postOrder() {
143+
_postOrderDetail(root);
144+
}
145+
146+
_postOrderDetail(_Node? node) {
147+
if (node == null) {
148+
return;
149+
}
150+
_postOrderDetail(node.left);
151+
152+
_postOrderDetail(node.right);
153+
print(node.e);
154+
}
155+
156+
// 二分搜索树的非递归前序遍历
157+
preOrderNR() {
158+
if (root == null) return;
159+
LinkedListStack stack = new LinkedListStack();
160+
stack.push(root);
161+
while (!stack.isEmpty()) {
162+
_Node cur = stack.pop();
163+
print(cur.e);
164+
if (cur.right != null) {
165+
stack.push(cur.right);
166+
}
167+
if (cur.left != null){
168+
stack.push(cur.left);
169+
}
170+
}
171+
}
172+
173+
// 二分搜索树的层序遍历
174+
levelOrder(){
175+
if(root == null)
176+
return;
177+
LinkedListQueue q= new LinkedListQueue();
178+
q.enqueue(root);
179+
while(!q.isEmpty()){
180+
_Node cur = q.dequeue();
181+
print(cur.e);
182+
if(cur.left != null){
183+
q.enqueue(cur.left);
184+
}
185+
if(cur.right != null){
186+
q.enqueue(cur.right);
187+
}
188+
}
189+
}
190+
191+
// 寻找二分搜索树的最小元素
192+
searchMinimum<T>(){
193+
if(size == 0){
194+
throw new Exception("BST is empty!");
195+
}
196+
return _minimum(root!).e;
197+
}
198+
// 返回以node为根的二分搜索树的最小值所在的节点
199+
_Node _minimum(_Node node){
200+
if(node.left == null){
201+
return node;
202+
}
203+
return _minimum(node.left!);
204+
}
205+
206+
// 寻找二分搜索树的最大元素
207+
searchMaximum<T>(){
208+
if(size == 0){
209+
throw new Exception("BST is empty");
210+
}
211+
return _maximum(root!).e;
212+
}
213+
// 返回以node为根的二分搜索树的最大值所在的节点
214+
_Node _maximum(_Node node){
215+
if(node.right == null){
216+
return node;
217+
}
218+
return _maximum(node.right!);
219+
}
220+
221+
// 从二分搜索树中删除最小值所在节点, 返回最小值
222+
removeMin<T>(){
223+
T ret = searchMinimum();
224+
root = _removeMinDetail(root!);
225+
return ret;
226+
}
227+
// 删除掉以node为根的二分搜索树中的最小节点
228+
// 返回删除节点后新的二分搜索树的根
229+
_Node _removeMinDetail(_Node node){
230+
if(node.left == null){
231+
_Node rightNode = node.right!;
232+
node.right = null;
233+
size = size! - 1;
234+
return rightNode;
235+
}
236+
node.left = _removeMinDetail(node.left!);
237+
return node;
238+
}
239+
240+
241+
// 从二分搜索树中删除最大值所在节点
242+
removeMax<T>(){
243+
T ret = searchMaximum();
244+
root = _removeMaxDetail(root!);
245+
return ret;
246+
}
247+
// 删除掉以node为根的二分搜索树中的最大节点
248+
// 返回删除节点后新的二分搜索树的根
249+
_Node _removeMaxDetail(_Node node){
250+
if(node.right == null){
251+
_Node leftNode = node.left!;
252+
node.left = null;
253+
size = size! -1 ;
254+
return leftNode;
255+
}
256+
node.right = _removeMaxDetail(node.right!);
257+
return node;
258+
}
259+
260+
// 从二分搜索树中删除元素为e的节点
261+
remove(T e){
262+
root = _removeNode(root!, e);
263+
}
264+
265+
_removeNode(_Node node, T e){
266+
if( node == null )
267+
return null;
268+
269+
if( e!.compareTo(node.e!) < 0 ){
270+
node.left = _removeNode(node.left! , e);
271+
return node;
272+
}
273+
else if(e.compareTo(node.e) > 0 ){
274+
node.right = _removeNode(node.right!, e);
275+
return node;
276+
}
277+
else{ // e.compareTo(node.e) == 0
278+
// 待删除节点左子树为空的情况
279+
if(node.left == null){
280+
_Node rightNode = node.right!;
281+
node.right = null;
282+
size = size! - 1 ;
283+
return rightNode;
284+
}
285+
// 待删除节点右子树为空的情况
286+
if(node.right == null){
287+
_Node leftNode = node.left!;
288+
node.left = null;
289+
size = size! -1;
290+
return leftNode;
291+
}
292+
// 待删除节点左右子树均不为空的情况
293+
// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
294+
// 用这个节点顶替待删除节点的位置
295+
_Node successor = _minimum(node.right!);
296+
successor.right = _removeMinDetail(node.right!);
297+
successor.left = node.left;
298+
node.left = node.right = null;
299+
return successor;
300+
}
301+
}
302+
303+
304+
@override
305+
String toString() {
306+
StringBuffer res = new StringBuffer();
307+
_generateBSTString(root!, 0, res);
308+
return res.toString();
309+
}
310+
311+
_generateBSTString(_Node? node, int depth, StringBuffer res) {
312+
if (node == null) {
313+
res.write("${_generateBSTStringDepth(depth)} null \n");
314+
return;
315+
}
316+
res.write("${_generateBSTStringDepth(depth)} ${node.e} \n");
317+
_generateBSTString(node.left, depth + 1, res);
318+
_generateBSTString(node.right, depth + 1, res);
319+
}
320+
321+
_generateBSTStringDepth(int depth) {
322+
StringBuffer res = new StringBuffer();
323+
for (int i = 0; i < depth; i++) {
324+
res.write(" - -");
325+
}
326+
return res.toString();
327+
}
328+
}
329+
330+
class _Node<T> {
331+
T? e;
332+
333+
_Node? left;
334+
335+
_Node? right;
336+
337+
_Node(T t) {
338+
this.e = t;
339+
this.left = null;
340+
this.right = null;
341+
}
342+
}

0 commit comments

Comments
 (0)