数据结构_树结构

树结构同时集成了数组查找迅速和链表添删迅速的优点。先来看看普通的搜索二叉树的实现：

package com.wly.algorithmbase.datastructure;

/**
* 二叉搜索树
* @author wly
*/
public class BinaryTree {

private static BTreeNode root;
public static void main(String[] args) {

BinaryTree tree = new BinaryTree();
tree.insert(new BTreeNode(11, 23));
tree.insert(new BTreeNode(6, 12));
tree.insert(new BTreeNode(16, 51));
tree.insert(new BTreeNode(3, 32));
tree.insert(new BTreeNode(9, 42));
tree.insert(new BTreeNode(14, 52));
tree.insert(new BTreeNode(19, 62));
tree.insert(new BTreeNode(13, 72));
tree.insert(new BTreeNode(12, 82));

tree.find(2);
tree.print(root);
tree.delete(11);
tree.print(root);
}

/**
* 插入节点
* 关键在于缓存当前节点，检查当前节点的子节点
*/
public void insert(BTreeNode node) {
if(root == null) {
root = node;
} else {
BTreeNode currentNode = root;
BTreeNode parent;
while(true) {
parent = currentNode;
if(node.getKey() < currentNode.getKey()) {
currentNode = currentNode.getLeft();
if(currentNode == null) {
parent.setLeft(node);
return;
}
} else {
currentNode = currentNode.getRight();
if(currentNode == null) {
parent.setRight(node);
return;
}
}
}
}
}

/**
* 根据关键字查找
*/
public BTreeNode find(int key) {
BTreeNode current = root;
while(true) {
if(current == null) {
System.out.println("未查找到key=" + key + "的节点");
return null;
} else {
if(current.getKey() > key) {
current = current.getLeft();
} else if(current.getKey() < key) {
current = current.getRight();
} else {
System.out.println("查找到key=" + key + ",data=" + current.getData() + "的节点");
return current;
}
}
}
}

/**
* 根据key值删除节点,删除的成功与否取决于是否存在该节点
* @param key
* @return true删除成功，false删除失败
*/
public boolean delete(int key) {
BTreeNode deleteNode = find(key);
if(deleteNode == null) {
System.out.println("未查找到key=" + key + "的节点，无法进行删除");
return false;
} else {
removeFromTree(deleteNode);
System.out.println("成功删除key=" + key + "的节点");
return true;
}
}

/**
* 将自身从树中移除
*/
public void removeFromTree(BTreeNode node) {
//1.自身不包含子节点
if(node.getLeft() == null && node.getRight() == null) {
if(node.isLeft) {
node.getParent().setLeft(null);
} else {
node.getParent().setRight(null);
}
}

//2.包含一个子节点
if(node.getLeft() != null && node.getRight() == null) {
if(node.isLeft) {
node.getParent().setLeft(node.getLeft());
} else {
node.getParent().setRight(node.getLeft());
}
} else if(node.getLeft() == null && node.getRight() != null) {
if(node.isLeft) {
node.getParent().setLeft(node.getRight());
} else {
node.getParent().setRight(node.getRight());
}
}

//3.包含两个子节点
//查找后继节点
BTreeNode successorNode = node.getSuccessor(node);
//从树种移除该后继节点
if(successorNode.getParent() != null) {
if(successorNode.isLeft) {
successorNode.getParent().setLeft(null);
} else {
successorNode.getParent().setRight(null);
}
}
successorNode.setLeft(node.getLeft());
successorNode.setRight(node.getRight());
//从树中移除待删除节点，并用后继节点替换
if(node.getParent() != null) {
if(node.isLeft) {
node.getParent().setLeft(successorNode);
} else {
node.getParent().setRight(successorNode);
}
} else {
root = successorNode;
}
}

/**
* 打印树结构
*/
public void print(BTreeNode node) {
if(node != null) {
System.out.print(node.getKey() + "|" + node.getData());
System.out.println();
}
if(node.getLeft() != null) {
print(node.getLeft());
}
if(node.getRight() != null) {
print(node.getRight());
}
}

}

/**
* 节点类
* @author wly
*
*/
class BTreeNode {
private BTreeNode left;
private BTreeNode right;

private BTreeNode parent;

boolean isLeft; //是左子节点吗，否则就是右子节点

int key; //检索关键字
int data; //包含的数据对象

public BTreeNode() {
super();
}

public BTreeNode(int key, int data) {
super();
this.key = key;
this.data = data;
}

public BTreeNode getLeft() {
return left;
}
public void setLeft(BTreeNode left) {
this.left = left;
if(left != null) {
left.parent = this;
left.isLeft = true;
}
}
public BTreeNode getRight() {
return right;
}
public void setRight(BTreeNode right) {
this.right = right;
if(right != null) {
right.parent = this;
right.isLeft = false;
}
}

public BTreeNode getParent() {
return parent;
}

public void setParent(BTreeNode parent) {
this.parent = parent;

}
public int getKey() {
return key;
}
public void setKey(int key) {
this.key = key;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}

/**
* 返回指定节点的后继节点(即大于指定节点的最小节点)
* @param node
* @return
*/
public BTreeNode getSuccessor(BTreeNode node) {
BTreeNode result = node.getRight(); //先取得右节点
if(result == null) {
return null;
} else {
while(result.getLeft() != null) {
result = result.getLeft();
}
}
return result;
}
}

未查找到key=2的节点
11|23
6|12
3|32
9|42
16|51
14|52
13|72
12|82
19|62

12|82
6|12
3|32
9|42
16|51
14|52
13|72
19|62

O啦~~~

• 本文已收录于以下专栏：

《数据结构实战》模拟文件系统目录组织------树的应用

• li2818
• 2017年05月24日 19:58
• 1333

js--数据结构--树

1.树的构造函数1.1Node属性： data存储的值 parent指向节点的父节点 children指向许多孩子节点 Node构造函数：function Node(data) { t...
• github_34514750
• 2016年04月08日 22:18
• 1747

用C#实现数据结构--树(一)

首先我们给树下一个定义： 树是一个有限的、非空的结点集，T={r} or T1 or T2 or…or Tn它具有下列性质：1．集合指定的结点r叫做树的根结点2．其余的结点可以划分成n个子集，T1,...
• shixinbao
• 2007年04月29日 18:11
• 1457

数据结构中各种树

1. 二叉树 2. 二叉查找树 3. 平衡二叉树 3.1 平衡查找树之AVL树 3.2 平衡二叉树之红黑树 4. B树 5. B+树 6. B*树 7. Trie树 　　数据结构中有很多树的结构，...
• qq445803843
• 2016年07月23日 23:25
• 1104

数据结构—— 二叉树数据结构的节点删除问题

• xinzhi8
• 2017年09月19日 17:16
• 192

数据结构C语言实现系列[8]——树

#include stdio.h>#include stdlib.h>#define kk 3        /* 定义树的度 */#define MS 10        /* 定义在建立树的存储...
• DL88250
• 2007年01月29日 01:34
• 1954

树结构的自定义及基本算法（Java数据结构学习笔记）

• github_27609763
• 2015年08月16日 20:07
• 5446

树结构控件：jQuery zTree

【简介】 zTree 是利用 JQuery 的核心代码，实现一套能完成大部分常用功能的 Tree 插件  兼容 IE、FireFox、Chrome 等浏览器  在一个页面内可同时生成多个 Tree...
• replace_
• 2016年12月21日 13:48
• 786

数据结构：树结构笔试题目

1、n个顶点,m条边的全连通图,至少去掉几条边才能构成一棵树？ n个顶点的树一定有n-1条边（证明可以看任何一本图论书），所以需要去掉m-(n-1)=m-n+1条边...
• u013200470
• 2015年07月13日 11:23
• 279

Android获取app目录树结构工具类

• carterrao
• 2017年11月22日 17:52
• 58

举报原因： 您举报文章：数据结构_树结构 色情 政治 抄袭 广告 招聘 骂人 其他 (最多只允许输入30个字)