資料結構-Tree
鄭重說明:儘管網路上有很多的資源可以借鑑,但是筆者還是需要很多的幫助才能寫出這些總結筆記
1️⃣首先也是最重要的慕課網給了我巨大的幫助,自從第一次開啟慕課網以後,從此就在我心裡播下了一顆學習的種子;
2️⃣要特別鳴謝慕課網的liuyubobobo老師,從他那裡我"偷了"許多的想法放到這篇筆記裡邊;
3️⃣本文內容直接出自liuyubobobo老師的課程<玩轉資料結構 從入門到進階>
4️⃣清醒時做事,糊塗時學習,祝大家都能夢想成真;
一 為什麼要研究樹結構。
樹結構是計算機世界中非常高效的一種資料結構，也是應用非常廣泛的資料結構；
樹結構圖示.png
2⃣️ 樹結構的應用場景。
計算機中檔案目錄結構圖示.png
公司組織架構圖示.png
以上這些應用場景都是樹型結構的使用場景，樹結構的特點就是層次清晰，高效。
3⃣️ 樹結構常用的型別都有什麼？
二分搜尋樹 平衡二叉樹 線段樹 Trie等都是很常用的樹型資料結構。
二 二分搜尋樹基礎
二分搜尋樹是樹型結構中的一種，要了解二分搜尋樹需要先說一下二叉樹結構；
二叉樹圖示.png
2⃣️ 二叉樹的組成圖示。
二叉樹的組成圖示.png
根節點：二叉樹具有一個唯一的根節點；
左右節點：二叉樹每個節點最多有兩個節點(左節點和右節點);
父節點：二叉樹每個節點最多有一個父節點；
3⃣️ 二叉樹具有天然遞迴結構。
二叉樹具有天然遞迴結構.png
為什麼說二叉樹具有天然的遞迴結構呢？因為對於一個父節點來說，下邊的每個節點(左節點和右節點)又是一個新的二叉樹；
4⃣️ 二叉樹不一定都是滿的。
滿二叉樹圖示.png
非滿二叉樹圖示1.png
非滿二叉樹圖示2.png
非滿二叉樹圖示3.png
最特殊的二叉樹.png
5⃣️ 二分搜尋樹
在介紹完二叉樹以後我們來看一下二分搜尋樹；
二分搜尋樹圖示.png
二分搜尋樹概念圖示.png
二分搜尋樹是二叉樹的一種，二分搜尋樹的特點是每個節點的值都大於左子樹的所有節點，每個節點的值都小於右子樹中所有節點的值，然後每個父節點下邊的子樹也是一個二分搜尋樹，同時二分搜尋樹每個節點的值必須滿足可比較性；
二分搜尋樹既然是二叉樹的一種，也就意味著二分搜尋樹也不一定都是滿的，更多的時候應該是不滿的情況；
不規則的二分搜尋樹.png
三 程式碼實現一個二分搜尋樹
package com.mufeng.binarySearchTree;
/**
* Created by wb-yxk397023 on 2018/6/30.
*/
public class BST<E extends Comparable<E>> {
private class Node{
public E e;
public Node left, right;
public Node(E e){
this.e = e;
this.left = null;
this.right = null;
}
}
private Node root;
private int size;
public BST(){
root = null;
size = 0;
}
public int getSize(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
}
四 向二分搜尋樹中新增元素
1⃣️ 新增新元素圖示
一個空的樹
新新增的元素將會成為根
繼續進行新增操作
通過對比找到位置
新增了多個元素的樹
繼續新增新元素
通過對比找到具體的位置
繼續新增元素
通過對比找到位置
補充：我們的新增操作是不包含重複操作的；但是如果想要包含重複元素的只需要改變一個對比的條件就可以了，比如左子樹可以放置小於或者等於根節點的元素或者右子樹中放置大於或者等於根的元素即可；
2⃣️ 程式碼實現
/**
* 向二分搜尋樹中新增新的元素e
* @param e
*/
public void add(E e){
if (root == null){
root = new Node(e);
size++;
}else {
add(root, e);
}
}
/**
* 向以node為根的二分搜尋樹中插入元素e，遞迴演算法
* @param node
* @param e
*/
public void add(Node node, E e){
// 遞迴的終止條件
if (e.equals(node.e)){
return;
}else if (e.compareTo(node.e) < 0 && node.left == null){
node.left = new Node(e);
size++;
return;
}else if (e.compareTo(node.e) > 0 && node.right == null){
node.right = new Node(e);
size++;
return;
}
// 遞迴呼叫
if (e.compareTo(node.e) < 0){
add(node.left, e);
}
add(node.right, e);
}
由於二分搜尋樹的結構非常適合使用遞迴的操作，所以我們的新增操作直接使用遞迴的方式進行實現，但是上邊的程式碼遞迴的終止條件顯得有些臃腫，所以我們需要對新增操作的程式碼邏輯進行優化；
/**
* 向二分搜尋樹中新增新的元素e
* @param e
*/
public void add(E e){
root = add(root, e);
}
/**
* 向以node為根的二分搜尋樹中插入元素e，遞迴演算法
* 返回插入新節點後二分搜尋樹的根
* @param node
* @param e
* @return
*/
public Node add(Node node, E e){
// 遞迴的終止條件
if (node == null){
size++;
return new Node(e);
}
// 遞迴呼叫
if (e.compareTo(node.e) < 0){
node.left = add(node.left, e);
}else if (e.compareTo(node.e) > 0){
node.right = add(node.right, e);
}
return node;
}
五 二分搜尋樹的查詢操作
如果大家理解了二分搜尋樹的新增操作，那麼就可以很容易的理解二分搜尋樹的查詢操作；
/**
* 二分搜尋樹中是否包含元素e
* @param e
* @return
*/
public boolean contains(E e){
return contains(root, e);
}
/**
* 查詢以node為節點的二分搜尋樹中是否包含元素e
* @param node
* @param e
* @return
*/
private boolean contains(Node node, E e){
if (node == null){
return false;
}else if (e.compareTo(node.e) == 0){
return true;
}else if (e.compareTo(node.e) < 0){
return contains(node.left, e);
}
return contains(node.right, e);
}
六 二分搜尋樹的遍歷
1⃣️ 前序遍歷
二叉樹圖示
二分搜尋樹模型圖
/**
* 二叉樹的前序遍歷
*/
public void preOrder(){
preOrder(root);
}
/**
* 前序遍歷以node為根的二分搜尋樹，遞迴演算法
* @param node
*/
private void preOrder(Node node){
if (node == null){
return;
}
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
}
重寫toString
/**
* 以前序遍歷的方式重寫toString
* @return
*/
@Override
public String toString(){
StringBuilder res = new StringBuilder();
generateBSTString(root, 0, res);
return res.toString();
}
/**
* 生成以node為根節點，深度為depth的描述二叉樹的字串
* @param node
* @param depth
* @param res
*/
private void generateBSTString(Node node, int depth, StringBuilder res){
if (node == null){
res.append(generateDepthString(depth) + "null\n");
return;
}
res.append(generateDepthString(depth) + node.e + "\n");
generateBSTString(node.left, depth + 1, res);
generateBSTString(node.right, depth + 1, res);
}
private String generateDepthString(int depth){
StringBuilder res = new StringBuilder();
for (int i = 0; i < depth; i++){
res.append("--");
}
return res.toString();
}
2⃣️ 中序遍歷
中序遍歷圖示
/**
* 二分搜尋樹的中序遍歷
*/
public void inOrder(){
inOrder(root);
}
/**
* 中序遍歷以node為根的二分搜尋樹，遞迴演算法
* @param node
*/
private void inOrder(Node node){
if (node == null){
return;
}
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right);
}
3⃣️ 後序遍歷
後序遍歷的原理在遍歷當前節點之前先遍歷左右子樹，然後在遍歷當前節，得到的結果就是後序遍歷的結果；
後續遍歷的適用場景：比如釋放二分搜尋樹的記憶體這樣的操作需要用到後序遍歷，因為要釋放記憶體肯定需要先釋放左右子樹在釋放當前節點；
/**
* 二分搜尋樹的後序遍歷
*/
public void postOrder(){
postOrder(root);
}
/**
* 後續遍歷以node為根的二分搜尋樹，遞迴演算法
* @param node
*/
private void postOrder(Node node){
if (node == null){
return;
}
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}
4⃣️ 深度優先遍歷
非遞迴實現二分搜尋樹的前序遍歷
// 二分搜尋樹的非遞迴前序遍歷
public void preOrderNR(){
if(root == null)
return;
Stack<Node> stack = new Stack<>();
stack.push(root);
while(!stack.isEmpty()){
Node cur = stack.pop();
System.out.println(cur.e);
if(cur.right != null)
stack.push(cur.right);
if(cur.left != null)
stack.push(cur.left);
}
}
在二分搜尋樹這樣的結構中，使用遞迴可以很簡單的實現功能，但是非遞迴的話實現起來就會有一點困難，當使用非遞迴的方式實現前序遍歷的話，需要藉助棧來實現，這樣的遍歷方式也被稱為深度優先遍歷；
5⃣️ 廣度優先遍歷
// 二分搜尋樹的層序遍歷
public void levelOrder(){
if(root == null)
return;
Queue<Node> q = new LinkedList<>();
q.add(root);
while(!q.isEmpty()){
Node cur = q.remove();
System.out.println(cur.e);
if(cur.left != null)
q.add(cur.left);
if(cur.right != null)
q.add(cur.right);
}
}
二分搜尋樹的層序遍歷也叫做廣度優先遍歷；深度優先遍歷以及廣度優先遍歷更多的是應用與演算法中的，所以這裡不做深入的說明；
七 二分搜尋樹中的刪除操作
1⃣️ 刪除二分搜尋樹中的最大值和最小值
一個完整的二分搜尋樹
以此圖為例，如果要刪除這個二分搜尋樹的最小以及最大節點，我們需要從根節點開始執行查詢操作，如果要刪除最小值的話，就需要一直向左進行查詢，直到找到最小值即可，刪除最大值也是一樣的操作；
刪除後的二分搜尋樹
此處需要注意的是，如果我們在進行刪除此樹的最小值的話，則16將會被刪除，22將作為此樹根節點28的左子樹的根節點。
需要注意的是，刪除操作的前提是需要先找到待刪除的樹的最小值與最大值，所以我們需要先實現這個邏輯才能進行刪除的操作；
/**
* 尋找二分搜尋樹的最小元素
* @return
*/
public E minimum(){
if(size == 0)
throw new IllegalArgumentException("BST is empty");
Node miniNode = minimum(root);
return miniNode.e;
}
/**
* 返回以node為根的二分搜尋樹的最小值所在的節點
* @param node
* @return
*/
private Node minimum(Node node){
if (node.left == null){
return node;
}
return minimum(node.left);
}
/**
* 尋找二分搜尋樹的最大元素
* @return
*/
public E maxmum(){
if (size == 0){
throw new IllegalArgumentException("BST is empty");
}
Node maxNode = maxmum(root);
return maxNode.e;
}
/**
* 返回以node為根的二分搜尋樹的最大值所在的節點
* @param node
* @return
*/
private Node maxmum(Node node){
if (node.right == null){
return node;
}
return maxmum(node.right);
}
待刪除最小節點的二分搜尋樹
刪除最小值後的二分搜尋樹
刪除最小值後的二分搜尋樹
刪除22節點後的二分搜尋樹
對於刪除二分搜尋樹中的最大節點也是一樣的操作，這裡就不再進行圖示了。
/**
* 從二分搜尋樹中刪除最小值所在節點, 返回最小值
* @return
*/
public E removemin(){
E ret = minimum();
root = removemin(root);
return ret;
}
/**
* 刪除掉以node為根的二分搜尋樹中的最小節點
* 返回刪除節點後新的二分搜尋樹的根
* @param node
* @return
*/
private Node removemin(Node node){
if (node.left == null){
Node rightNode = node.right;
node.right = null;
size--;
return rightNode;
}
node.left = removemin(node.left);
return node;
}
/**
* 從二分搜尋樹中刪除最大值所在節點，返回最大值
* @return
*/
public E removeMax(){
E ret = maxmum();
root = removeMax(root);
return ret;
}
/**
* 刪除掉以node為根的二分搜尋樹中的最大節點
* 返回刪除節點後新的二分搜尋樹的根
* @param node
* @return
*/
private Node removeMax(Node node){
if (node.right == null){
Node leftNode = node.left;
node.left = null;
size--;
return leftNode;
}
node.left = removeMax(node.right);
return node;
}
2⃣️ 刪除二分搜尋樹中的任意元素
刪除二分搜尋樹中任意元素分以下幾種情況：
刪除只有左子樹的元素
刪除只有右子樹的元素
刪除有左右子樹的元素
第一種情況和第二種情況都比較簡單，和我們刪除最小值和最大值的邏輯基本一樣，但是第三種情況則相對複雜一些，這裡我們採取一種後繼的做法，請看圖示
刪除任意元素1
刪除任意元素2
刪除任意元素3
刪除任意元素4
刪除任意元素5
刪除任意元素6
/**
* 從二分搜尋樹中刪除元素為e的節點
* @param e
*/
public void remove(E e){
root = remove(root, e);
}
/**
* 刪除掉以node為根的二分搜尋樹中值為e的節點, 遞迴演算法
* 返回刪除節點後新的二分搜尋樹的根
* @param node
* @param e
* @return
*/
private Node remove(Node node, E e){
if( node == null )
return null;
if( e.compareTo(node.e) < 0 ){
node.left = remove(node.left , e);
return node;
}
else if(e.compareTo(node.e) > 0 ){
node.right = remove(node.right, e);
return node;
}
else{ // e.compareTo(node.e) == 0
// 待刪除節點左子樹為空的情況
if(node.left == null){
removeMin(node);
}
// 待刪除節點右子樹為空的情況
if(node.right == null){
removeMax(node);
}
// 待刪除節點左右子樹均不為空的情況
// 找到比待刪除節點大的最小節點, 即待刪除節點右子樹的最小節點
// 用這個節點頂替待刪除節點的位置
Node successor = minimum(node.right);
successor.right = removeMin(node.right);
successor.left = node.left;
node.left = node.right = null;
return successor;
}
}
八 二分搜尋樹相關程式碼
package com.mufeng.binarySearchTree;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
/**
* Created by wb-yxk397023 on 2018/6/30.
*/
public class BST<E extends Comparable<E>> {
private class Node{
public E e;
public Node left, right;
public Node(E e){
this.e = e;
this.left = null;
this.right = null;
}
}
private Node root;
private int size;
public BST(){
root = null;
size = 0;
}
public int size(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
/**
* 向二分搜尋樹中新增新的元素e
* @param e
*/
public void add(E e){
root = add(root, e);
}
/**
* 向以node為根的二分搜尋樹中插入元素e，遞迴演算法
* 返回插入新節點後二分搜尋樹的根
* @param node
* @param e
* @return
*/
public Node add(Node node, E e){
// 遞迴的終止條件
if (node == null){
size++;
return new Node(e);
}
// 遞迴呼叫
if (e.compareTo(node.e) < 0){
node.left = add(node.left, e);
}else if (e.compareTo(node.e) > 0){
node.right = add(node.right, e);
}
return node;
}
/**
* 二分搜尋樹中是否包含元素e
* @param e
* @return
*/
public boolean contains(E e){
return contains(root, e);
}
/**
* 查詢以node為節點的二分搜尋樹中是否包含元素e
* @param node
* @param e
* @return
*/
private boolean contains(Node node, E e){
if (node == null){
return false;
}else if (e.compareTo(node.e) == 0){
return true;
}else if (e.compareTo(node.e) < 0){
return contains(node.left, e);
}
return contains(node.right, e);
}
/**
* 二分搜尋樹的前序遍歷
*/
public void preOrder(){
preOrder(root);
}
/**
* 前序遍歷以node為根的二分搜尋樹，遞迴演算法
* @param node
*/
private void preOrder(Node node){
if (node == null){
return;
}
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
}
/**
* 二分搜尋樹的非遞迴前序遍歷
*/
public void preOrderNR(){
Stack<Node> stack = new Stack<>();
stack.push(root);
while(!stack.isEmpty()){
Node cur = stack.pop();
System.out.println(cur.e);
if(cur.right != null)
stack.push(cur.right);
if(cur.left != null)
stack.push(cur.left);
}
}
/**
* 二分搜尋樹的中序遍歷
*/
public void inOrder(){
inOrder(root);
}
/**
* 中序遍歷以node為根的二分搜尋樹，遞迴演算法
* @param node
*/
private void inOrder(Node node){
if (node == null){
return;
}
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right);
}
/**
* 二分搜尋樹的後序遍歷
*/
public void postOrder(){
postOrder(root);
}
/**
* 尋找二分搜尋樹的最小元素
* @return
*/
public E minimum(){
if(size == 0)
throw new IllegalArgumentException("BST is empty");
Node miniNode = minimum(root);
return miniNode.e;
}
/**
* 返回以node為根的二分搜尋樹的最小值所在的節點
* @param node
* @return
*/
private Node minimum(Node node){
if (node.left == null){
return node;
}
return minimum(node.left);
}
/**
* 尋找二分搜尋樹的最大元素
* @return
*/
public E maxmum(){
if (size == 0){
throw new IllegalArgumentException("BST is empty");
}
Node maxNode = maxmum(root);
return maxNode.e;
}
/**
* 返回以node為根的二分搜尋樹的最大值所在的節點
* @param node
* @return
*/
private Node maxmum(Node node){
if (node.right == null){
return node;
}
return maxmum(node.right);
}
/**
* 從二分搜尋樹中刪除最小值所在節點, 返回最小值
* @return
*/
public E removemin(){
E ret = minimum();
root = removeMin(root);
return ret;
}
/**
* 刪除掉以node為根的二分搜尋樹中的最小節點
* 返回刪除節點後新的二分搜尋樹的根
* @param node
* @return
*/
private Node removeMin(Node node){
if (node.left == null){
Node rightNode = node.right;
node.right = null;
size--;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
/**
* 從二分搜尋樹中刪除最大值所在節點，返回最大值
* @return
*/
public E removeMax(){
E ret = maxmum();
root = removeMax(root);
return ret;
}
/**
* 刪除掉以node為根的二分搜尋樹中的最大節點
* 返回刪除節點後新的二分搜尋樹的根
* @param node
* @return
*/
private Node removeMax(Node node){
if (node.right == null){
Node leftNode = node.left;
node.left = null;
size--;
return leftNode;
}
node.left = removeMax(node.right);
return node;
}
/**
* 後續遍歷以node為根的二分搜尋樹，遞迴演算法
* @param node
*/
private void postOrder(Node node){
if (node == null){
return;
}
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}
/**
* 二分搜尋樹的層序遍歷
*/
public void levelOrder(){
Queue<Node> q = new LinkedList<>();
q.add(root);
while(!q.isEmpty()){
Node cur = q.remove();
System.out.println(cur.e);
if(cur.left != null)
q.add(cur.left);
if(cur.right != null)
q.add(cur.right);
}
}
/**
* 從二分搜尋樹中刪除元素為e的節點
* @param e
*/
public void remove(E e){
root = remove(root, e);
}
/**
* 刪除掉以node為根的二分搜尋樹中值為e的節點, 遞迴演算法
* 返回刪除節點後新的二分搜尋樹的根
* @param node
* @param e
* @return
*/
private Node remove(Node node, E e){
if( node == null )
return null;
if( e.compareTo(node.e) < 0 ){
node.left = remove(node.left , e);
return node;
}
else if(e.compareTo(node.e) > 0 ){
node.right = remove(node.right, e);
return node;
}
else{ // e.compareTo(node.e) == 0
// 待刪除節點左子樹為空的情況
if(node.left == null){
removeMin(node);
}
// 待刪除節點右子樹為空的情況
if(node.right == null){
removeMax(node);
}
// 待刪除節點左右子樹均不為空的情況
// 找到比待刪除節點大的最小節點, 即待刪除節點右子樹的最小節點
// 用這個節點頂替待刪除節點的位置
Node successor = minimum(node.right);
successor.right = removeMin(node.right);
successor.left = node.left;
node.left = node.right = null;
return successor;
}
}
/**
* 以前序遍歷的方式重寫toString
* @return
*/
@Override
public String toString(){
StringBuilder res = new StringBuilder();
generateBSTString(root, 0, res);
return res.toString();
}
/**
* 生成以node為根節點，深度為depth的描述二叉樹的字串
* @param node
* @param depth
* @param res
*/
private void generateBSTString(Node node, int depth, StringBuilder res){
if (node == null){
res.append(generateDepthString(depth) + "null\n");
return;
}
res.append(generateDepthString(depth) + node.e + "\n");
generateBSTString(node.left, depth + 1, res);
generateBSTString(node.right, depth + 1, res);
}
private String generateDepthString(int depth){
StringBuilder res = new StringBuilder();
for (int i = 0; i < depth; i++){
res.append("--");
}
return res.toString();
}
}
相關文章
- 『資料結構』樹(Tree)資料結構
- 資料結構：Expression Tree資料結構Express
- js資料結構--樹(tree)JS資料結構
- 【資料結構】K-D Tree資料結構
- 詳解資料庫儲存的資料結構LSM Tree資料庫資料結構
- 資料的儲存結構淺析LSM-Tree和B-tree
- 前端樹形Tree資料結構使用-🤸🏻♂️各種姿勢總結前端資料結構
- B-tree和B+tree 一種為資料查詢而生的結構
- 資料結構分析及其實現(Stack、Queue、Tree、LinkedList)資料結構
- 區塊鏈中的資料結構之 Merkle Tree區塊鏈資料結構
- 每週一練 之 資料結構與演算法（Tree）資料結構演算法
- [譯文] 初學者應該瞭解的資料結構： Tree資料結構
- 構建layui的tree節點資料UI
- 結構化資料、半結構化資料和非結構化資料
- 【資料結構篇】認識資料結構資料結構
- 資料結構小白系列之資料結構概述資料結構
- LayUI—tree樹形結構的使用UI
- 資料結構？資料結構
- 資料結構資料結構
- 資料結構與演算法-資料結構（棧）資料結構演算法
- 【PHP資料結構】PHP資料結構及演算法總結PHP資料結構演算法
- php tree類的使用（樹形結構）PHP
- oracle的B-tree索引結構分析Oracle索引
- 轉儲B*Tree索引的分枝結構索引
- 資料結構-棧資料結構
- 資料結構-堆資料結構
- 資料結構-集合資料結構
- 資料結構 - 字串資料結構字串
- 資料結構——列表資料結構
- Redis 資料結構Redis資料結構
- 資料結構——樹資料結構
- Redis資料結構Redis資料結構
- 資料結構-樹資料結構
- Java資料結構Java資料結構
- 資料結構---串資料結構
- 資料結構|前言資料結構
- 資料結構——堆資料結構
- spacy資料結構資料結構