基于C#的泛型搜索二叉树

搜索二叉树是序列式容器的底层数据结构；泛型版本能存储各种类型的数据。

二叉树有三个关键数据成员：存储数据，左节点，右节点；在C#中定义为三个属性：Data， Left， Right。

1）为使用方便，实现了<，>两个操作符；主要C#的泛型定义与C++有所区别，不能直接使用模板类的操作符。C#这方面坚持比较严格，会报出operator '<' cannot be applied to operands 'T' and operands 'T'编译错误。这里使用C#的Comparer<T>得到模板类的默认比较操作符解决。Comparer<T>实现的C#的IComparable接口。如果你的类有自己的基类，不妨实现此接口，方便在泛型版本进行比较操作。

2）这里枚举了三种搜索方式 SearchOrder{ InOrder, PreOrder, PostOrder };划分的依据是左，右和父节点之间的先后顺序。L->P->R:InOrder，P->L->R:PreOrder，L->R->P:PostOrder。

3）为方便调试，定义的节点的打印；为保留输出方式的多变性，把StreaWriter传入；比如想打印到标注输出，就可以这样创建StreamWriter：

StreamWriter sw = new StreamWriter(Console.OpenStandardOutput());
            sw.AutoFlush = true;

也可以输出到文本文件中。

4）public方法简介：

• public void Insert(T t)出入类型T数据
• public void Traverse(Node<T> root, StreamWriter sw, SearchOrder so)二叉树遍历
• public T FindMin()查找最小值
• public T FindMax()查找最大值
• public Node<T> Find(T key)查找指定值的节点
• public bool Delete(T key)删除某一值的节点

实际运行结果：

InOrder traversal:
3 16 22 23 37 45 99
23 16 3 22 45 37 99
3 22 16 37 99 45 23
Minmum value:3, Maximum value:99

find a 3
16 22 23 37 45 99
16 22 23 37 99
22 23 37 99
22 23 99
22 99
22

Press any key to continue . . .

 

源代码清单。

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace BinaryTree
{   
    public class Node<T>
    {
        private T tData;
        private Node<T> left;
        private Node<T> right;
        public T Data
        {
            get
            {
                return tData;
            }
            set
            {
                tData = value;
            }
        }
        public Node<T> Left
        {
            get
            {
                return left;
            }
            set
            {
                left = value;
            }       
        }
        public Node<T> Right
        {
            get
            {
                return right;
            }
            set
            {
                right = value;
            }     
        }
        public void Write(StreamWriter sw)
        {             
            sw.Write(tData);
            sw.Write(' ');
        }
        public static bool operator< (Node<T> n1, Node<T> n2)
        {
            return 0 > Comparer<T>.Default.Compare(n1.Data, n2.Data);
        }
        public static bool operator >(Node<T> n1, Node<T> n2)
        {
            return 0 < Comparer<T>.Default.Compare(n1.Data, n2.Data);
        }
    }
    public class BinarySearchTree<T>
    {
        private Node<T> root;
        public Node<T> Root
        {
            get
            {
                return root;
            }
            set
            {
                root = value;
            }
        }
        public enum SearchOrder{ InOrder, PreOrder, PostOrder };
        public BinarySearchTree()
        {
            root = null;
        }
        public void Insert(T t)
        {
            Node<T> newNode = new Node<T>();
            newNode.Data = t;
            if (root == null)
            {
                root = newNode;
            }
            else
            {
                Node<T> current = root;
                Node<T> parent;
                while (true)
                {
                    parent = current;
                    if (0 > Comparer<T>.Default.Compare(t,current.Data))
                    {
                        current = current.Left;
                        if (current == null)
                        {
                            parent.Left = newNode;
                            break;
                        }
                        else
                        {
                            //next loop
                        }
                    }
                    else
                    {
                        current = current.Right;
                        if (current == null)
                        {
                            parent.Right = newNode;
                            break;
                        }
                    }
                }
            }      
        }
        private void InOrder(Node<T> root, StreamWriter sw)
        {
            if (root != null)
            {
                InOrder(root.Left,sw);
                root.Write(sw);
                InOrder(root.Right, sw);               
            }
        }
        private void PreOrder(Node<T> root, StreamWriter sw)
        {
            if (root != null)
            {
                root.Write(sw);
                PreOrder(root.Left, sw);
                PreOrder(root.Right, sw);
            }
        }
        private void PostOrder(Node<T> root, StreamWriter sw)
        {
            if (root != null)
            {
                PostOrder(root.Left, sw);
                PostOrder(root.Right, sw);
                root.Write(sw);
            }
        }
        public void Traverse(Node<T> root, StreamWriter sw, SearchOrder so)
        {
            switch (so)
            {
                case BinarySearchTree<T>.SearchOrder.InOrder: InOrder(root, sw); break;
                case BinarySearchTree<T>.SearchOrder.PreOrder: PreOrder(root, sw); break;
                case BinarySearchTree<T>.SearchOrder.PostOrder: PostOrder(root, sw); break;
            }           
        }
        public T FindMin()
        {
            Node<T> current = root;
            while (current.Left != null)
            {
                current = current.Left;
            }
            return current.Data;
        }
        public T FindMax()
        {
            Node<T> current = root;
            while (current.Right != null)
            {
                current = current.Right;
            }
            return current.Data;
        }
        public Node<T> Find(T key)
        {
            Node<T> current = root;
            while (current != null)
            {
                int cmp = Comparer<T>.Default.Compare(current.Data, key);
                if (0 == cmp)
                {
                    return current;
                }
                else if (0 < cmp)
                {
                    current = current.Left;
                }
                else
                {
                    current = current.Right;
                }
            }
            return null;
        }
        public bool Delete(T key)
        {
            Node<T> current = root;
            Node<T> parent = root;
            bool isLeft = true;
            while (current != null)
            {
                int cmp = Comparer<T>.Default.Compare(current.Data, key);
                if (0 == cmp)
                {                          
                    if (current.Left == null && current.Right == null)
                    {
                        //leaf node
                        if (current != root)
                        {
                            if (isLeft == true)
                            {
                                parent.Left = null;
                            }
                            else
                            {
                                parent.Right = null;
                            }
                        }
                        else
                        {
                            root = null;
                        }
                    }
                    else if (current.Left == null)
                    {
                        //with right child
                        if (current == root)
                        {
                            root = current.Right;
                        }
                        else if (isLeft)
                        {
                            parent.Left = current.Right;
                        }
                        else
                        {
                            parent.Right = current.Right;
                        }
                    }
                    else if (current.Right == null)
                    {
                        //with left child
                        if (current == root)
                        {
                            root = current.Left;
                        }
                        else if (isLeft)
                        {
                            parent.Left = current.Left;
                        }
                        else
                        {
                            parent.Right = current.Left;
                        }
                    }
                    else
                    {
                        isLeft = false;
                        //two children   
                        Node<T> successor = GetSuccessor(current);
                        if (successor == root.Right)
                        {
                            root = successor;
                        }
                        else if (isLeft)
                        {
                            parent.Left = successor;
                        }
                        else
                        {
                            parent.Right = successor;
                        }
                        successor.Left = current.Left;
                    }                   

                    return true ;
                }
                else if (0 < cmp)
                {
                    parent = current;
                    current = current.Left;                   
                    isLeft = true;
                }
                else
                {
                    parent = current;
                    current = current.Right;
                    isLeft = false;
                }
            }
            return false;
        }
        private Node<T> GetSuccessor(Node<T> delNode)
        {
            Node<T> sucParent = delNode;
            Node<T> suc = delNode;
            Node<T> current = delNode.Right;
            while (current != null)
            {
                sucParent = current;
                suc = current;
                current = current.Left;
            }
            if (suc != delNode.Right)
            {
                //only right child
                sucParent.Right = current.Right;
            }
            return suc;
        }
    }