2. 程式人生 > 其它 >【資料結構】手撕二叉查詢樹（Binary Search Tree）

【資料結構】手撕二叉查詢樹（Binary Search Tree）

阿新 • • 發佈：2021-01-22

技術標籤：演算法題解演算法二叉樹資料結構c#

文章目錄


備註：實現語言為C#（.NET Core），語法和Java別無二致

第一步 構建結點類

class Node
{
    public int data { get; set; }
    public Node Left { get; set
 
; }
    public Node Right { get; set; }

    public Node() { }
    public Node(int val)
    {
        data = val;
        Left = null;
        Right = null;
    }
}

第二步 實現結點新增方法

public int Add(int val)
{
    if (root == null)
        root = new Node(val);
    else
    {
        Node node = root;
        while
 
 (node != null)
        {
            if (val < node.data)
            {
                if(node.Left != null)
                {
                    node = node.Left;
                    continue;
                }
                node.Left = new Node(val);
                break;
            }

            else
 
 if (val == node.data) return -1; //重複則不新增，直接返回-1

            else
            {
                if (node.Right != null)
                {
                    node = node.Right;
                    continue;
                }
                node.Right = new Node(val);
                break;
            }
        }
    }
    Size++;
    return 0;
}

第三步 實現結點的刪除方法（重難點）

//外部API
public void Del(int val)
{
    root = Del(root, val);
}

//遞迴實現部分
private Node Del(Node node, int val)
{
    if (node == null)
        return null;

    if(val < node.data)
    {
        node.Left = Del(node.Left, val);
        return node;
    }
    else if(val > node.data)
    {
        node.Right = Del(node.Right, val);
        return node;
    }
    else //找到要刪除的結點
    {
        if(node.Left == null)
        {
            if(node.Right == null) //沒有孩子結點
            {
                node = null;
                return node;
            }
            else                   //有右孩子
            {
                node = node.Right;
                return node;
            }
        }
        else
        {
            if(node.Right == null) //有左孩子
            {
                node = node.Left;
                return node;
            }
            else                   //左右孩子都有 
            {
                //找到右子樹中最小的結點替換要刪除的結點
                Node findMin = node.Right;
                while (findMin.Left != null)
                    findMin = findMin.Left;
                node.data = findMin.data;
                node.Right = Del(node.Right, findMin.data);
                return node;
            }
        }
    }
}

第四步 實現結點的查詢方法

public bool Have(int val)
{
    Node node = root;
    while(node != null)
    {
        if (val < node.data)
            node = node.Left;
        else if (val > node.data)
            node = node.Right;
        else
            return true;
    }
    return false;
}

第五步 實現二叉樹的先序遍歷演算法

//外部API
public void Previous_travel()
{
    Previous_travel(root);
}

//遞迴實現部分
private void Previous_travel(Node node)
{
    if (node != null)
    {
        Console.Write(node.data + " ");
        Previous_travel(node.Left);
        Previous_travel(node.Right);
    }
}

第六步 實現二叉樹的中序遍歷演算法

//外部API
public void Medium_travel()
{
    Medium_travel(root);
}

//遞迴實現部分
private void Medium_travel(Node node)
{
    if (node != null)
    {
        Medium_travel(node.Left);
        Console.Write(node.data + " ");
        Medium_travel(node.Right);
    }
}

第七步 實現二叉樹的後序遍歷演算法

//外部API
public void Post_travel()
{
    Post_travel(root);
}

//遞迴實現部分
private void Post_travel(Node node)
{
    if (node != null)
    {
        Post_travel(node.Left);
        Post_travel(node.Right);
        Console.Write(node.data + " ");
    }
}

第八步 實現二叉樹的層次遍歷演算法（難點）

public void layer_travel()
{
    Queue<Node> nodes = new Queue<Node>();//需要藉助佇列暫存每層的孩子結點
    nodes.Enqueue(root);
    Node node = null;

    while(nodes.Count != 0)
    {
        node = nodes.Dequeue();
        if(node != null)
        {
            Console.Write(node.data + " ");
            if (node.Left != null)
                nodes.Enqueue(node.Left);
            if (node.Right != null)
                nodes.Enqueue(node.Right);
        }
    }
}

完整程式碼實現

using System;
using System.Collections.Generic;

namespace DataStructure
{
	// 結點類
    class Node
    {
        public int data { get; set; }
        public Node Left { get; set; }
        public Node Right { get; set; }

        public Node() { }
        public Node(int val)
        {
            data = val;
            Left = null;
            Right = null;
        }
    }
    
    // 二叉搜尋樹
    class BinarySearchTree
    {
        private Node root;
        public int Size { get; set; }

        public BinarySearchTree()
        {
            root = null;
            Size = 0;
        }

        //結點新增
        public int Add(int val)
        {
            if (root == null)
                root = new Node(val);
            else
            {
                Node node = root;
                while (node != null)
                {
                    if (val < node.data)
                    {
                        if(node.Left != null)
                        {
                            node = node.Left;
                            continue;
                        }
                        node.Left = new Node(val);
                        break;
                    }

                    else if (val == node.data) return -1;

                    else
                    {
                        if (node.Right != null)
                        {
                            node = node.Right;
                            continue;
                        }
                        node.Right = new Node(val);
                        break;
                    }
                }
            }
            Size++;
            return 0;
        }

        //結點刪除
        public void Del(int val)
        {
            root = Del(root, val);
        }

        private Node Del(Node node, int val)
        {
            if (node == null)
                return null;

            if(val < node.data)
            {
                node.Left = Del(node.Left, val);
                return node;
            }
            else if(val > node.data)
            {
                node.Right = Del(node.Right, val);
                return node;
            }
            else //找到要刪除的結點
            {
                if(node.Left == null)
                {
                    if(node.Right == null) //沒有孩子結點
                    {
                        node = null;
                        return node;
                    }
                    else                   //有右孩子
                    {
                        node = node.Right;
                        return node;
                    }
                }
                else
                {
                    if(node.Right == null) //有左孩子
                    {
                        node = node.Left;
                        return node;
                    }
                    else                   //左右孩子都有 
                    {
                        //找到右子樹中最小的結點替換要刪除的結點
                        Node findMin = node.Right;
                        while (findMin.Left != null)
                            findMin = findMin.Left;
                        node.data = findMin.data;
                        node.Right = Del(node.Right, findMin.data);
                        return node;
                    }
                }
            }
        }

        //查詢結點
        public bool Have(int val)
        {
            Node node = root;
            while(node != null)
            {
                if (val < node.data)
                    node = node.Left;
                else if (val > node.data)
                    node = node.Right;
                else
                    return true;
            }
            return false;
        }

        //先序遍歷
        public void Previous_travel()
        {
            Previous_travel(root);
        }
        private void Previous_travel(Node node)
        {
            if (node != null)
            {
                Console.Write(node.data + " ");
                Previous_travel(node.Left);
                Previous_travel(node.Right);
            }
        }

        //中序遍歷
        public void Medium_travel()
        {
            Medium_travel(root);
        }
        private void Medium_travel(Node node)
        {
            if(node != null)
            {
                Medium_travel(node.Left);
                Console.Write(node.data + " ");
                Medium_travel(node.Right);

            }
        }

        //後序遍歷
        public void Post_travel()
        {
            Post_travel(root);
        }
        private void Post_travel(Node node)
        {
            if(node != null)
            {
                Post_travel(node.Left);
                Post_travel(node.Right);
                Console.Write(node.data + " ");
            }
        }

        //層次遍歷
        public void layer_travel()
        {
            Queue<Node> nodes = new Queue<Node>();
            nodes.Enqueue(root);
            Node node = null;

            while(nodes.Count != 0)
            {
                node = nodes.Dequeue();
                if(node != null)
                {
                    Console.Write(node.data + " ");
                    if (node.Left != null)
                        nodes.Enqueue(node.Left);
                    if (node.Right != null)
                        nodes.Enqueue(node.Right);
                }
            }
        }
    }
}

除錯程式碼及執行結果

using System;

namespace DataStructure
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] nums = Console.ReadLine().Split(" ");
            BinarySearchTree tree = new BinarySearchTree();

            foreach (string num in nums)
                tree.Add(int.Parse(num));

            Console.WriteLine("樹中元素的個數為：{0}", tree.Size);
            if (tree.Have(2))
                Console.WriteLine("樹中包含2這個元素");
            else
                Console.WriteLine("樹中不包含2這個元素");

            Console.Write("先序遍歷結果：");
            tree.Previous_travel();
            Console.Write("\n中序遍歷結果：");
            tree.Medium_travel();
            Console.Write("\n後序遍歷結果：");
            tree.Post_travel();
            Console.Write("\n層序遍歷結果：");
            tree.layer_travel();

            Console.Write("\n請輸入要刪除的元素：");
            int del = int.Parse(Console.ReadLine());
            tree.Del(del);

            Console.Write("刪除後先序遍歷結果：");
            tree.Previous_travel();
            Console.Write("\n刪除後中序遍歷結果：");
            tree.Medium_travel();
            Console.Write("\n刪除後後序遍歷結果：");
            tree.Post_travel();
            Console.Write("\n刪除後層序遍歷結果：");
            tree.layer_travel();

            Console.ReadKey();
        }
    }
}

執行結果：
在這裡插入圖片描述

相關推薦

【資料結構】手撕二叉查詢樹（Binary Search Tree）

技術標籤：演算法題解演算法二叉樹資料結構c# 文章目錄 第一步 構建結點類第二步 實現結點新增方法第三步 實現結點的刪除方法（重難點）第四步 實現結點的查詢方法第五步 實現二叉樹的先序遍歷演算法第六步 實

【資料結構】數和二叉樹相關演算法

二叉樹的遍歷 先序遍歷 //先序遍歷 void InOrder(BiTree T) { InitStack(S); BiTree p = T; while (p || !Empty(S)) {

二叉搜尋樹BST(Binary Search Tree)的建立

技術標籤：樹c++資料結構 以下是鄙人建立此樹的全部過程 生成結構體 樹節點中包含1個數值域，兩個指標域，分別指向左右孩子。 結構示意：

【PTA資料結構與演算法題目集筆記】7-4 是否同一棵二叉搜尋樹（C語言實現）

技術標籤：演算法資料結構c語言 7-4 是否同一棵二叉搜尋樹 題目要求 給定一個插入序列就可以唯一確定一棵二叉搜尋樹。然而，一棵給定的二叉搜尋樹卻可以由多種不同的插入序列得到。例如分別按照序列{2, 1, 3}和{

【力扣】538. 把二叉搜尋樹轉換為累加樹

給定一個二叉搜尋樹（Binary Search Tree），把它轉換成為累加樹（Greater Tree)，使得每個節點的值是原來的節點值加上所有大於它的節點值之和。

【2】不同的二叉搜尋樹（LeetCode 96）

技術標籤：LeetCode刷題筆記演算法動態規劃c++ 問題描述 不同的二叉搜尋樹 給定一個整數 n，求以 1 … n 為節點組成的二叉搜尋樹有多少種？

【資料結構】演算法 排序陣列中查詢元素的第一個和最後一個位置 Find First And Last Position of Element in Sorted Array

目錄排序陣列中查詢元素的第一個和最後一個位置 Find First And Last Position of Element in Sorted Array思路Tag

二叉查詢樹（BST）

二叉查詢樹、BST 二叉搜尋樹 時間複雜度與樹的高度成正比，理想情況下O(lgn)。

【資料結構】【二叉樹】四、二叉搜尋樹的特性（不斷補充）

技術標籤：資料結構與演算法資料結構二叉樹leetcode演算法 目錄 一、題目1：二叉搜尋樹的後序遍歷序列（劍指Offer 33）1. 後序遍歷的兩個特性2.二叉搜尋樹的特性3.二叉搜尋樹的後序遍歷的特性注：二叉搜尋樹的

【資料結構】二叉樹的遍歷

技術標籤：二叉樹演算法 初始為滿二叉樹ABCDEFG 先中後序的程式碼實現 #include <cstdio>

【資料結構】演算法 Binary Search Tree find Kth largest Node 二叉搜尋樹的第k大節點

目錄Binary Search Tree find Kth largest Node 二叉搜尋樹的第k大節點思路Tag Binary Search Tree find Kth largest Node 二叉搜尋樹的第k大節點

【資料結構】二叉樹

一、二叉樹介紹　　 　　簡單地理解，滿足以下兩個條件的樹就是二叉樹： 本身是有序樹；

【資料結構】演算法 Maximum Width of Binary Tree 二叉樹最大寬度

目錄Maximum Width of Binary Tree 二叉樹最大寬度思路Tag Maximum Width of Binary Tree 二叉樹最大寬度

【資料結構】二叉樹中的列表 Linked List in Binary Tree

目錄二叉樹中的列表 Linked List in Binary Tree7思路Tag 二叉樹中的列表 Linked List in Binary Tree7

【資料結構】二叉樹專題

LeetCode 94. 二叉樹的中序遍歷 遞迴寫法 /** * Definition for a binary tree node. * struct TreeNode {

【資料結構】單向連結串列——用Java手寫一個單向連結串列

技術標籤：資料結構連結串列資料結構java演算法單向連結串列 目錄 前言單鏈表圖解程式碼

【資料結構】二維樹狀陣列

一、二維樹狀陣列 二維樹狀陣列，其實就是一維的樹狀陣列上的節點再套個樹狀陣列，就變成了二維樹狀陣列了。

資料結構之二叉樹——二叉查詢樹

定義 二叉查詢樹（Binary Search Tree），又稱為二叉搜尋樹，二叉排序樹。它可以是一棵空樹，如果不是空樹，則具有下列的性質：

【資料結構】字尾陣列

字尾陣列 Suffix Array 　　對於一個長度為 len 字串 S ，將其 len 個字尾根據字典序排序得到的排名陣列即為字尾陣列

【資料結構】- Java位元組序、主機位元組序和網路位元組序掃盲貼

　　Java程式設計師是幸福，因為相對於C/C++的不跨平臺，JVM為我們遮蔽了大量的底層細節和複雜性，讓我們能夠將精力放在實現特定的業務邏輯上，所以使用java開發專案效率是比較高的。同時java程式設計師是悲哀的，就