【万丈高楼平地起 第三季 C#实现二叉树操作】

本文接上一篇【万丈高楼平地起 第二季 队列和栈】继续说明如何用C#语言实现二叉树的操作。

四、树
      链表、堆栈和队列都是线性结构(即序列)。树是一种特殊的非线性二维数据机构。树节点包含两个或两个以上的链接。工作中主要应用的二叉树——每个节点都有两个链接（其中可有一个或两个链接为null）。根节点是树的第一个节点。左孩子（left child）是左子树的第一个节点，右孩子（right child ）是右子树的第一个节点。属于相同节点的子节点成为兄弟节点（siblings）。没有子节点的节点成为叶子节点。计算机科学家常常用根节点在上、叶子节点的方式画出一棵树——同树的自然生长方向恰好相反。

特殊二叉树——二叉查找树
二叉查找树（没有重复的节点值）的特征是：左子树中任何值都小于父节点的值，右子树中任何值都大于父节点的值。

构建二叉树、前序、中序、后序遍历二叉树  BinaryTreeLibrary.cs

using System;
 
namespace BinaryTreeLibrary
{
    /// <summary>
    /// 定义TreeNode类
    /// </summary>
    class TreeNode
    {
        private TreeNode leftNode;
        private int data;
        private TreeNode rightNode;
 
        /// <summary>
        /// 初始化数据，构造一个叶子节点
        /// </summary>
        /// <param name="nodeData"></param>
        public TreeNode(int nodeData)
        {
            data = nodeData;
            leftNode = rightNode = null;
        }
       
        /// <summary>
        /// 左节点
        /// </summary>
        public TreeNode LeftNode
        {
            get
            {
                return leftNode;
            }
            set
            {
                leftNode = value;
            }
        }
 
        /// <summary>
        /// Data数据节点
        /// </summary>
        public int Data
        {
            get
            {
                return data;
            }
            set
            {
                data = value;
            }
        }
 
        public TreeNode RightNode
        {
            get
            {
                return rightNode;
            }
            set
            {
                rightNode = value;
            }
        }
 
        /// <summary>
        /// 在包含节点的二叉树中插入TreeNode
        /// </summary>
        /// <param name="insertValue"></param>
        public void Insert(int insertValue)
        {
            // 在左子树中插入数据
            if (insertValue < data)
            {
                // 如果没有左子树就构建一个叶子节点
                if (leftNode == null)
                {
                    leftNode = new TreeNode(insertValue);
                }
                else
                {
                    // 遍历左子树
                    leftNode.Insert(insertValue);
                }
            }
            // 在右子树中插入数据
            else if (insertValue > data)
            {
                // 如果没有右子树就构建一个叶子节点
                if (rightNode == null)
                {
                    rightNode = new TreeNode(insertValue);
                }
                else
                {
                    // 遍历右子树
                    rightNode.Insert(insertValue);
                }
            }
        }// end insert method
 
    }// end class TreeNode
 
    /// <summary>
    /// 类Tree定义
    /// </summary>
    public class Tree
    {
        // 整个类操作的是 TreeNode 类的对象
        private TreeNode root;
 
        /// <summary>
        /// 构建一颗空树
        /// </summary>
        public Tree()
        {
            root = null;
        }
 
        /// <summary>
        /// 将新节点插入到二叉树
        /// 如果根节点是空的，就创建根节点
        /// 否则，调用insert方法
        /// </summary>
        /// <param name="insertValue"></param>
        public void InsertNode(int insertValue)
        {
            lock (this)
            {
                if (root == null)
                {
                    root = new TreeNode(insertValue);
                }
                else
                {
                    root.Insert(insertValue);
                }
            }
        }
 
        /// <summary>
        /// 前序遍历
        /// </summary>
        public void PreorderTraverse()
        {
            lock (this)
            {
                PreorderHelper(root);
            }
        }
 
 
        /// <summary>
        /// 递归进行前序遍历
        /// </summary>
        /// <param name="node"></param>
        private void PreorderHelper(TreeNode node)
        {
            if (node == null)
            {
                return;
            }
 
            // 输出 节点 数据
            Console.Write(node.Data + " ");
 
            // 遍历左子树
            PreorderHelper(node.LeftNode);
 
            // 遍历右子树
            PreorderHelper(node.RightNode);
        }
 
        /// <summary>
        /// 中序遍历
        /// </summary>
        public void InorderTravese()
        {
            lock (this)
            {
                InorderHelper(root);
            }
        }
 
        /// <summary>
        /// 递归进行中序遍历
        /// </summary>
        /// <param name="node"></param>
        private void InorderHelper(TreeNode node)
        {
            if (node == null)
            {
                return;
            }
 
            // 先 遍历左子树
            InorderHelper(node.LeftNode);
 
            // 输出 数据 节点
            Console.Write(node.Data + " ");
 
            // 后 遍历右子树
            InorderHelper(node.RightNode);
 
        }
 
        /// <summary>
        /// 后序遍历
        /// </summary>
        public void PostorderTravese()
        {
            lock (this)
            {
                PostorderHelper(root);
            }
        }
 
        /// <summary>
        /// 递归进行后序遍历
        /// </summary>
        /// <param name="node"></param>
        private void PostorderHelper(TreeNode node)
        {
            if (node == null)
            {
                return;
            }
 
            // 先 遍历左子树
            PostorderHelper(node.LeftNode);
 
            // 再 遍历右子树
            PostorderHelper(node.RightNode);
 
            // 输出 数据 节点
            Console.Write(node.Data + " ");
        }
    }// end class Tree
}

　　

Tree类操作TreeNode类的对象。Tree类有一个私有数据成员——root，这是对根节点的引用。

为保证线程的安全性，Tree类的InsertNode方法首先锁定Tree对象，然后再进行后序是否为空、插入节点等操作。
方法PreorderTraverse()、InorderTraverse()和PostorderTraverse()分别调用辅助方法PreorderHelper、InorderHelper和PostorderHelper方法。

测试代码，Program.cs

using System;
using BinaryTreeLibrary;
 
namespace TreeTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Tree tree = new Tree();
            int insertValue;
 
            Console.WriteLine("Inserting values: ");
            Random random = new Random();
 
            for (int i = 0; i <= 10; i++)
            {
                insertValue = random.Next(100);
                Console.Write(insertValue + " ");
 
                tree.InsertNode(insertValue);
            }
 
            // 前序遍历
            Console.Write("\n\n 前序遍历：");
            tree.PreorderTraverse();
 
            // 中序遍历
            Console.Write("\n\n 中序遍历：");
            tree.InorderTravese();
 
            // 后序遍历
            Console.Write("\n\n 后序遍历：");
            tree.PostorderTravese();
 
            Console.ReadKey();
        }
    }
}

　　

至此，二叉查找树测试完毕！