- 浏览: 3507486 次
- 性别:
- 来自: 杭州
文章分类
- 全部博客 (1491)
- Hibernate (28)
- spring (37)
- struts2 (19)
- jsp (12)
- servlet (2)
- mysql (24)
- tomcat (3)
- weblogic (1)
- ajax (36)
- jquery (47)
- html (43)
- JS (32)
- ibatis (0)
- DWR (3)
- EXTJS (43)
- Linux (15)
- Maven (3)
- python (8)
- 其他 (8)
- JAVASE (6)
- java javase string (0)
- JAVA 语法 (3)
- juddiv3 (15)
- Mule (1)
- jquery easyui (2)
- mule esb (1)
- java (644)
- log4j (4)
- weka (12)
- android (257)
- web services (4)
- PHP (1)
- 算法 (18)
- 数据结构 算法 (7)
- 数据挖掘 (4)
- 期刊 (6)
- 面试 (5)
- C++ (1)
- 论文 (10)
- 工作 (1)
- 数据结构 (6)
- JAVA配置 (1)
- JAVA垃圾回收 (2)
- SVM (13)
- web st (1)
- jvm (7)
- weka libsvm (1)
- weka屈伟 (1)
- job (2)
- 排序 算法 面试 (3)
- spss (2)
- 搜索引擎 (6)
- java 爬虫 (6)
- 分布式 (1)
- data ming (1)
- eclipse (6)
- 正则表达式 (1)
- 分词器 (2)
- 张孝祥 (1)
- solr (3)
- nutch (1)
- 爬虫 (4)
- lucene (3)
- 狗日的腾讯 (1)
- 我的收藏网址 (13)
- 网络 (1)
- java 数据结构 (22)
- ACM (7)
- jboss (0)
- 大纸 (10)
- maven2 (0)
- elipse (0)
- SVN使用 (2)
- office (1)
- .net (14)
- extjs4 (2)
- zhaopin (0)
- C (2)
- spring mvc (5)
- JPA (9)
- iphone (3)
- css (3)
- 前端框架 (2)
- jui (1)
- dwz (1)
- joomla (1)
- im (1)
- web (2)
- 1 (0)
- 移动UI (1)
- java (1)
- jsoup (1)
- 管理模板 (2)
- javajava (1)
- kali (7)
- 单片机 (1)
- 嵌入式 (1)
- mybatis (2)
- layui (7)
- asp (12)
- asp.net (1)
- sql (1)
- c# (4)
- andorid (1)
- 地价 (1)
- yihuo (1)
- oracle (1)
最新评论
-
endual:
https://blog.csdn.net/chenxbxh2 ...
IE6 bug -
ice86rain:
你好,ES跑起来了吗?我的在tomcat启动时卡在这里Hibe ...
ES架构技术介绍 -
TopLongMan:
...
java public ,protect,friendly,private的方法权限(转) -
贝塔ZQ:
java实现操作word中的表格内容,用插件实现的话,可以试试 ...
java 读取 doc poi读取word中的表格(转) -
ysj570440569:
Maven多模块spring + springMVC + JP ...
Spring+SpringMVC+JPA
在计算机科学中,树是一种非常重要的数据结构,而且有非常广泛的应用,例如linux下的目录结构就可以看成是一棵树,另外树也是存储大量的数据一种解决方法,二叉排序树是树的一种特殊情形,它的每个节点之多只能有两个子节点,同时左子树的节点都小于它的父节点,右子树中的节点都大于它的父节点,二叉排序树在搜索中的应用非常广泛,同时二叉排序树的一个变种(红黑树)是java中TreeMap和TreeSet的实现基础。下边是二叉排序树的定义,其中用到了两个类,一个是Node类,代表树中的节点,另外一个是Name类,表示节点的数据,Name类实现Comparable接口,这样才可以比较节点的大小。
?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 public class BinarySearchTree{
private Node root;
private int size;
public BinarySearchTree(Node root){
this.root=root;
size++;
}
public int getSize(){
return this.size;
}
public boolean contains(Name name){
return contains(name,this.root);
//return false;
}
private boolean contains(Name n,Node root){
if(root==null){
return false;
}
int compare=n.compareTo(root.element);
if(compare>0){
if(root.right!=null){
return contains(n,root.right);
}else{
return false;
}
}else if(compare<0){
if(root.left!=null){
return contains(n,root.left);
}else{
return false;
}
}else{
return true;
}
}
public boolean insert(Name n){
boolean flag = insert(n,this.root);
if(flag) size++;
return flag;
}
private boolean insert(Name n,Node root){
if(root==null){
this.root=new Node(n);
return true;
}else if(root.element.compareTo(n)>0){
if(root.left!=null){
return insert(n,root.left);
}else{
root.left=new Node(n);
return true;
}
}else if(root.element.compareTo(n)<0){
if(root.right!=null){
return insert(n,root.right);
}else{
root.right=new Node(n);
return true;
}
}else{
root.frequency++;
return true;
}
}
public boolean remove(Name name){
root = remove(name,this.root);
if(root != null){
size--;
return true;
}
return false;
}
private Node remove(Name name,Node root){
int compare = root.element.compareTo(name);
if(compare == 0){
if(root.frequency>1){
root.frequency--;
}else{
/**根据删除节点的类型,分成以下几种情况
**①如果被删除的节点是叶子节点,直接删除
**②如果被删除的节点含有一个子节点,让指向该节点的指针指向他的儿子节点
**③如果被删除的节点含有两个子节点,找到左字数的最大节点,并替换该节点
**/
if(root.left == null && root.right == null){
root = null;
}else if(root.left !=null && root.right == null){
root = root.left;
}else if(root.left == null && root.right != null){
root = root.right;
}else{
//被删除的节点含有两个子节点
Node newRoot = root.left;
while (newRoot.left != null){
newRoot = newRoot.left;//找到左子树的最大节点
}
root.element = newRoot.element;
root.left = remove(root.element,root.left);
}
}
}else if(compare > 0){
if(root.left != null){
root.left = remove(name,root.left);
}else{
return null;
}
}else{
if(root.right != null){
root.right = remove(name,root.right);
}else{
return null;
}
}
return root;
}
public String toString(){
//中序遍历就可以输出树中节点的顺序
return toString(root);
}
private String toString(Node n){
String result = "";
if(n != null){
if(n.left != null){
result += toString(n.left);
}
result += n.element + " ";
if(n.right != null){
result += toString(n.right);
}
}
return result;
}
}
在二叉排序树的操作中,节点的删除时最难处理的,要分成很多种情况分别进行处理,下边是Node类和Name类的定义:
?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 class Node{
public Name element;
public Node left;
public Node right;
public int frequency = 1;
public Node(Name n){
this.element=n;
}
}
class Name implements Comparable<Name>{
private String firstName;
private String lastName;
public Name(String firstName,String lastName){
this.firstName=firstName;
this.lastName=lastName;
}
public int compareTo(Name n) {
int result = this.firstName.compareTo(n.firstName);
return result==0?this.lastName.compareTo(n.lastName):result;
}
public String toString(){
return firstName + "-" +lastName;
}
}
最后是二叉排序树的测试:
?1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 public static void main(String[] args){
//System.out.println("sunzhenxing");
Node root = new Node(new Name("sun","zhenxing5"));
BinarySearchTree bst =new BinarySearchTree(root);
bst.insert(new Name("sun","zhenxing3"));
bst.insert(new Name("sun","zhenxing7"));
bst.insert(new Name("sun","zhenxing2"));
bst.insert(new Name("sun","zhenxing4"));
bst.insert(new Name("sun","zhenxing6"));
bst.insert(new Name("sun","zhenxing8"));
System.out.println(bst);
bst.remove(new Name("sun","zhenxing2"));
System.out.println(bst);
bst.remove(new Name("sun","zhenxing7"));
System.out.println(bst);
}
发表评论
-
java 回溯法求解 8皇后问题
2012-02-14 07:51 4452package endual; public cl ... -
算法设计与分析_回溯法分析
2012-02-12 09:53 2356回溯法 有通用的解题 ... -
经典而简单的贪心算法
2012-02-10 18:23 1978package endual; public cl ... -
贪心算法的一些感悟
2012-02-10 15:42 2372每一个贪心算法的背后 ... -
java排序算法的实现(转载)
2012-01-31 23:12 1453插入排序: package org.rut. ... -
计算时间和空间复杂度
2012-02-02 13:37 1728计算时间和空间复杂度 分类: C++学习 2 ... -
java实现队列
2012-01-25 21:10 1540队列是一种重要的数据结构,在排队论和算法设计中有很重要的应用, ... -
java 栈(面试够了的)
2012-01-25 21:07 1545package endual;public class Sta ... -
java 栈的实现
2012-01-25 20:38 1382栈可以说是一种特殊的链表,它的主要特点是先进后出,是一种重要的 ... -
求解算法的时间复杂度的具体步骤
2012-01-25 19:14 1622求解算法的时间复杂度 ... -
常用的排序算法的时间复杂度和空间复杂度
2012-01-24 23:03 2450常用的排序算法的时间复杂度和空间复杂度 分类: 笔试面试题 ... -
时间复杂度和空间复杂度
2012-01-24 22:18 1950同一问题可用不同 ... -
时间复杂度和空间复杂度
2012-01-24 22:17 1956时间复杂度和空间复杂度 分类: Algorithm 2008 ... -
海量数据算法笔试题
2012-01-21 01:58 1561海量数据算法笔 ... -
[转]大数据量,海量数据 处理方法总结
2012-01-21 01:57 1192[转]大数据量,海量数据 处理方法总 ... -
时间复杂度的计算
2012-01-17 22:54 1331算法复杂度是在《数据 ... -
算法分类(按照效率降序排列)
2011-09-13 21:09 16361.常数级、 2.对数级 3.次线性级 4.线性级 5 ...
相关推荐
Java实现二叉树的基本操作
java实现二叉树非递归前序中序后序遍历
java实现二叉树数据结构,简单明了,免费下载
java实现二叉树遍历demo,一个简单是实例
Java实现二叉树的相关操作.
Java实现二叉树,Java实现队列.pdf
Java实现二叉树中序线索化 左键画节点 右键画跟 点可以拖动 两个节点可以连线 确认进行线索化 并画出线索
java实现2叉树 的一些简单的算法 例如 删除 插入 查找
java实现二叉树最佳方法。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
java实现二叉树的遍历,包括前序中序后序遍历,递归和非递归实现。
用java实现二叉树的创建和遍历
Java实现二叉树的先序、中序、后续、层次遍历,经验证可用版本,方便各种找工作面试笔试
java用队列实现的二叉树程序//入队 public void enqueue(E e); //出队 public E dequeue(); //取队列第一个 public E front(); //队列是否为空 public boolean isEmpty(); //队列大小 public int size...
java实现二叉树的Node节点定义手撕8种遍历(一遍过).doc
简单的描述了JAVA实现二叉树
java二叉树实现 (简单实现,入门用) /**创建二叉树*/ public BinaryTree createTree(String treeStr); /**寻找结点*/ public BinaryTree findNode(BinaryTree tree ,char sign); /**找所给结点的左子树*/ ...
给定先序中序序列,递归建立二叉树,并遍历
代码实现: 二叉树的查找、插入、删除和输出根节点到当前节点的路径 二叉树的前序遍历,中序遍历和后续遍历 TreeNode.java --定义树节点 Mytree.java----创建树结构和上述功能函数 TestTree.java --测试上述的功能