算法-二叉树查找排序

二叉树

用C#实现二叉树

二叉树的插入

 public static void InsertNode(int data)
        {
            NodeTest newNode = new NodeTest(data);
            NodeTest parentNode;
            if (rootNode == null)
            {
                rootNode = new NodeTest(data);
            }
            else
            {
                NodeTest current = rootNode;
                while (true)
                {
                    parentNode = current;
                    if (newNode.data < current.data)//左边插入
                    {
                        current = current.leftNode;
                        if (current == null)
                        {
                            parentNode.leftNode = newNode;
                            break;
                        }
                    }
                    else if (newNode.data > current.data)//从右边插入
                    {
                        current = current.rightNode;
                        if (current == null)
                        {
                            parentNode.rightNode = newNode;
                            break;
                        }
                    }
                }
            }
        }

二叉树的遍历

 //中序遍历二叉树,首先遍历左节点，然后是根节点，然后是右子树
        public static void BeRootSerach(NodeTest theRoot)
        {
            if (theRoot != null)
            {
                BeRootSerach(theRoot.leftNode);
                theRoot.DisplayNode();
                BeRootSerach(theRoot.rightNode);
            }
        }
        //先序遍历二叉树，首先遍历根节点，然后是左子树，然后是右子树
        public static void PreRootSearch(NodeTest theroot)
        {
            if (theroot != null)
            {
                theroot.DisplayNode();
                PreRootSearch(theroot.leftNode);
                PreRootSearch(theroot.rightNode);
            }
        }
        //后序遍历二叉树，首先遍历左子树，再遍历右子树，最后是遍历根节点
        public static void AfRootSearch(NodeTest theroot)
        {
            if (theroot != null)
            {
                AfRootSearch(theroot.leftNode);
                AfRootSearch(theroot.rightNode);
                theroot.DisplayNode();
            }
        }

二叉树的查找最大节点值和最小节点值

//查找最大节点值，那就是根节点
        public static int  FindMax()
        {
            NodeTest current;
            NodeTest parent;
            if (rootNode != null)
            {
                parent = rootNode;
                while (true)
                {
                    current = parent.rightNode;
                    if (current!= null)
                    {
                        parent = current;
                    }
                    else
                        break;
                }
                return parent.data;
            }
            return 0;
        }
        //查找最小节点值，左子树的最左
        public static int FindMin()
        {
            NodeTest current;
            NodeTest parent;
            if (rootNode != null)
            {
                parent = rootNode;
                while (true)
                {
                    current = parent.leftNode;
                    if (current != null)
                    {
                        parent = current.leftNode;
                    }
                    else
                        break;
                }
                return parent.data;
            }
            return 0;
        }

查找二叉树所在的位置

public static NodeTest Search(int k)
        {
            NodeTest parent;
            if (rootNode == null)
                return null;
            else
            {
                parent = rootNode;
                while (true)
                {
                    if (parent != null)
                    {
                        if (k > parent.data)//去右边查找
                        {
                            parent = parent.rightNode;
                        }
                        else if (k < parent.data)
                        {
                            parent = parent.leftNode;
                        }
                        else if (k == parent.data)
                        {
                            return parent;
                        }
                        else
                            return null;
                    }
                    else
                        return null;
                }
            }
        }

二叉树的删除

//考虑四种情况
//1.被删节点无左右子节点
//2、被删节点有左子树
//3、被删节点有右子树
//4、被删节点位根节点

     public static void delNode(int K)
        {
            NodeTest current=rootNode;
            NodeTest parent=rootNode;
            //找到要删除的节点所在的位置
            while (true)
            {
                if (K < current.data)//向左查找
                {
                    if (current.leftNode == null)
                        break;
                    parent = current;
                    current = parent.leftNode;
                }
                else if (K > current.data)
                {
                    if (current.rightNode == null)
                        break;
                    parent = current;
                    current = parent.rightNode;
                }
                else//找到了
                    break;
            }
            if (current.leftNode == null && current.rightNode == null)//下面没有节点
            {
                if (parent.rightNode.data == K)
                {
                    parent.rightNode = null;
                }
                else if (parent.leftNode.data == K)
                {
                    parent.leftNode = null;
                }
            }
            else if (current.leftNode != null && current.rightNode == null)//只有左子树
            {
                if (current.data < parent.data)
                    parent.leftNode = current.leftNode;
                else
                    parent.rightNode = current.rightNode;
            }
            else if (current.rightNode != null && current.leftNode == null)//只有右子树
            {
                if (current.data < parent.data)
                    parent.leftNode = current.rightNode;
                else
                    parent.rightNode = current.rightNode;
            }
            else if (current.rightNode != null && current.leftNode != null)//左右子树都存在的时候
            {
                NodeTest temp;
                temp = current.leftNode;
                //先判断是左子树还是右子树
                if (current.data < parent.data)//左子树
                {
                    parent.leftNode = current.leftNode;
                    temp = current.leftNode;
                    while (temp != null)//寻找最深的右子树，将空缺的右子树挂接在这里
                        temp = temp.rightNode;
                    temp.rightNode = current.rightNode;
                }
                else if (current.data > parent.data)//右子树
                {
                    parent.rightNode = current.leftNode;
                    temp = current.leftNode;
                    while (temp.leftNode != null)
                        temp = temp.leftNode;
                    temp.rightNode = current.rightNode;
                }
            }
        }

主要记住的是二叉树的性质
左边的都是比根节点小的，右边的都是比根节点大的，这样无论是查找还是删除都是基于这一性质进行的。