/// <summary>
    /// 二叉樹節點的定義
    /// </summary>
    public class Node
    {
        //本身的資料
        public int data;
        //左右節點
        public Node left;
        public Node right;

        public void DisplayData()
        {
            Console.Write(data + "  ");
        }
    }

    public class BinarySearchTree
    {

        Node rootNode = null;

        public void Insert(int data)
        {
            Node parent;
            //包裝資料進節點
            Node newNode = new Node();
            newNode.data = data;
            //根節點
            if (rootNode == null)
            {
                rootNode = newNode;
            }
            //找到合適的子節點位置插入
            else
            {
                Node currentNode = rootNode;
                while (true)
                {
                    parent = currentNode;
                    if (newNode.data < currentNode.data)
                    {
                        currentNode = currentNode.left;
                        if (currentNode == null)
                        {
                            parent.left = newNode;
                            break;
                        }
                    }
                    else
                    {
                        currentNode = currentNode.right;
                        if (currentNode == null)
                        {
                            parent.right = newNode;
                            break;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 中序遍歷
        /// </summary>
        /// <param name="theRoot"></param>
        public void InOrder(Node theRoot)
        {
            if (theRoot != null)
            {
                InOrder(theRoot.left);
                theRoot.DisplayData();
                InOrder(theRoot.right);
            }
        }
        //先序遍歷
        public void PreOrder(Node theRoot)
        {
            if (theRoot != null)
            {
                theRoot.DisplayData();
                PreOrder(theRoot.left);
                PreOrder(theRoot.right);
            }
        }
        //後序遍歷
        public void PostOrder(Node theRoot)
        {
            if (theRoot != null)
            {
                PostOrder(theRoot.left);
                PostOrder(theRoot.right);
                theRoot.DisplayData();
            }
        }


        public void FindMax()
        {
            Node current = rootNode;
            //找到最右邊的即可
            while (current.right != null)
            {
                current = current.right;
            }
            Console.WriteLine("max:" + current.data);
        }

        public void FindMin()
        {
            Node current = rootNode;
            //找到最左邊的節點即可
            while (current.left != null)
            {
                current = current.left;
            }
            Console.WriteLine("min:" + current.data);
        }

        public Node Search(int i)
        {
            Node current = rootNode;
            while (true)
            {
                if (i < current.data)
                {
                    if (current.left == null) break;
                    current = current.left;
                }
                else if (i > current.data)
                {
                    if (current == null) break;
                    current = current.right;
                }
                else
                {
                    return current;
                }
            }

            if (current.data != i)
            {
                return null;
            }
            return current;
        }

        public Node Delete(int key)
        {
            Node parent = rootNode;
            Node current = rootNode;
            //首先找到需要被刪除的節點和其父節點
            while (true)
            {
                if (key < current.data)
                {
                    if (current.left == null) break;
                    parent = current;
                    current = current.left;
                }
                else if (key > current.data)
                {
                    if (current == null) break;
                    parent = current;
                    current = current.right;
                }
                else
                {
                    break;
                }
            }

            //找到被刪除的節點後，分四種情況

            //1.當是子節點的時候，直接刪除
            if (current.left == null && current.right == null)
            {
                if (current == rootNode && rootNode.left == null && rootNode.right == null)
                {
                    rootNode = null;
                }
                else if (current.data < parent.data)
                {
                    parent.left = null;
                }
                else
                {
                    parent.right = null;
                }
            }
             //所刪除的節點只有左節點的時
            else if (current.left != null && current.right == null)
            {
                if (current.data < parent.data)
                    parent.left = current.left;
                else
                    parent.right = current.left;
            }
            //所刪除的節點只有右節點時
            else if (current.left == null && current.right != null)
            {
                if (current.data < parent.data)
                    parent.left = current.right;
                else
                    parent.right = current.right;
            }
            //當刪除的節點有左右節點的時候
            else
            {
                //current是被刪除的節點，temp是被刪左子樹最右邊的節點
                Node temp;
                //先判斷是父節點的左節點還是右節點
                if (current.data < parent.data)
                {
                    parent.left = current.left;
                    temp = current.left;
                    //尋找被刪除節點最深的右孩子
                    while (temp.right != null)
                    {
                        temp = temp.right;
                    }
                    temp.right = current.right;
                }
                //右節點
                else if (current.data > parent.data)
                {
                    parent.right = current.left;
                    temp = current.left;
                    //尋找被刪除節點最深的左孩子
                    while (temp.left != null)
                    {
                        temp = temp.left;
                    }
                    temp.right = current.right;
 
點選開啟連結
                }
                //當被刪節點是根節點，並且有兩個孩子時
                else
                {
                    temp = current.left;
                    while (temp.right != null)
                    {
                        temp = temp.right;
                    }
                    temp.right = rootNode.right;
                    rootNode = current.left;
                }
            }

            return current;
        }
    }