C#實現二叉樹--二叉鏈表結構

二叉樹的簡單介紹

關於二叉樹的介紹請看這里 ：

二叉樹的簡單介紹 http://www.cnblogs.com/JiYF/p/7048785.html

---

 

二叉鏈表存儲結構：

二叉樹的鏈式存儲結構是指，用鏈表來表示一棵二叉樹，即用鏈來指示元素的邏輯關系。

通常的方法是鏈表中每個結點由三個域組成，數據域和左右指針域，左右指針分別用來給出該結點左孩子和右孩子所在的鏈結點的存儲地址。其結點結構為：

  其中，data域存放某結點的數據信息；lchild與rchild分別存放指向左孩子和右孩子的指針，當左孩子或右孩子不存在時，相應指針域值為空（用符號∧或NULL表示）。利用這樣的結點結構表示的二叉樹的鏈式存儲結構被稱為二叉鏈表，如圖5-8所示。  

C#實現代碼

二叉樹的節點類：

Binary Tree

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

namespace DataStructure
{
    /// <summary>
    /// 二叉鏈表結點類
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public  class TreeNode<T>
    {
        private T data;               //數據域
        private TreeNode<T> lChild;   //左孩子   樹中一個結點的子樹的根結點稱為這個結點的孩子
        private TreeNode<T> rChild;   //右孩子

        public TreeNode(T val, TreeNode<T> lp, TreeNode<T> rp)
        {
            data = val;
            lChild = lp;
            rChild = rp;
        }

        public TreeNode(TreeNode<T> lp, TreeNode<T> rp)
        {
            data = default(T);
            lChild = lp;
            rChild = rp;
        }

        public TreeNode(T val)
        {
            data = val;
            lChild = null;
            rChild = null;
        }

        public TreeNode()
        {
            data = default(T);
            lChild = null;
            rChild = null;
        }

        public T Data
        {
            get { return data; }
            set { data = value; }
        }

        public TreeNode<T> LChild
        {
            get { return lChild; }
            set { lChild = value; }
        }

        public TreeNode<T> RChild
        {
            get { return rChild; }
            set { rChild = value; }
        }

    }

定義索引文件結點的數據類型

 /// <summary>
    /// 定義索引文件結點的數據類型
    /// </summary>
    public struct indexnode
    {
        int key;         //鍵
        int offset;      //位置
        public indexnode(int key, int offset)
        {
            this.key = key;
            this.offset = offset;
        }

        //鍵屬性
        public int Key
        {
            get { return key; }
            set { key = value; }
        }
        //位置屬性
        public int Offset
        {
            get { return offset; }
            set { offset = value; }
        }


    }


    public class LinkBinaryTree<T>
    {
        private TreeNode<T> head;       //頭引用

        public TreeNode<T> Head
        {
            get { return head; }
            set { head = value; }
        }

        public LinkBinaryTree()
        {
            head = null;
        }

        public LinkBinaryTree(T val)
        {
            TreeNode<T> p = new TreeNode<T>(val);
            head = p;
        }

        public LinkBinaryTree(T val, TreeNode<T> lp, TreeNode<T> rp)
        {
            TreeNode<T> p = new TreeNode<T>(val, lp, rp);
            head = p;
        }

        //判斷是否是空二叉樹
        public bool IsEmpty()
        {
            if (head == null)
                return true;
            else
                return false;
        }

        //獲取根結點
        public TreeNode<T> Root()
        {
            return head;
        }

        //獲取結點的左孩子結點
        public TreeNode<T> GetLChild(TreeNode<T> p)
        {
            return p.LChild;
        }

        public TreeNode<T> GetRChild(TreeNode<T> p)
        {
            return p.RChild;
        }

        //將結點p的左子樹插入值為val的新結點，原來的左子樹稱為新結點的左子樹
        public void InsertL(T val, TreeNode<T> p)
        {
            TreeNode<T> tmp = new TreeNode<T>(val);
            tmp.LChild = p.LChild;
            p.LChild = tmp;
        }

        //將結點p的右子樹插入值為val的新結點，原來的右子樹稱為新節點的右子樹
        public void InsertR(T val, TreeNode<T> p)
        {
            TreeNode<T> tmp = new TreeNode<T>(val);
            tmp.RChild = p.RChild;
            p.RChild = tmp;
        }

        //若p非空 刪除p的左子樹
        public TreeNode<T> DeleteL(TreeNode<T> p)
        {
            if ((p == null) || (p.LChild == null))
                return null;
            TreeNode<T> tmp = p.LChild;
            p.LChild = null;
            return tmp;
        }

        //若p非空 刪除p的右子樹
        public TreeNode<T> DeleteR(TreeNode<T> p)
        {
            if ((p == null) || (p.RChild == null))
                return null;
            TreeNode<T> tmp = p.RChild;
            p.RChild = null;
            return tmp;
        }

        //編寫算法 在二叉樹中查找值為value的結點

        public TreeNode<T> Search(TreeNode<T> root, T value)
        {
            TreeNode<T> p = root;
            if (p == null)
                return null;
            if (!p.Data.Equals(value))
                return p;
            if (p.LChild != null)
            {
                return Search(p.LChild, value);
            }
            if (p.RChild != null)
            {
                return Search(p.RChild, value);
            }
            return null;
        }

        //判斷是否是葉子結點
        public bool IsLeaf(TreeNode<T> p)
        {
            if ((p != null) && (p.RChild == null) && (p.LChild == null))
                return true;
            else
                return false;
        }


        //中序遍歷
        //遍歷根結點的左子樹->根結點->遍歷根結點的右子樹 
        public void inorder(TreeNode<T> ptr)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Tree is Empty !");
                return;
            }
            if (ptr != null)
            {
                inorder(ptr.LChild);
                Console.WriteLine(ptr.Data + " ");
                inorder(ptr.RChild);
            }
        }


        //先序遍歷
        //根結點->遍歷根結點的左子樹->遍歷根結點的右子樹 
        public void preorder(TreeNode<T> ptr)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Tree is Empty !");
                return;
            }
            if (ptr != null)
            {
                Console.WriteLine(ptr.Data + " ");
                preorder(ptr.LChild);
                preorder(ptr.RChild);
            }
        }


        //后序遍歷
        //遍歷根結點的左子樹->遍歷根結點的右子樹->根結點
        public void postorder(TreeNode<T> ptr)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Tree is Empty !");
                return;
            }
            if (ptr != null)
            {
                postorder(ptr.LChild);
                postorder(ptr.RChild);
                Console.WriteLine(ptr.Data + "");
            }
        }


        //層次遍歷
        //引入隊列 
        public void LevelOrder(TreeNode<T> root)
        {
            if (root == null)
            {
                return;
            }
            CSeqQueue<TreeNode<T>> sq = new CSeqQueue<TreeNode<T>>(50);
            sq.EnQueue(root);
            while (!sq.IsEmpty())
            {
                //結點出隊
                TreeNode<T> tmp = sq.DeQueue();
                //處理當前結點
                Console.WriteLine("{0}", tmp);
                //將當前結點的左孩子結點入隊
                if (tmp.LChild != null)
                {
                    sq.EnQueue(tmp.LChild);
                }
                if (tmp.RChild != null)
                {
                    sq.EnQueue(tmp.RChild);
                }
            }
        }
    }

二叉搜索樹：結點的左子節點的值永遠小於該結點的值，而右子結點的值永遠大於該結點的值 稱為二叉搜索樹

/// <summary>
    /// 二叉搜索樹：結點的左子節點的值永遠小於該結點的值，而右子結點的值永遠大於該結點的值 稱為二叉搜索樹
    /// </summary>
    public class LinkBinarySearchTree : LinkBinaryTree<indexnode>
    {
        //定義增加結點的方法
        public void insert(indexnode element)
        {
            TreeNode<indexnode> tmp, parent = null, currentNode = null;
            //調用FIND方法
            find(element, ref parent, ref currentNode);
            if (currentNode != null)
            {
                Console.WriteLine("Duplicates words not allowed");
                return;
            }
            else
            {
                //創建結點
                tmp = new TreeNode<indexnode>(element);
                if (parent == null)
                    Head = tmp;
                else
                {
                    if (element.Key < parent.Data.Key)
                        parent.LChild = tmp;
                    else
                        parent.RChild = tmp;
                }
            }
        }

        //定義父結點
        public void find(indexnode element, ref TreeNode<indexnode> parent, ref TreeNode<indexnode> currentNode)
        {
            currentNode = Head;
            parent = null;
            while ((currentNode != null) && (currentNode.Data.Key.ToString() != element.Key.ToString()) && (currentNode.Data.Offset .ToString() != element.Offset .ToString()))//
            {
                parent = currentNode;
                if (element.Key < currentNode.Data.Key)
                    currentNode = currentNode.LChild;
                else
                    currentNode = currentNode.RChild;
            }
        }

        //定位結點
        public void find(int key)
        {
            TreeNode<indexnode> currentNode = Head;
            while ((currentNode != null) && (currentNode.Data.Key.ToString () != key.ToString ()))
            {
                Console.WriteLine(currentNode.Data.Offset.ToString());
                if (key < currentNode.Data.Key)
                    currentNode = currentNode.LChild;
                else
                    currentNode = currentNode.RChild;
            }
        }

        //中序遍歷
        //遍歷根結點的左子樹->根結點->遍歷根結點的右子樹 
        public void inorderS(TreeNode<indexnode> ptr)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Tree is Empty !");
                return;
            }
            if (ptr != null)
            {
                inorderS(ptr.LChild);
                Console.WriteLine(ptr.Data.Key  + " ");
                inorderS(ptr.RChild);
            }
        }


        //先序遍歷
        //根結點->遍歷根結點的左子樹->遍歷根結點的右子樹 
        public void preorderS(TreeNode<indexnode> ptr)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Tree is Empty !");
                return;
            }
            if (ptr != null)
            {
                Console.WriteLine(ptr.Data.Key  + " ");
                preorderS(ptr.LChild);
                preorderS(ptr.RChild);
            }
        }


        //后序遍歷
        //遍歷根結點的左子樹->遍歷根結點的右子樹->根結點
        public void postorderS(TreeNode<indexnode> ptr)
        {
            if (IsEmpty())
            {
                Console.WriteLine("Tree is Empty !");
                return;
            }
            if (ptr != null)
            {
                postorderS(ptr.LChild);
                postorderS(ptr.RChild);
                Console.WriteLine(ptr.Data.Key + "");
            }
        }
    }


    /// <summary>
    /// 循環順序隊列
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class CSeqQueue<T>
    {
        private int maxsize;       //循環順序隊列的容量
        private T[] data;          //數組，用於存儲循環順序隊列中的數據元素
        private int front;         //指示最近一個已經離開隊列的元素所占有的位置 循環順序隊列的對頭
        private int rear;          //指示最近一個進入隊列的元素的位置           循環順序隊列的隊尾

        public T this[int index]
        {
            get { return data[index]; }
            set { data[index] = value; }
        }

        //容量屬性
        public int Maxsize
        {
            get { return maxsize; }
            set { maxsize = value; }
        }

        //對頭指示器屬性
        public int Front
        {
            get { return front; }
            set { front = value; }
        }

        //隊尾指示器屬性
        public int Rear
        {
            get { return rear; }
            set { rear = value; }
        }

        public CSeqQueue()
        {

        }

        public CSeqQueue(int size)
        {
            data = new T[size];
            maxsize = size;
            front = rear = -1;
        }

        //判斷循環順序隊列是否為滿
        public bool IsFull()
        {
            if ((front == -1 && rear == maxsize - 1) || (rear + 1) % maxsize == front)
                return true;
            else
                return false;
        }

        //清空循環順序列表
        public void Clear()
        {
            front = rear = -1;
        }

        //判斷循環順序隊列是否為空
        public bool IsEmpty()
        {
            if (front == rear)
                return true;
            else
                return false;
        }

        //入隊操作
        public void EnQueue(T elem)
        {
            if (IsFull())
            {
                Console.WriteLine("Queue is Full !");
                return;
            }
            rear = (rear + 1) % maxsize;
            data[rear] = elem;
        }

        //出隊操作
        public T DeQueue()
        {
            if (IsEmpty())
            {
                Console.WriteLine("Queue is Empty !");
                return default(T);
            }
            front = (front + 1) % maxsize;
            return data[front];
        }

        //獲取對頭數據元素
        public T GetFront()
        {
            if (IsEmpty())
            {
                Console.WriteLine("Queue is Empty !");
                return default(T);
            }
            return data[(front + 1) % maxsize];//front從-1開始
        }

        //求循環順序隊列的長度
        public int GetLength()
        {
            return (rear - front + maxsize) % maxsize;
        }
    }