Java数据结构与算法(20) - ch08树
树的主要算法有插入,查找,显示,遍历,删除,其中显示和删除略微复杂。
package chap08.tree; import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack; class Node { public int iData;
public double dData; public Node leftChild;
public Node rightChild; public void displayNode() {
System.out.print("{" + iData + ", " + dData + "}");
}
} class Tree { // first node of tree
private Node root; public Tree() { root = null;
} /*
* 查找
*/
public Node find(int key) { // (assumes non-empty tree)
Node current = root; // start at root while (current.iData != key) // while no match,
{
if (key < current.iData) {
current = current.leftChild;
}
else {
current = current.rightChild;
}
if (current == null) {
return null;
}
}
return current; // found it
} /*
* 插入
*/
public void insert(int id, double dd) { Node newNode = new Node(); // make new node
newNode.iData = id; // insert data
newNode.dData = dd; if (root == null) { // no node in root
root = newNode;
}
else // root occupied
{
Node current = root; // start at root
Node parent; while (true) // (exits internally)
{
parent = current;
if (id < current.iData) {
current = current.leftChild;
if (current == null) {
// insert on left
parent.leftChild = newNode;
return;
}
}
else {
current = current.rightChild;
if (current == null) {
// insert on right
parent.rightChild = newNode;
return;
}
}
}
}
} /*
* 删除
*/
public boolean delete(int key)
{
// (assumes non-empty list)
Node current = root;
Node parent = root;
boolean isLeftChild = true; // search for node
while (current.iData != key)
{
parent = current;
if (key < current.iData) // go left?
{
isLeftChild = true;
current = current.leftChild;
}
else
{
isLeftChild = false;
current = current.rightChild;
}
if (current == null) // end of the line,
return false; // didn't find it
} // if no children, simply delete it
if (current.leftChild == null && current.rightChild == null) {
if (current == root) {
root = null;
}
else if (isLeftChild) {
parent.leftChild = null; // disconnect
}
else {
// from parent
parent.rightChild = null;
}
} // if no right child, replace with left subtree
else if (current.rightChild == null) {
if (current == root) {
root = current.leftChild;
}
else if (isLeftChild) {
parent.leftChild = current.leftChild;
}
else {
parent.rightChild = current.leftChild;
}
} // if no left child, replace with right subtree
else if (current.leftChild == null)
if (current == root)
root = current.rightChild;
else if (isLeftChild)
parent.leftChild = current.rightChild;
else
parent.rightChild = current.rightChild; // 有两个孩子,则用中序后继替代
else
{
// get successor of node to delete (current)
Node successor = getSuccessor(current); // connect parent of current to successor instead
if (current == root) {
root = successor;
}
else if (isLeftChild) {
parent.leftChild = successor;
}
else {
parent.rightChild = successor;
} // connect successor to current's left child
successor.leftChild = current.leftChild;
} return true;
} /*
* 获取后继
* 返回具有倒数第二高的值的节点
* 找到右孩子,然后右孩子的左子孙
*/
private Node getSuccessor(Node delNode) { Node successorParent = delNode;
Node successor = delNode; // go to right child
Node current = delNode.rightChild; while (current != null) {
successorParent = successor;
successor = current;
// go to left child
current = current.leftChild;
} // if successor not right child
if (successor != delNode.rightChild) { // make connections
successorParent.leftChild = successor.rightChild;
successor.rightChild = delNode.rightChild;
}
return successor;
} public void traverse(int traverseType) {
switch (traverseType) {
case 1:
System.out.print("\nPreorder traversal: ");
preOrder(root);
break;
case 2:
System.out.print("\nInorder traversal: ");
inOrder(root);
break;
case 3:
System.out.print("\nPostorder traversal: ");
postOrder(root);
break;
}
System.out.println();
} /*
* 先序遍历
*/
private void preOrder(Node localRoot) {
if (localRoot != null) {
System.out.print(localRoot.iData + " ");
preOrder(localRoot.leftChild);
preOrder(localRoot.rightChild);
}
} /*
* 中序遍历
*/
private void inOrder(Node localRoot) {
if (localRoot != null) {
inOrder(localRoot.leftChild);
System.out.print(localRoot.iData + " ");
inOrder(localRoot.rightChild);
}
} /*
* 后序遍历
*/
private void postOrder(Node localRoot) {
if (localRoot != null) {
postOrder(localRoot.leftChild);
postOrder(localRoot.rightChild);
System.out.print(localRoot.iData + " ");
}
} /*
* 在控制台打印显示树
*
*/
public void displayTree() { // 全局栈,初始放入树的根节点
Stack globalStack = new Stack();
globalStack.push(root); // 打印空格的数量
int nBlanks = 32; // 是否为空的标识
boolean isRowEmpty = false; while (isRowEmpty == false) { // 本地栈
Stack localStack = new Stack(); // 设置标识为空,后边再根据实际情况判断其是否不为空
isRowEmpty = true; // 打印一定数量的空格,为了将节点 放置在适当的位置以满足视觉效果上树的形状
for (int j = 0; j < nBlanks; j++) {
System.out.print(' ');
} while (globalStack.isEmpty() == false) { // 当标识不为空时,从全局栈弹出栈顶节点
Node temp = (Node) globalStack.pop(); if (temp != null) {
// 如果当前从全局栈弹出的栈顶元素 不为空,则打印当前节点数值,同时将其左右孩子节点放入本地栈
System.out.print(temp.iData);
// 先放左孩子,后方右孩子,后边转移到全局栈后,可以反序,从而保证左孩子在右孩子顶端
localStack.push(temp.leftChild);
localStack.push(temp.rightChild); // 如果当前全局栈弹出的节点有左孩子或右孩子
if (temp.leftChild != null || temp.rightChild != null) {
// 设置标识不为空
isRowEmpty = false;
}
}
else {
// 如果当前从全局栈弹出的栈顶元素 为空,则打印"--"替代节点数值,同时将两个空值放入本地栈
System.out.print("-");
localStack.push(null);
localStack.push(null);
} for (int j = 0; j < nBlanks * 2 - 1; j++) {
System.out.print(' ');
}
} System.out.println();
System.out.println(); nBlanks /= 2; while (localStack.isEmpty() == false) {
// 将本地栈的节点放入全局栈,进行反序,从而保证先处理左孩子
globalStack.push(localStack.pop());
}
}
}
} class TreeApp {
public static void main(String[] args) throws IOException {
int value;
Tree theTree = new Tree(); theTree.insert(50, 1.5);
theTree.insert(25, 1.2);
theTree.insert(75, 1.7);
theTree.insert(12, 1.5);
theTree.insert(37, 1.2);
theTree.insert(43, 1.7);
theTree.insert(30, 1.5);
theTree.insert(33, 1.2);
theTree.insert(87, 1.7);
theTree.insert(93, 1.5); while (true) {
System.out.print("Enter first letter of show, insert, find, delete, or traverse: "); int choice = getChar();
switch (choice) {
case 's':
theTree.displayTree();
break;
case 'i':
System.out.print("Enter value to insert: ");
value = getInt();
theTree.insert(value, value + 0.9);
break;
case 'f':
System.out.print("Enter value to find: ");
value = getInt();
Node found = theTree.find(value);
if (found != null) {
System.out.print("Found: ");
found.displayNode();
System.out.print("\n");
}
else {
System.out.print("Could not find ");
}
System.out.print(value + '\n');
break;
case 'd':
System.out.print("Enter value to delete: ");
value = getInt();
boolean didDelete = theTree.delete(value);
if (didDelete) {
System.out.print("Deleted " + value + '\n');
}
else {
System.out.print("Could not delete ");
}
System.out.print(value + '\n');
break;
case 't':
System.out.print("Enter type 1, 2 or 3: ");
value = getInt();
theTree.traverse(value);
break;
default:
System.out.print("Invalid entry\n");
}
}
} /*
* 获取输入
*/
public static String getString() throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr); String s = br.readLine();
return s;
} public static char getChar() throws IOException {
String s = getString();
return s.charAt(0);
} public static int getInt() throws IOException {
String s = getString();
return Integer.parseInt(s);
}
}
Java数据结构与算法(20) - ch08树的更多相关文章
- Java数据结构和算法(七)--AVL树
在上篇博客中,学习了二分搜索树:Java数据结构和算法(六)--二叉树,但是二分搜索树本身存在一个问题: 如果现在插入的数据为1,2,3,4,5,6,这样有序的数据,或者是逆序 这种情况下的二分搜索树 ...
- Java数据结构和算法 - 什么是2-3-4树
Q1: 什么是2-3-4树? A1: 在介绍2-3-4树之前,我们先说明二叉树和多叉树的概念. 二叉树:每个节点有一个数据项,最多有两个子节点. 多叉树:(multiway tree)允许每个节点有更 ...
- Java数据结构和算法(七)B+ 树
Java数据结构和算法(七)B+ 树 数据结构与算法目录(https://www.cnblogs.com/binarylei/p/10115867.html) 我们都知道二叉查找树的查找的时间复杂度是 ...
- Java数据结构和算法(一)树
Java数据结构和算法(一)树 数据结构与算法目录(https://www.cnblogs.com/binarylei/p/10115867.html) 前面讲到的链表.栈和队列都是一对一的线性结构, ...
- Java数据结构和算法(四)赫夫曼树
Java数据结构和算法(四)赫夫曼树 数据结构与算法目录(https://www.cnblogs.com/binarylei/p/10115867.html) 赫夫曼树又称为最优二叉树,赫夫曼树的一个 ...
- java数据结构和算法07(2-3-4树)
上一篇我们大概了解了红黑树到底是个什么鬼,这篇我们可以看看另外一种树-----2-3-4树,看这个树的名字就觉得很奇怪.... 我们首先要知道这里的2.3.4指的是任意一个节点拥有的子节点个数,所以我 ...
- Java数据结构和算法 - 二叉树
前言 数据结构可划分为线性结构.树型结构和图型结构三大类.前面几篇讨论了数组.栈和队列.链表都是线性结构.树型结构中每个结点只允许有一个直接前驱结点,但允许有一个以上直接后驱结点.树型结构有树和二叉树 ...
- Java数据结构和算法 - 递归
三角数字 Q: 什么是三角数字? A: 据说一群在毕达哥拉斯领导下工作的古希腊的数学家,发现了在数学序列1,3,6,10,15,21,……中有一种奇特的联系.这个数列中的第N项是由第N-1项加N得到的 ...
- Java数据结构与算法 - 外部存储
Q: 什么是外部存储? A: 外部存储特指某类磁盘系统,例如在大多数台式电脑或服务器中的硬盘. Q: 如何访问外部存储? A: 我们所学的数据结构都是假设数据存储在内存中,但是,在很多情况下要处理的数 ...
随机推荐
- 在 树莓派上使用 c++ libsockets library
rpi默认安装的编译器是gcc-4.6.2 而现在最新的c++ libsockets library 需要使用支持c++-11特征的编译器,即需要4.8.2才可以.为此,需要先升级编译器才可以支持编译 ...
- checkbox的attr("checked")一直以来,undefined问题解决
最近,屌丝要项目开发的需要,需要一个完整的选checkbox特征. 该死的~~这不是很easy什么东西,共checkbox,N多个子的checkbox,总checkbox一旦选定,儿checkbox所 ...
- 利用HttpOnly来防御xss攻击
xss的概念就不用多说了,它的危害是极大的,这就意味着一旦你的站点出现xss漏洞,就能够运行随意的js代码,最可怕的是攻击者利用js获取cookie或者session劫持,假设这里面包括了大量敏感信息 ...
- java: org.luaj.vm2.LuaError:XXX module not found lua脚本初始化出错(转)
我遇到这个错误是因为在引用脚本目录时,设置错了位置.设置成脚本所在目录的上级目录. lua使用和加载初始化方法 在java中使用lua,使用需要引用 luaj-jse-2.0.2.jar 同时需要使用 ...
- 双链表---LinkedList的重写
重写Linkedlist类,改写为MyLinkedList,未继承Iterable类. public class MyLinkedList<AnyType> { private int t ...
- .NET读写Excel工具Spire.Xls使用(1)入门介绍
原文:[原创].NET读写Excel工具Spire.Xls使用(1)入门介绍 在.NET平台,操作Excel文件是一个非常常用的需求,目前比较常规的方法有以下几种: 1.Office Com组件的方式 ...
- 【iOS发展-61】更换plist经过资源,执行iOS一旦数据仍显示在模拟器的外观,如何解决?
(1)案例介绍 --我们首先导入plist文件做项目,模拟的观看效果. --删除plist,更换一个新的plist,CMD+R模拟执行,或者找到该程序界面上显示最后一个数据. (2)原因 是由于第一次 ...
- CacheManager
.Net缓存管理框架CacheManager Cache缓存在计算机领域是一个被普遍使用的概念.硬件中CPU有一级缓存,二级缓存, 浏览器中有缓存,软件开发中也有分布式缓存memcache, redi ...
- Mongodb安装和配置
Mongodb之安装配置 安装 Mongodb的下载地址为Mongodb官网.下载时.你能够选择是安装包或者是压缩包. 下载完毕后.双击安装包并安装. 安装完毕后.你能够在安装文件夹看到下图中所见的文 ...
- Oracle Product Hub / Product Lifecycle Management / Product Information Management / Advanced Produc
In this Document Goal Solution 1. Master List showing sample code for APIs in Product Data Hub ...