java tree类子项的添加和删除_使用Java实现二叉树的添加，删除，获取以及遍历...
二叉樹節點的聲明：
static final class Entry>{
//保存的數據
private T item;
//左子樹
private Entry left;
//右子樹
private Entry right;
//父節點
private Entry parent;
Entry(T item,Entry parent){
this.item = item;
this.parent = parent;
}
}
類屬性：
//根節點
private Entry root;
//數據量
private int size = 0;
二叉樹添加數據：
/**
* 添加元素
* @param item 待添加元素
* @return 已添加元素
*/
public T put(T item){
//每次添加數據的時候都是從根節點向下遍歷
Entry t = root;
if (t == null){
//當前的叉樹樹的為空，將新節點設置為根節點，父節點為null
root = new Entry<>(item,null);
size++;
return root.item;
}
//自然排序結果，如果傳入的數據小于當前節點返回-1，大于當前節點返回1，否則返回0
int ret = 0;
//記錄父節點
Entry p = t;
while (t != null){
//與當前節點比較
ret = item.compareTo(t.item);
p = t;
//插入節點比當前節點小，把當前節點設置為左子節點，然后與左子比較，以此類推找到合適的位置
if (ret < 0)
t = t.left;
//大于當前節點
else if (ret > 0)
t = t.right;
else {
//相等就把舊值覆蓋掉
t.item = item;
return t.item;
}
}
//創建新節點
Entry e = new Entry<>(item,p);
//根據比較結果將新節點放入合適的位置
if (ret < 0)
p.left = e;
else
p.right = e;
size++;
return e.item;
}
在put的過程中，使用Comparable中的compareTo來比較兩個元素的大小的，所以在二叉樹中存儲的元素必須要繼承Comparable 類，覆寫compareTo方法。
二叉樹刪除數據
/**
* 刪除元素
* 刪除元素如果細分的話，可以分為4中：沒有子節點，只有左節點，只有右節點，有兩個子節點
* 1)沒有子節點這種情況比較簡單，直接刪除就可以了
* 2)只有左節點或右節點，這兩種情況處理方式是一致的，只是方向相反，所以在一起講了，
* 將刪除節點的父節點的左節點(右節點)指向刪除節點的子節點，將左節點(右節點)指向刪除節點的父節點
* 3)有兩個子節點，這種情況相對來說比較復雜一點：
* 找到刪除節點的前驅節點或后繼節點，然后將前驅或后繼節點的值賦給刪除節點，然后將前驅或后繼節點刪除。本質是刪除前驅或后繼節點
* 前驅節點的特點：
* 1)刪除的左子節點沒有右子節點，那么左子節點即為前驅節點
* 2)刪除節點的左子節點有右子節點，那么最右邊的最后一個節點即為前驅節點
* 后繼節點的特點：
* 與前驅節點剛好相反，總是右子節點，或則右子節點的最左子節點;例如：刪除節點為c ，那么前驅節點為 m，后繼節點為n
* a
* / \
* b c
* / \ / \
* d e f g
* / \ / \ / \ / \
* @param item 刪除元素 h i j k l m n o
* @return 刪除結果
*/
public boolean remove(T item){
//獲取刪除節點
Entry delEntry = getEntry(item);
if (delEntry == null) return false;
//刪除節點的父節點
Entry p = delEntry.parent;
size--;
//情況1：沒有子節點
if (delEntry.left == null && delEntry.right == null){
//刪除節點為根節點
if (delEntry == root){
root = null;
}else {//非根節點
//刪除的是父節點的左節點
if (delEntry == p.left){
p.left = null;
}else {//刪除右節點
p.right = null;
}
}
//情況2：刪除的節點只有左節點
}else if (delEntry.right == null){
Entry lc = delEntry.left;
//刪除的節點為根節點，將刪除節點的左節點設置成根節點
if (p == null) {
lc.parent = null;
root = lc;
} else {//非根節點
if (delEntry == p.left){//刪除左節點
p.left = lc;
}else {//刪除右節點
p.right = lc;
}
lc.parent = p;
}
//情況3：刪除節點只有右節點
}else if (delEntry.left == null){
Entry rc = delEntry.right;
//刪除根節點
if (p == null) {
rc.parent = null;
root = rc;
}else {//刪除非根節點
if (delEntry == p.left)
p.left = rc;
else
p.right = rc;
rc.parent = p;
}
//情況4：刪除節點有兩個子節點
}else {//有兩個節點,找到后繼節點，將值賦給刪除節點，然后將后繼節點刪除掉即可
Entry successor = successor(delEntry);//獲取到后繼節點
delEntry.item = successor.item;
//后繼節點為右子節點
if (delEntry.right == successor){
//右子節點有右子節點
if (successor.right != null) {
delEntry.right = successor.right;
successor.right.parent = delEntry;
}else {//右子節點沒有子節點
delEntry.right = null;
}
}else {//后繼節點必定是左節點
successor.parent.left = null;
}
return true;
}
//讓gc回收
delEntry.parent = null;
delEntry.left = null;
delEntry.right = null;
return true;
}
/**
* 獲取節點節點
* @param item 獲取節點
* @return 獲取到的節點，可能為null
*/
private Entry getEntry(T item){
Entry t = root;
int ret;
//從根節點開始遍歷
for (;t != null;){
ret = item.compareTo(t.item);
if (ret < 0)
t = t.left;
else if (ret > 0)
t = t.right;
else
return t;
}
return null;
}
/**
* 查找后繼節點
* @param delEntry 刪除節點
* @return 后繼節點
*/
private Entry successor(Entry delEntry) {
Entry r = delEntry.right;//r節點必定不為空
while (r.left != null){
r = r.left;
}
return r;
}
二叉樹獲取節點
/**
* 判斷是否存在該元素
* @param item 查找元素
* @return 結果
*/
public boolean contains(T item){
return getEntry(item) != null;
}
/**
* 獲取節點節點
* @param item 獲取節點
* @return 獲取到的節點，可能為null
*/
private Entry getEntry(T item){
Entry t = root;
int ret;
//從根節點開始遍歷
for (;t != null;){
ret = item.compareTo(t.item);
if (ret < 0)
t = t.left;
else if (ret > 0)
t = t.right;
else
return t;
}
return null;
}
因為我這個例子是存儲一個元素，獲取到的元素和傳進去的元素是一致的，所以我用contains方法來判斷返回true即表示獲取成功了，不返回獲取到的結果了。當然，如果將entry存儲的元素改為kv形式的話，就可以使用get方法了。
二叉樹的遍歷
二叉樹的遍歷可以分為三種：前序遍歷、中序遍歷和后續遍歷，其中中序遍歷是最常用的遍歷方式，因為它遍歷出來的結果的升序的。
前序遍歷：
/**
* 前序遍歷
* @param e 開始遍歷元素
*/
public void prevIterator(Entry e){
if (e != null) {
System.out.print(e.item + " ");
prevIterator(e.left);
prevIterator(e.right);
}
}
中序遍歷：
/**
* 中序遍歷
* @param e
*/
public void midIterator(Entry e){
if (e != null){
midIterator(e.left);
System.out.print(e.item + " ");
midIterator(e.right);
}
}
后序遍歷：
/**
* 后續遍歷
* @param e 開始遍歷元素
*/
public void subIterator(Entry e){
if (e != null) {
subIterator(e.left);
subIterator(e.right);
System.out.print(e.item + " ");
}
}
package com.rainple.collections;
/**
* 二叉樹
* @param
*/
public class BinaryTree> {
//根節點
private Entry root;
//數據量
private int size = 0;
public BinaryTree(){}
/**
* 添加元素
* @param item 待添加元素
* @return 已添加元素
*/
public T put(T item){
//每次添加數據的時候都是從根節點向下遍歷
Entry t = root;
size++;
if (t == null){
//當前的叉樹樹的為空，將新節點設置為根節點，父節點為null
root = new Entry<>(item,null);
return root.item;
}
//自然排序結果，如果傳入的數據小于當前節點返回-1，大于當前節點返回1，否則返回0
int ret = 0;
//記錄父節點
Entry p = t;
while (t != null){
//與當前節點比較
ret = item.compareTo(t.item);
p = t;
//插入節點比當前節點小，把當前節點設置為左子節點，然后與左子比較，以此類推找到合適的位置
if (ret < 0)
t = t.left;
//大于當前節點
else if (ret > 0)
t = t.right;
else {
//相等就把舊值覆蓋掉
t.item = item;
return t.item;
}
}
//創建新節點
Entry e = new Entry<>(item,p);
//根據比較結果將新節點放入合適的位置
if (ret < 0)
p.left = e;
else
p.right = e;
return e.item;
}
public void print(){
midIterator(root);
}
/**
* 中序遍歷
* @param e
*/
public void midIterator(Entry e){
if (e != null){
midIterator(e.left);
System.out.print(e.item + " ");
midIterator(e.right);
}
}
/**
* 獲取根節點
* @return 根節點
*/
public Entry getRoot(){return root;}
/**
* 前序遍歷
* @param e 開始遍歷元素
*/
public void prevIterator(Entry e){
if (e != null) {
System.out.print(e.item + " ");
prevIterator(e.left);
prevIterator(e.right);
}
}
/**
* 后續遍歷
* @param e 開始遍歷元素
*/
public void subIterator(Entry e){
if (e != null) {
subIterator(e.left);
subIterator(e.right);
System.out.print(e.item + " ");
}
}
/**
* 獲取節點節點
* @param item 獲取節點
* @return 獲取到的節點，可能為null
*/
private Entry getEntry(T item){
Entry t = root;
int ret;
//從根節點開始遍歷
for (;t != null;){
ret = item.compareTo(t.item);
if (ret < 0)
t = t.left;
else if (ret > 0)
t = t.right;
else
return t;
}
return null;
}
/**
* 判斷是否存在該元素
* @param item 查找元素
* @return 結果
*/
public boolean contains(T item){
return getEntry(item) != null;
}
/**
* 刪除元素
* 刪除元素如果細分的話，可以分為4中：沒有子節點，只有左節點，只有右節點，有兩個子節點
* 1)沒有子節點這種情況比較簡單，直接刪除就可以了
* 2)只有左節點或右節點，這兩種情況處理方式是一致的，只是方向相反，所以在一起講了，
* 將刪除節點的父節點的左節點(右節點)指向刪除節點的子節點，將左節點(右節點)指向刪除節點的父節點
* 3)有兩個子節點，這種情況相對來說比較復雜一點：
* 找到刪除節點的前驅節點或后繼節點，然后將前驅或后繼節點的值賦給刪除節點，然后將前驅或后繼節點刪除。本質是刪除前驅或后繼節點
* 前驅節點的特點：
* 1)刪除的左子節點沒有右子節點，那么左子節點即為前驅節點
* 2)刪除節點的左子節點有右子節點，那么最右邊的最后一個節點即為前驅節點
* 后繼節點的特點：
* 與前驅節點剛好相反，總是右子節點，或則右子節點的最左子節點;例如：刪除節點為c ，那么前驅節點為 m，后繼節點為n
* a
* / \
* b c
* / \ / \
* d e f g
* / \ / \ / \ / \
* @param item 刪除元素 h i j k l m n o
* @return 刪除結果
*/
public boolean remove(T item){
//獲取刪除節點
Entry delEntry = getEntry(item);
if (delEntry == null) return false;
//刪除節點的父節點
Entry p = delEntry.parent;
size--;
//情況1：沒有子節點
if (delEntry.left == null && delEntry.right == null){
//刪除節點為根節點
if (delEntry == root){
root = null;
}else {//非根節點
//刪除的是父節點的左節點
if (delEntry == p.left){
p.left = null;
}else {//刪除右節點
p.right = null;
}
}
//情況2：刪除的節點只有左節點
}else if (delEntry.right == null){
Entry lc = delEntry.left;
//刪除的節點為根節點，將刪除節點的左節點設置成根節點
if (p == null) {
lc.parent = null;
root = lc;
} else {//非根節點
if (delEntry == p.left){//刪除左節點
p.left = lc;
}else {//刪除右節點
p.right = lc;
}
lc.parent = p;
}
//情況3：刪除節點只有右節點
}else if (delEntry.left == null){
Entry rc = delEntry.right;
//刪除根節點
if (p == null) {
rc.parent = null;
root = rc;
}else {//刪除非根節點
if (delEntry == p.left)
p.left = rc;
else
p.right = rc;
rc.parent = p;
}
//情況4：刪除節點有兩個子節點
}else {//有兩個節點,找到后繼節點，將值賦給刪除節點，然后將后繼節點刪除掉即可
Entry successor = successor(delEntry);//獲取到后繼節點
delEntry.item = successor.item;
//后繼節點為右子節點
if (delEntry.right == successor){
//右子節點有右子節點
if (successor.right != null) {
delEntry.right = successor.right;
successor.right.parent = delEntry;
}else {//右子節點沒有子節點
delEntry.right = null;
}
}else {//后繼節點必定是左節點
successor.parent.left = null;
}
return true;
}
//讓gc回收
delEntry.parent = null;
delEntry.left = null;
delEntry.right = null;
return true;
}
/**
* 查找后繼節點
* @param delEntry 刪除節點
* @return 后繼節點
*/
private Entry successor(Entry delEntry) {
Entry r = delEntry.right;//r節點必定不為空
while (r.left != null){
r = r.left;
}
return r;
}
public int size(){return size;}
public boolean isEmpty(){return size == 0;}
public void clear(){
clear(getRoot());
root = null;
}
private void clear(Entry e){
if (e != null){
clear(e.left);
e.left = null;
clear(e.right);
e.right = null;
}
}
static final class Entry>{
//保存的數據
private T item;
//左子樹
private Entry left;
//右子樹
private Entry right;
//父節點
private Entry parent;
Entry(T item,Entry parent){
this.item = item;
this.parent = parent;
}
}
}
測試代碼示例：
public static void main(String[] args) {
BinaryTree binaryTree = new BinaryTree<>();
//放數據
binaryTree.put(73);
binaryTree.put(22);
binaryTree.put(532);
binaryTree.put(62);
binaryTree.put(72);
binaryTree.put(243);
binaryTree.put(42);
binaryTree.put(3);
binaryTree.put(12);
binaryTree.put(52);
System.out.println("size： " + binaryTree.size());
binaryTree.put(52);
System.out.println("添加相同元素后的size： " + binaryTree.size());
//判斷數據是否存在
System.out.println("數據是否存在：" + binaryTree.contains(12));
//中序遍歷
System.out.print("中序遍歷結果： ");
binaryTree.midIterator(binaryTree.getRoot());
System.out.println();
//前序遍歷
System.out.print("前遍歷結果： ");
binaryTree.prevIterator(binaryTree.getRoot());
System.out.println();
//后序遍歷
System.out.print("后續遍歷結果： ");
binaryTree.subIterator(binaryTree.getRoot());
//刪除數據
System.out.println();
binaryTree.remove(62);
System.out.println("刪除數據后判斷是否存在：" + binaryTree.contains(62));
//清空二叉樹
binaryTree.clear();
System.out.print("清空數據后中序遍歷： ");
binaryTree.midIterator(binaryTree.getRoot());
}
測試結果：
size： 10
添加相同元素后的size： 10
數據是否存在：true
中序遍歷結果： 3 12 22 42 52 62 72 73 243 532
前遍歷結果： 73 22 3 12 62 42 52 72 532 243
后續遍歷結果： 12 3 52 42 72 62 22 243 532 73
刪除數據后判斷是否存在：false
總結
以上是生活随笔為你收集整理的java tree类子项的添加和删除_使用Java实现二叉树的添加，删除，获取以及遍历...的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 天启3内存选择指南：16GB以上，高速内
- 下一篇： DDR5内存解读：955处理器的性能提升