2. 程式人生 > >二叉排序樹的java實現

二叉排序樹的java實現

阿新 • • 發佈：2019-01-08

最近在看JDK原始碼時，發現JDK的J.U.C包下面的很多類都用到了二叉排序樹和紅黑樹，就想著這一塊還是考研的時候看了的，順便就在理論基礎上覆習加用Java做個實現。

二叉排序樹

先來說說這個二叉排序樹的定義和性質：

定義：二叉排序樹或者是一棵空樹，或者是具有下列性質的二叉樹：
（1）若左子樹不空，則左子樹上所有結點的鍵值均小於或等於它的根結點的鍵值；
（2）若右子樹不空，則右子樹上所有結點的鍵值均大於或等於它的根結點的鍵值；
（3）左、右子樹也分別為二叉排序樹；

下面的程式碼將用java實現，並且全部基於遞迴實現(非遞迴演算法複雜一些且效率高)。主要討論BST的如下操作：
查詢、插入、最大鍵、最小鍵、向上取整、向下取整、排名k的鍵、獲取鍵key的排名、刪除最大最小鍵、刪除操作、範圍查詢。

1.結點的資料結構的定義

下面是BST(後文都用BST表示二叉排序樹)中結點的資料結構的定義。

private class Node{
    private Key key;//鍵
    private Value value;//值
    private Node left, right;//指向子樹的連結:包括左子樹和右子樹.
    private int N;//以當前節點為根的子樹的結點總數
//構造器
    public Node(Key key, Value value, int N) {
        this.key = key;
        this.value = value
 
;
        this.N = N;
    }
}

此外，對於整個二叉查詢樹來說，有一個根節點，所以在BST類中定義了一個根結點：

private Node root;//二叉查詢樹的根節點

2. 計算二叉排序樹的size

思想: 根據我們資料結構Node中的定義，裡面有一個屬性 N 表示的就是以當前節點為根的子樹的結點總數。所以原始碼如下：

/**
 * 獲取整個二叉查詢樹的大小
 * @return
 */
public int size(){
    return size(root);
}
/**
 * 獲取某一個結點為根結點的二叉查詢樹的大小
 * @param x
 * @return
 

 */
private int size(Node x){
    if(x == null){
        return 0;
    } else {
        return x.N;
    }
}

3. 查詢和插入

在實現BST類的時候，BST繼承自Comparable介面的，實現compareTo()函式。因為我們知道二叉查詢樹的鍵值是有有序的，左子樹小於根節點，右子樹大於根節點。所以實現Comparable介面，那麼我們就很容易根據key找到插入的位置，而且對於BTS來說，插入的位置都是在葉子節點處。對於插入和查詢都是基於鍵值的比較。下面是原始碼：

/**
 * 查詢：通過key獲取value
 * @param key
 * @return
 */
public Value get(Key key){
    return get(root, key);
}
/**
 * 在以 x 為根節點的子樹中查詢並返回Key所對應的值,如果找不到就返回null
 * 遞迴實現
 * @param x
 * @param key
 * @return
 */
private Value get(Node x, Key key){
    if(x == null){
        return null;
    }
    //鍵值的比較
    int cmp = key.compareTo(x.key);
    if(cmp<0){
        return get(x.left, key);
    }else if(cmp>0){
        return get(x.right, key);
    } else{
        return x.value;
    }
}


/**
 * 插入：設定鍵值對
 * @param key
 * @param value
 */
public void put(Key key, Value value){
    root = put(root, key, value);
}
/**
 * key如果存在以 x 為根節點的子樹中,則更新它的值;
 * 否則將key與value鍵值對插入並建立一個新的結點.
 * @param x
 * @param key
 * @param value
 * @return
 */
private Node put(Node x, Key key, Value value){
    if( x==null ){
        x = new Node(key, value, 1);
        return x;
    }
    int cmp = key.compareTo(x.key);
    if(cmp<0){
        x.left = put(x.left, key, value);
    }else if(cmp>0){
        x.right = put(x.right, key, value);
    } else{
        x.value=value;//更新value的值
    }
    //設定根節點的N屬性
    x.N = size(x.left) + size(x.right) + 1;

    return x;
}

4. 最大鍵和最小鍵的實現

求BST中的最大鍵值和最小鍵值。根據BSt的特性，其實原理很簡單：最小值就是最左下邊的一個節點。最大鍵值就是最右下邊的結點。原始碼如下：

/**
 * 最小鍵
 */
public Key min(){
    return min(root).key;
}
/**
 * 返回結點x為root的二叉排序樹中最小key值的Node
 * @param x
 * @return 返回樹的最小key的結點
 */
private Node min(Node x){
    if(x.left == null){
        return x;
    }else{
        return min(x.left);
    }
}

/**
 * 最大鍵
 */
public Key max(){
    return max(root).key;
}
/**
 * 返回結點x為root的二叉排序樹中最大key值的Node
 * @param x
 * @return
 */
private Node max(Node x){
    if(x.right == null){//右子樹為空,則根節點是最大的
        return x;
    }else{
        return max(x.right);
    }
}

5. Key值向下取整和向上取整

所謂的向下取整和向上取整，就是給定鍵值key，向下取整的意思就是找出小於等於當前key的的Key值。向上取整的意思就是找出大於等於當前key的的Key值。實現也是基於Comparable介面的，具體的原始碼如下：

/**
 * key向下取整
 */
public Key floor(Key key){
    Node x = floor(root, key);
    if(x == null){
        return null;
    }
    return x.key;
}
/**
 * 以x 為根節點的二叉排序樹,查詢以引數key的向下取整的Node
 * @param x
 * @param key
 * @return
 */
private Node floor(Node x, Key key){
    if(x == null){
        return null;
    }

    int cmp = key.compareTo(x.key);
    if(cmp == 0){
        return x;
    }
    if(cmp < 0){//說明key引數小於x結點的key,所以向下取整結點在左子樹
        return floor(x.left, key);
    }
    //向下取整在右子樹,
    Node t = floor(x.right, key);
    if( t!= null){
        return t;
    }else {
        return x;
    }
}

/**
 * key向上取整
 */
public Key ceiling(Key key){
    Node x = ceiling(root, key);
    if(x == null){
        return null;
    }
    return x.key;
}
/**
 * 以x 為根節點的二叉排序樹,查詢以引數key的向上取整的Node
 * @param x
 * @param key
 * @return
 */
private Node ceiling(Node x, Key key){
    if(x == null){
        return null;
    }

    int cmp = key.compareTo(x.key);
    if(cmp == 0){
        return x;
    }
    if(cmp > 0){//說明key引數大於x結點的key,所以向上取整結點在右子樹
        return ceiling(x.right, key);
    }
    //向上取整在左子樹,
    Node t = ceiling(x.left, key);
    if( t!= null){
        return t;
    }else {
        return x;
    }
}

6. 獲取排名

我們經常可能會遇到需要獲取到排名為k的結點或則獲取某一個結點的排名，具體的實現也是基於Comparable介面的比較。

/**
 * 排名為k的結點的key
 */
public Key select(int k){
    Node x = select(root, k);
    if(x == null){
        return null;
    }
    return x.key;
}
/**
 * 返回排名為k的結點
 * @param x 根節點
 * @param k 排名
 * @return
 */
private Node select(Node x, int k){
    if(x == null){
        return null;
    }
    int t = size(x.left);//獲取左子樹的節點數
    if(t == k) {//左子樹節點數和k相同
        return x.left ;
    } else if( t+1 == k ){//左子樹結點數比k小一.
        return x;
    } else if(t>k){//排名k的結點在左子樹
        return select(x.left, k);
    }else{
        //排名k的在右子樹
        return select(x.right, k-t-1);
    }
}

/**
 * 返回給定鍵key的排名
 */
public int rank(Key key){
    return rank(root, key);
}
/**
 * 在二叉排序樹x上返回key的排名
 * @param x
 * @param key
 * @return
 */
private int rank(Node x, Key key){
    if(x == null){
        return 0;
    }
    int cmp = key.compareTo(x.key);
    if(cmp < 0){
        //key鍵小於root的key,所以key在左子樹中
        return rank(x.left, key);
    } else if(cmp>0){
        //key大於root的key,所以key在右子樹中
        return 1+size(x.left)+rank(x.right, key);
    } else{
        return size(x.left)+1;
    }
}

7. 刪除最小鍵值和最大鍵值的結點。

刪除二叉排序樹中的最大鍵值和最小鍵值的結點。這裡的思想和找到最大鍵值和最小鍵值結點幾乎一樣。只是這裡需要刪除該結點。由於最大鍵值和最小鍵值的位置的特殊性，都在葉子結點，所以這裡的刪除都是比較簡單的，不涉及到子樹的移動。原始碼如下：

/**
 * 刪除鍵值最小結點
 */
public void deleteMin(){
    //刪除root二叉查詢樹中的最小key的結點,其實也就是最左邊的結點
    root = deleteMin(root);
}
/**
 * 刪除鍵值最小結點
 * @param x
 * @return 返回新的二叉查詢樹的根節點
 */
private Node deleteMin(Node x){
    if(x.left == null){
        return x.right;//刪除根節點,這時返回的是新的二叉查詢樹的根節點
    }
    x.left = deleteMin(x.left);
    x.N = size(x.left) + size(x.right) + 1;
    return x;
}

/**
 * 刪除:鍵值最大結點
 */
public void deleteMax(){
    //刪除root二叉查詢樹中的最小key的結點,其實也就是最左邊的結點
    root = deleteMax(root);
}
/**
 * 刪除
 * @param x
 * @return 返回新的二叉查詢樹的根節點
 */
private Node deleteMax(Node x){
    if(x.right == null){//右子樹為空
        return x.left;//刪除根節點,這時返回的是新的二叉查詢樹的根節點
    }
    x.right = deleteMax(x.right);
    x.N = size(x.left) + size(x.right) + 1;
    return x;
}

8. 刪除任意結點

這裡的刪除指刪除二叉排序樹中任意位置的結點x，這個時候的結點x就有如下4種情況：
首先做個約定：待刪除的結點是結點x，其父結點是結點p，左子樹結點是l，右子樹結點是r，兄弟結點為b。其中NIL均為虛擬的null結點。(以上結點均在存在的情況下)
1、當待刪除結點x位於葉子結點位置：
這時直接刪除該葉子結點x，並將其父結點p指向該結點的域設定為null。
待刪除結點x位於葉子結點
這時只要刪除葉子結點x，然後將p的左結點指向NIL 結點：
刪除葉子結點之後

2、當待刪除結點x只有一個子結點時(該結點只有左子樹或則右子樹：即左子樹和右子樹中有一個為空)，這時將x結點的父結點p指向待刪除的結點x的指標直接指向x結點的唯一兒子結點(l或則是r)，然後刪除x結點就OK了。下圖只演示只有左子樹的時候，只有右子樹時候相同：
待刪除結點x只有一個左子結點時
這時只用刪除x結點，並將p結點左子樹指向x的子結點L. 如下圖：
刪除結點x之後

3、當待刪除結點x有兩個子結點的時候，這時候刪除待刪除結點x是最麻煩的。一個最經典的方案是：用刪除結點x的後繼結點填補它的位置。因為x有一個右子結點，因此它的後繼結點就是右子樹中的最小結點，這樣替換就能保證有序性，因為x.key和它的後繼之間不存在其他的鍵。我們用下面的4個步驟解決x替換為它後繼結點的任務：
1）將指向即將被刪除的結點x的連結儲存為t;

2）將x指向它的後繼結點min(x.right);

3）將x的右連結指向deleteMin(t.right) (這裡也就是右子樹刪除最小結點之後的)，也就是刪除最小結點後，其右子樹所有節點都仍大於x.key的右子二叉查詢樹。

4）將x的左連結(本為空)設為t.left(其下所有的鍵都小於被刪除的結點和它的後繼結點)。

原始碼如下：

/**
 * 刪除鍵key結點.
 * @param key
 */
public void delete(Key key){
    root = delete(root, key);
}
/**
 * 刪除以x為根結點的二叉查詢樹的key鍵的結點
 * @param x
 * @param key
 * @return 新的二叉查詢樹的根節點
 */
private Node delete(Node x, Key key){
    if( x == null ){
        return null;
    }
    int cmp = key.compareTo(x.key);
    if (cmp < 0) {
        x.left = delete(x.left, key);
    } else if(cmp > 0){
        x.right = delete(x.right, key);
    } else {//這時刪除根節點x
        if(x.left == null){
            return x.right;
        }
        if(x.right == null){
            return x.left;
        }
        //根節點有左右子樹
        Node t = x;
        //1. 先求出x的右子樹中最小鍵值的結點並讓x指向它.
        x = min(t.right);
        //2. 將t的右子樹刪除最小的結點之後的根節點返回
        x.right = deleteMin(t.right);
        //3. 將t的左子樹給x的左子樹
        x.left = t.left;
    }
    x.N = size(x.left) + size(x.right) + 1;
    return x;
}

整個實現的原始碼：

相關推薦

用java構建二叉排序樹，實現先序，中序和後序遍歷

1.基礎知識： 先上圖，舉個例子： 先選遍歷的規則：根節點----左子樹----右子樹      結果為12-9-76-35-22-16-48-46-40-90 中序遍歷的規則：左子樹--

最優二叉搜尋樹(JAVA實現）

演算法課上老師講的最優二叉搜尋樹，自己又查了些資料才看明白。這篇只記錄下自己用java的實現和自己的一些細節的理解。想學習整個演算法的可以參照 https://blog.csdn.net/zhangyifei521/article/details/50833792 package bes

資料結構之二叉查詢樹Java實現原始碼及註釋

二叉查詢樹（Binary Search Tree），（又：二叉搜尋樹，二叉排序樹）它或者是一棵空樹，或者是具有下列性質的二叉樹： 若它的左子樹不空，則左子樹上所有結點的值均小於它的根結點的值； 若它的右子樹不空，則右子樹上所有結點的值均大於它的根結點的值； 它的左、右子樹也分別為二叉排序樹。以下是樓主用jav

二叉搜尋樹Java實現（查詢、插入、刪除、遍歷）

1 class Node { 2 int key; 3 int value; 4 Node leftChild; 5 Node rightChild; 6 7 public Node(int key, int value) { 8

AVL樹-自平衡二叉查詢樹(Java實現)

      在電腦科學中，AVL樹是最先發明的自平衡二叉查詢樹。AVL樹得名於它的發明者 G.M. Adelson-Velsky 和 E.M. Landis，他們在 1962 年的論文 "An algorithm for the organization of inform

C語言二叉排序樹的實現

二叉排序樹是一種排序和查詢都很有用的特殊二叉樹。 二叉樹的性質： 1.      若它的左子樹不為空，則左子樹上所有結點的值均小於它的根節點的值。 2.      若它的右子樹不為空，則右子樹上所有節點的值均大於它的根節點的值。 3.      他的左右子樹也是二叉排序樹。

二叉排序樹C++實現

簡介 學習了演算法導論12章關於二叉排序樹的內容，自己利用C++實現了二叉排序樹的封裝。由此對二叉樹這種資料結構理解更加深刻了，對於遞迴在樹中的應用之廣更是有深切體會，例如遞迴建立，遞迴前，中，後序遍歷，返回樹高（個人最喜歡這個樹高遞迴函式，一句話返回樹高確實

二叉排序樹 python實現

class BTNode: def __init__(self, data, left, right): self.data = data

二叉排序樹程式碼實現

參照《大話資料結構》 313 ~328頁 #include <iostream> #include <stdio.h> #include <stdlib.h> #include <string.h> using names

資料結構與演算法—二叉排序樹(java)

前言 前面介紹學習的大多是線性表相關的內容，把指標搞懂後其實也沒有什麼難度。規則相對是簡單的。 再資料結構中樹、圖才是資料結構標誌性產物，(線性表大多都現成api可以使用),因為樹的難度相比線性表大一些並且樹的拓展性很強，你所知道的樹、二叉樹、二叉排序樹，AVL樹，線索二叉樹、紅黑樹、B數、線段

java實現平衡二叉排序樹增刪

在學習了普通二叉排序樹的演算法之後，我們發現了它的一些不足，如果我們的普通二叉樹在插入資料的時候造成樹的一側資料過多的話，就會使得查詢的時候效率大大降低，在極端情況下，我們插入一串有序的數，原本的二叉樹就會變成連結串列，例如，插入：1，2，3，4，5，6，結果就會變成下圖這樣： 這樣就

Java理解實現二叉排序樹

Java實現二叉排序樹 要求： 實現二叉排序樹，包括生成、插入，刪除，深度 對二叉排序樹進行先根、中根、和後根非遞迴遍歷 每次對樹的修改操作和遍歷操作的顯示結果都需要在螢幕上用樹的形狀表示出來 結點類： public class Node { public

二叉樹基礎操作 ，前中後序遍歷，求二叉樹高度，二叉搜尋樹（二叉排序樹）Java實現 程式碼集合

首先，定義一個樹類Tree.java public class Tree { public TreeNode root; } 定義樹節點類TreeNode.java public class TreeNode { public TreeNode(int

Java實現二叉排序樹的插入、查詢、刪除

import java.util.Random; /** * 二叉排序樹（又稱二叉查詢樹） * （1）可以是一顆空樹 * （2）若左子樹不空，則左子樹上所有的結點的值均小於她的根節點的值 * （3）若右子樹不空，則右子樹上所有的結點的值均大於她的根節點的值

Java實現二叉排序樹

定義: 二叉排序樹或者是一棵空樹，或者是具有下列性質的二叉樹： （1）若左子樹不空，則左子樹上所有結點的值均小於它的根結點的值； （2）若右子樹不空，則右子樹上所有結點的值均大於或等於它的根結點的值； （3）左、右子樹也分別為二叉排序樹； （4）沒有鍵值相等的節

二叉排序樹（Binary Sort Tree）查詢、插入、刪除 Java實現

順序儲存的插入和刪除可以通過在表末端插入和刪除元素同最後一個元素互換來保持高效率，但是無序造成查詢的效率很低。 如果查詢的資料表是有序線性表，並且是順序儲存的，查詢可以折半、插值、斐波那契等查詢演算法來實現，但是因為有序在插入和刪除操作上，就需要耗費大量時間。 二叉排序樹可

二叉排序樹，java實現（知識簡單的實現，持續完善更新）

定義： 二叉排序樹就是左子樹都比節點小，右子樹都比節點大。簡單的排序二叉樹實現。 程式碼： package com.wzq.data_structure; public class Bina

二叉排序樹的java實現

最近在看JDK原始碼時，發現JDK的J.U.C包下面的很多類都用到了二叉排序樹和紅黑樹，就想著這一塊還是考研的時候看了的，順便就在理論基礎上覆習加用Java做個實現。 二叉排序樹 先來說說這個二叉排序樹的定義和性質： 定義：二叉排序樹或者

Java實現動態表查詢--二叉排序樹

package yao.demo; import java.util.*; //二叉樹的定義 class BinaryTree{ int val; BinaryTree left; BinaryTree right; public BinaryTree(int val){ this.val = v

二叉排序樹建立(JAVA實現)

      最近看了一下二叉排序樹的建立，自己寫了一段程式碼，用來建立二叉排序樹,給定一個數組，對這個陣列中的數字進行建立二叉排序樹。分兩種情況：      1  陣列中的數字是隨機的，也就是說沒有順序 eg : int  a [ ] = {3,1,2,5,0,7,9,8}