2. 程式人生 > 其它 >Java--演算法--二叉排序樹(BST)

Java--演算法--二叉排序樹(BST)

阿新 • • 發佈：2021-07-16
  1. 二叉排序樹的基本介紹：

  2. 二叉排序樹的遍歷和建立

    2. package com.model.tree;

/**
 * @Description:測試類
 * @Author: 張紫韓
 * @Crete 2021/7/16 9:34
 * 二叉排序樹的建立與遍歷(Binary Sort tree)
 */
public class TreeDemo08 {
    public static void main(String[] args) {
        BinarySortTree sortTree = new BinarySortTree();
        SortNode root 
       
      = new SortNode(0);
        SortNode node1 = new SortNode(1);
        SortNode node2 = new SortNode(2);
        SortNode node3 = new SortNode(3);
        sortTree.setRoot(root);
        sortTree.add(node1);
        sortTree.add(node2);
        sortTree.add(node3);
        sortTree.infixOrder();
    }

}

       
      class BinarySortTree{

    private SortNode root;
    public void add(SortNode node){
        if (root!=null) {
            root.add(node);
        }else {
            root=node;
        }
    }
    public void infixOrder(){
        if (root!=null) {
            root.infixOrder();
        }else {
            System.out.println(
       
      "樹為空");
        }
    }
    public SortNode getRoot() {
        return root;
    }

    public void setRoot(SortNode root) {
        this.root = root;
    }

}
class SortNode{
    private int value;
    private SortNode left;
    private SortNode right;

    public int getValue() {
        return value;
    }
//    新增
    public void add(SortNode node){
        if (node==null){
            return;
        }
        if (this.value< node.value){
            if (this.right==null){
                this.right= node;
            }else {
                this.right.add(node);
            }
       }else {
           if (this.left==null){
               this.left=node;
           }else {
               this.left.add(node);
           }
       }
    }

//    中序遍歷
    public void infixOrder(){
        if (this==null){
            return;
        }else {
            if (this.left!=null){
                this.left.infixOrder();
            }
            System.out.println(this.toString());
            if (this.right!=null){
                this.right.infixOrder();
            }
        }
    }

    @Override
    public String toString() {
        return "SortNode{" +
                "value=" + value +
                '}';
    }

    public void setValue(int value) {
        this.value = value;
    }

    public SortNode getLeft() {
        return left;
    }

    public void setLeft(SortNode left) {
        this.left = left;
    }

    public SortNode getRight() {
        return right;
    }

    public void setRight(SortNode right) {
        this.right = right;
    }

    public SortNode() {
    }

    public SortNode(int value) {
        this.value = value;
    }
}
  3. 二叉排序樹的節點刪除：
    5. package com.model.tree;

/**
 * @Description:測試類
 * @Author: 張紫韓
 * @Crete 2021/7/16 9:34
 * 二叉排序樹的建立與遍歷(Binary Sort tree)
 */
public class TreeDemo08 {
    public static void main(String[] args) {
        BinarySortTree sortTree = new BinarySortTree();
//        SortNode root = new SortNode(0);
//        SortNode node1 = new SortNode(1);
//        SortNode node2 = new SortNode(2);
//        SortNode node3 = new SortNode(3);
//        SortNode node4 = new SortNode(-1);
//        SortNode node5 = new SortNode(-2);
//        sortTree.setRoot(root);
//        sortTree.add(node2);
//        sortTree.add(node1);
//        sortTree.add(node3);
//        sortTree.add(node4);
//        sortTree.add(node5);
//        sortTree.infixOrder();
//        sortTree.delete(1);
//        System.out.println("-----------------------");
//        sortTree.infixOrder();
        int[] array={7,3,10,12,5,1,9,2};
        for (int i = 0; i < array.length; i++) {
            sortTree.add(new SortNode(array[i]));
        }
        sortTree.infixOrder();
        System.out.println("------------------");
        sortTree.delete(2);
        sortTree.infixOrder();



    }

}

class BinarySortTree {

    private SortNode root;

    public void add(SortNode node) {
        if (root != null) {
            root.add(node);
        } else {
            root = node;
        }
    }

    public void infixOrder() {
        if (root != null) {
            root.infixOrder();
        } else {
            System.out.println("樹為空");
        }
    }

    public SortNode searchParent(int value) {
        if (root == null) {
            return null;
        } else {
            if (root.getValue() == value) {
                return null;
            } else {
                return root.searchParent(value);
            }
        }
    }

    public SortNode search(int value) {
        if (root == null) {
            return null;
        } else {
            if (root.getValue() == value) {
                return root;
            } else {
                return root.search(value);
            }
        }
    }
    public void delete(int value){
        if (root==null){
            System.out.println("樹為空，無法進行刪除");
            return;
        }else {
            SortNode delNode = search(value);
            SortNode parentNode = searchParent(value);
            if (delNode!=null&&parentNode!=null){//要刪除的節點和他的父節點都存在
                if (parentNode.getLeft()==delNode){//要刪除的節點為父節點的左節點
                    if (delNode.getLeft()==null&&delNode.getRight()==null){//要刪除節點的為葉子節點
                        parentNode.setLeft(null);
                    }else if (delNode.getLeft()==null&&delNode.getRight()!=null) {
                        parentNode.setLeft(delNode.getRight());
                    }else if (delNode.getLeft()!=null&&delNode.getRight()==null){
                        parentNode.setLeft(delNode.getLeft());
                    }else {//左右子樹都不為空，從右子樹中找到最小的一個放在要刪除的節點行即可
                        int temp = delNode.getRight().searchMin().getValue();
                        delete(temp);
                        delNode.setValue(temp);
                    }
                }else {//要刪除的節點為父節點的右節點
                    if (delNode.getLeft()==null&&delNode.getRight()==null){//要刪除節點的為葉子節點
                        parentNode.setRight(null);
                    }else if (delNode.getLeft()==null&&delNode.getRight()!=null) {
                        parentNode.setRight(delNode.getRight());
                    }else if (delNode.getLeft()!=null&&delNode.getRight()==null){
                        parentNode.setRight(delNode.getLeft());
                    }else {//左右子樹都不為空，從右子樹中找到最小的一個放在要刪除的節點行即可
                        int temp = delNode.getRight().searchMin().getValue();
                        delete(temp);
                        delNode.setValue(temp);
                    }
                }
            }else if (parentNode==null&&delNode==root){//要刪除的節點存在，他的父節點不存在，接為 root節點
                if (delNode.getLeft()==null&&delNode.getRight()==null){//要刪除節點的為葉子節點
                    root=null;
                }else if (delNode.getLeft()==null&&delNode.getRight()!=null) {
                    root=delNode.getRight();
                }else if (delNode.getLeft()!=null&&delNode.getRight()==null){
                  root=delNode.getLeft();
                }else {//左右子樹都不為空，從右子樹中找到最小的一個放在要刪除的節點行即可
                    int temp = delNode.getRight().searchMin().getValue();
                    delete(temp);
                    root.setValue(temp);
                }
            }else {//兩個節點都為空
                System.out.println("沒有此節點，無法刪除");
                return;
            }
        }
    }

    public SortNode getRoot() {
        return root;
    }

    public void setRoot(SortNode root) {
        this.root = root;
    }

}

class SortNode {
    private int value;
    private SortNode left;
    private SortNode right;

    public void delete(int value){


    }
//    找到樹的最小值
    public SortNode searchMin(){
        if (this.left==null){
            return this;
        }else {
           return this.left.searchMin();
        }
    }

    //    查詢某個節點的父節點
    public SortNode searchParent(int value) {
        if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
            return this;
        } else {
            if (this.value <= value && this.right != null) {
                return this.right.searchParent(value);
            } else if (this.value > value && this.left != null) {
                return this.left.searchParent(value);
            } else {
                return null;
            }
        }
    }
    public SortNode searchParent02(int value) {
        if (this.left != null) {
            if (this.left.value == value) {
                return this;
            } else {
                if (this.value > value) {
                    return this.left.search(value);
                } else {
                    return null;
                }
            }
        } else if (this.right != null) {
            if (this.right.value == value) {
                return this;
            } else {
                if (this.value <= value) {
                    return this.right.search(value);
                } else {
                    return null;
                }
            }
        } else {
            return null;
        }
    }

    //    通過 某個值查詢某個節點
    public SortNode search(int value) {
        if (value == this.value) {
            return this;
        } else {
            if (this.value > value) {
                if (this.left == null) {
                    return null;
                } else {
                    return this.left.search(value);
                }
            } else {
                if (this.right == null) {
                    return null;
                } else {
                    return this.right.search(value);
                }
            }
        }
    }

    //    新增
    public void add(SortNode node) {
        if (node == null) {
            return;
        }
        if (this.value < node.value) {
            if (this.right == null) {
                this.right = node;
            } else {
                this.right.add(node);
            }
        } else {
            if (this.left == null) {
                this.left = node;
            } else {
                this.left.add(node);
            }
        }
    }

    //    中序遍歷
    public void infixOrder() {
        if (this == null) {
            return;
        } else {
            if (this.left != null) {
                this.left.infixOrder();
            }
            System.out.println(this.toString());
            if (this.right != null) {
                this.right.infixOrder();
            }
        }
    }


    @Override
    public String toString() {
        return "SortNode{" +
                "value=" + value +
                '}';
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public SortNode getLeft() {
        return left;
    }

    public void setLeft(SortNode left) {
        this.left = left;
    }

    public SortNode getRight() {
        return right;
    }

    public void setRight(SortNode right) {
        this.right = right;
    }

    public SortNode() {
    }

    public SortNode(int value) {
        this.value = value;
    }
}
      　　

相關推薦

Java--演算法--二叉排序樹(BST)

二叉排序樹的基本介紹： 二叉排序樹的遍歷和建立 package com.model.tree; /** * @Description:測試類

資料結構和演算法——二叉排序樹

一、二叉排序樹 對於無序的序列“62，58，88，47，73，99，35，51，93，29，37，49，56，36，48，50”，是否存在一種高效的查詢方案，使得能夠快速判斷在序列中是否存在指定的數值？二叉排序樹是一種簡單，高效的資料

二叉排序樹（二叉搜尋樹、二叉查詢樹）BST

概述 對於一組元素 [7, 3, 10, 12, 5, 1, 9] 可以有很多種儲存方式，但無論使用哪種資料結構，都或多或少有缺陷。比如使用線性結構儲存，排序方便，但查詢效率低。二叉排序樹的特點就是能在保證元素有序的同時，提高

資料結構—二叉排序樹（Java）

資料結構—二叉排序樹（Java） 部落格說明 文章所涉及的資料來自網際網路整理和個人總結，意在於個人學習和經驗彙總，如有什麼地方侵權，請聯絡本人刪除，謝謝！

查詢演算法：二叉排序樹

二叉排序樹，又稱二叉查詢樹，是一種對排序和查詢都很有用的特殊二叉樹 定義

二叉排序樹：BST: (Binary Sort(Search) Tree)

二叉排序樹 先看一個需求 給你一個數列 (7, 3, 10, 12, 5, 1, 9)，要求能夠高效的完成對資料的查詢和新增

二叉排序樹的刪除演算法解析

二叉排序樹刪除操作的幾種情況 要刪除的結點在二叉排序樹中是葉子結點： 則可以直接刪除，因為刪除它們對於整棵樹來說，其他節點的結構並不受到影響

資料結構 bst二叉排序樹 節點刪除

刪除葉子節點 刪除只有一個的子節點的 刪除有兩個子節點的 package tree.bst; public class bstDemo {

看動畫學演算法之:二叉搜尋樹BST

目錄簡介BST的基本性質BST的構建BST的搜尋BST的插入BST的刪除 簡介 樹是類似於連結串列的資料結構，和連結串列的線性結構不同的是，樹是具有層次結構的非線性的資料結構。

演算法08 五大查詢之：二叉排序樹(BSTree)

上一篇總結了索引查詢，這一篇要總結的是二叉排序樹(Binary Sort Tree)，又稱為二叉查詢樹(Binary Search Tree) ，即BSTree。

Java刪除二叉搜尋樹的任意元素的方法詳解

本文例項講述了Java刪除二叉搜尋樹的任意元素的方法。分享給大家供大家參考，具體如下：

Java刪除二叉搜尋樹最大元素和最小元素的方法詳解

本文例項講述了Java刪除二叉搜尋樹最大元素和最小元素的方法。分享給大家供大家參考，具體如下：

二叉排序樹/AVL樹原理與實現

2020/7/15 學習內容： 二叉樹查詢樹原理和實現： 二叉查詢樹是特殊的二叉樹，其中左子樹的key值都小於根節點key值，右子樹key值都大於根節點key值，對於每個子樹，也是一顆二叉查詢樹。

二、二叉排序樹

一、概念 　　二叉樹（Binary Tree）是另一種樹形結構，特點是每個節點至多隻有兩顆子樹（即二叉樹中不存在度大於2的節點），並且二叉樹的子樹有左右之分，其次序不能任意顛倒。

問題 A: 二叉排序樹

題目描述 輸入一系列整數，建立二叉排序數，並進行前序，中序，後序遍歷。

深入學習二叉樹(四) 二叉排序樹

摘自：https://www.jianshu.com/p/bbe133625c73 1 前言 資料結構中，線性表分為無序線性表和有序線性表。無序線性表的資料是雜亂無序的，所以在插入和刪除時，沒有什麼必須遵守的規則，可以插入在資料尾部或者刪除

二叉排序樹的建立和遍歷

一個數組建立成對應的二叉排序樹,並使用中序遍歷二叉排序樹,比如:陣列為Array(7,3,10,12,5,1,9),建立成對應的二叉排序樹為

二叉排序樹刪除

二叉排序樹的刪除情況比較複雜,有以下三種情況需要考慮 刪除葉子節點(比如:2,5,9,12)

二叉排序樹

1 #include<stdio.h> 2 #include<stdlib.h> 3 4 #define TRUE 1 5 #define FALSE 0 6 #define ElemType int

生成二叉排序樹

1 #include <bits/stdc++.h> 2 using namespace std; 3 typedef int ElemType; 4 5 typedef struct Node{