【数据结构】手撕二叉查找树（Binary Search Tree）

备注：实现语言为C#（.NET Core），语法和Java别无二致

综述

1. 介绍
   二叉搜索树（Binary Search Tree），又名二叉查找树，二叉排序树：
   • 它或者是一棵空树，或者是具有下列性质的二叉树：
     1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
     2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
     3. 它的左、右子树也分别为二叉搜索树。
   • 二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作
2. 实现原理
   一棵二叉搜索树是以二叉树的形式来组织的，可以使用一个链表数据结构来表示，其中每一个结点就是一个对象。一般地，除了key属性之外，每个结点还包含属性left、right，分别指向结点的左孩子、右孩子。如果某个孩子结点或父结点不存在，则相应属性的值为空（NULL）。
3. 主要算法
   二叉搜索树中的主要算法包括：
   • 结点插入算法（Add）
   • 结点查找算法（Have）
   • 先序遍历算法（Previous_travel）
   • 中序遍历算法（Medium_travel）
   • 后序遍历算法（Post_travel）
   • 层次遍历算法（Layer_travel）
   • 结点删除算法（Del）

第一步 构建结点类

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();
        }
    }
}

运行结果：