• 算法大全(3) 二叉树


    声明,本文所有11道算法题目,覆盖了基本上所有常见的二叉树问题,全都用C#实现,并测试通过,代码下载:BinNode.zip

    目录:

    1.二叉树三种周游(traversal)方式:

    2.怎样从顶部开始逐层打印二叉树结点数据

    3.如何判断一棵二叉树是否是平衡二叉树

    4.设计一个算法,找出二叉树上任意两个节点的最近共同父结点,复杂度如果是O(n2)则不得分。

    5.如何不用递归实现二叉树的前序/后序/中序遍历?

    6.在二叉树中找出和为某一值的所有路径

    7.怎样编写一个程序,把一个有序整数数组放到二叉树中?

    8.判断整数序列是不是二叉搜索树的后序遍历结果

    9.求二叉树的镜像

    10.一棵排序二叉树(即二叉搜索树BST),令 f=(最大值+最小值)/2,设计一个算法,找出距离f值最近、大于f值的结点。复杂度如果是O(n2)则不得分。

    11.把二叉搜索树转变成排序的双向链表

    首先写一个二叉树的C#实现,这是我们的基石:

    public class BinNode
    {
        public int Element;
        public BinNode Left;
        public BinNode Right;
        public BinNode(int element, BinNode left, BinNode right)
        {
            this.Element = element;
            this.Left = left;
            this.Right = right;
        }
        
        public bool IsLeaf()
        {
            return this.Left == null && this.Right == null;
        }
    }

    1.二叉树三种周游(traversal)方式:

    1)前序周游(preorder):节点 –> 子节点Left(包括其子树) –> 子节点Right(包括其子树)

    static void PreOrder(BinNode root)
    {
        if (root == null)
            return;
        //visit current node
        Console.WriteLine(root.Element);
        PreOrder(root.Left);
        PreOrder(root.Right);
    }

    2)后序周游(postorder):子节点Left(包括其子树) –> 子节点Right(包括其子树) –> 节点

    static void PostOrder(BinNode root)
    {
        if (root == null)
            return;
        PostOrder(root.Left);
        PostOrder(root.Right);
        //visit current node
        Console.WriteLine(root.Element);
    }

    3)中序周游(inorder):子节点Left(包括其子树) –> 节点 –> 子节点Right(包括其子树)

    static void InOrder(BinNode root)
    {
        if (root == null)
            return;
        InOrder(root.Left);
        //visit current node
        Console.WriteLine(root.Element);
        InOrder(root.Right);
    }

    我们发现,三种周游的code实现,仅仅是访问当前节点的这条语句所在位置不同而已。

    2.怎样从顶部开始逐层打印二叉树结点数据

    有2种算法:

    算法1:基于Queue来实现,也就是广度优先搜索(BFS)的思想

    static void PrintTree1(BinNode root)
    {
        if (root == null) return;
        BinNode tmp = null;
        Queue queue = new Queue();
        queue.Enqueue(root);
        while (queue.Count > 0)
        {
            tmp = (BinNode)queue.Dequeue();
            Console.WriteLine(tmp.Element);
            if (tmp.Left != null)
                queue.Enqueue(tmp.Left);
            if (tmp.Right != null)
                queue.Enqueue(tmp.Right);
        }
    }

    话说,BFS和DFS思想本来是用于图的,但我们不能被传统的思维方式所束缚。

    算法2:基于单链表实现

    如果没有Queue给我们用,我们只好使用单链表,把每个节点存在单链表的Data中,实现如下:

    public class Link
    {
        public Link Next;
        public BinNode Data;
        public Link(Link next, BinNode data)
        {
            this.Next = next;
            this.Data = data;
        }
    }

    看过了Queue的实现,我们发现永远是先出队1个(队头),然后入队2个(把出队的Left和Right放到队尾)。

    对于单链表而言,我们可以先模拟入队——把first的Data所对应的Left和Right,先后插到second的后面,即 second.Next和second.Next.Next位置,同时second向前走0、1或2次,再次到达链表末尾,这取决于Left和Right 是否为空;然后我们模拟出队——first前进1步。

    当first指针走不下去了,那么任务也就结束了。

    static void PrintTree2(BinNode root)
    {
        if (root == null) return;
        Link head = new Link(null, root);
        Link first = head;
        Link second = head;
        while (first != null)
        {
            if (first.Data.Left != null)
            {
                second.Next = new Link(null, first.Data.Left);
                second = second.Next;
            }
            if (first.Data.Right != null)
            {
                second.Next = new Link(null, first.Data.Right);
                second = second.Next;
            }
            Console.WriteLine(first.Data.Element);
            first = first.Next;
        }
    }

    3.如何判断一棵二叉树是否是平衡二叉树

    平衡二叉树的定义,如果任意节点的左右子树的深度相差不超过1,那这棵树就是平衡二叉树。

    算法思路:先编写一个计算二叉树深度的函数GetDepth,利用递归实现;然后再递归判断每个节点的左右子树的深度是否相差1

    static int GetDepth(BinNode root)
    {
        if (root == null)
            return 0;
        int leftLength = GetDepth(root.Left);
        int rightLength = GetDepth(root.Right);
        return (leftLength > rightLength ? leftLength : rightLength) + 1;
    }

    注意这里的+1,对应于root不为空(算作当前1个深度)

    static bool IsBalanceTree(BinNode root)
    {
        if (root == null)
            return true;
        int leftLength = GetDepth(root.Left);
        int rightLength = GetDepth(root.Right);
        int distance = leftLength > rightLength ? leftLength - rightLength : rightLength - leftLength;
        
        if (distance > 1)
            return false;
        else 
            return IsBalanceTree(root.Left) && IsBalanceTree(root.Right);
    }
     

    上述程序的逻辑是,只要当前节点root的Left和Right深度差不超过1,就递归判断Left和Right是否也符合条件,直到为Left或Right为null,这意味着它们的深度为0,能走到这一步,前面必然都符合条件,所以整个二叉树都符合条件。

    4.设计一个算法,找出二叉树上任意两个节点的最近共同父结点,复杂度如果是O(n2)则不得分。

    本题网上有很多算法,都不怎么样。这里提出包氏的两个算法:

    算法1:做一个容器,我们在遍历二叉树寻找节点的同时,把从根到节点的路径扔进去(两个节点就是两个容器)。由于根节点最后一个被扔进去,但我们接下来又需要第一个就能访问到它——后进先出,所以这个容器是一个栈。时间复杂度O(N),空间复杂度O(N)。

    static bool GetPositionByNode(BinNode root, BinNode node, ref Stack stack)
    {
        if (root == null)
            return false;
        if (root == node)
        {
            stack.Push(root);
            return true;
        }
        if (GetPositionByNode(root.Left, node, ref stack) || GetPositionByNode(root.Right, node, ref stack))
        {
            stack.Push(root);
            return true;
        }
        return false;
    }

    然后我们要同时弹出这两个容器的元素,直到它们不相等,那么之前那个相等的元素就是我们要求的父亲节点。

    static BinNode FindParentNode(BinNode root, BinNode node1, BinNode node2)
    {
        Stack stack1 = new Stack();
        GetPositionByNode(root, node1, ref stack1);
        Stack stack2 = new Stack();
        GetPositionByNode(root, node2, ref stack2);
        BinNode tempNode = null;
        while (stack1.Peek() == stack2.Peek())
        {
            tempNode = (BinNode)stack1.Pop();
            stack2.Pop();
        }
        return tempNode;
    }

    算法2:如果要求o(1)的空间复杂度,就是说,只能用一个变量来辅助我们。

    我们选择一个64位的整数,然后从1开始,从左到右逐层为二叉树的每个元素赋值,root对应1,root.Left对应2,root.Right对应3,依次类推,而不管实际这个位置上是否有节点,我们发现两个规律:

    ////                                1

    ////                   2                         3

    ////           4             5           6             7

    ////       8     9      10

    如果要找的是5和9位置上的节点。

    我们发现,它们的二进制分别是101和1001,右移1001使之与101位数相同,于是1001变成了100(也就是9的父亲4)。

    这时101和100(也就是4和5位于同样的深度),我们从左往右找,101和100具有2位相同,即10,这就是我们要找的4和5的父亲,也就是9和5的最近父亲。

    由上面观察,得到算法:

    1)将找到的两个节点对应的数字

    static bool GetPositionByNode(BinNode root, BinNode node, ref int pos)
    {
        if (root == null)
            return false;
        if (root == node)
            return true;
        int temp = pos;
        //这么写很别扭,但是能保证只要找到就不再进行下去
        pos = temp * 2;
        if (GetPositionByNode(root.Left, node, ref pos))
        {
            return true;
        }
        else
        {
            //找不到左边找右边
            pos = temp * 2 + 1;
            return GetPositionByNode(root.Right, node, ref pos);
        }
    }

    2)它们的二进制表示,从左向右逐一比较,直到一个结束或不再相同,则最大的相同子串,就是我们需要得到的最近父亲所对应的位置K。

    static int FindParentPosition(int larger, int smaller)
    {
        if (larger == smaller) return larger;
        int left = GetLen(larger) - GetLen(smaller);
        while (left > 0)
        {
            larger = larger >> 1;
            left--;
        }
        while (larger != smaller)
        {
            larger = larger >> 1;
            smaller = smaller >> 1;
        }
        return smaller;
    }
    static int GetLen(int num)
    {
        int length = 0;
        while (num != 0)
        {
            num = num >> 1;
            length++;
        }
        return length;
    }

    3)第3次递归遍历,寻找K所对应的节点。

    函数GetNodeByPosition的思想是,先算出k在第几层power,观察k的二进制表示,比如说12,即1100,从左向右数第一个位1不算,还剩下100,1表示向右走,0表示向左走,于是从root出发,1->3->6->12。

    static BinNode GetNodeByPosition(BinNode root, int num)
    {
        if (num == 1) return root;
        int pow = (int)Math.Floor(Math.Log(num, 2)); //1 return 0, 2-3 return 1, 4-7 return 2
        //第一个位不算
        num -= 1 << pow;
        while (pow > 0)
        {
            if ((num & 1 << (pow - 1)) == 0)
                root = root.Left;
            else
                root = root.Right;
            pow--;
        }
        return root;
    }

    总结上面的3个步骤:

    static BinNode FindParentNode(BinNode root, BinNode node1, BinNode node2)
    {
        int pos1 = 1;
        GetPositionByNode(root, node1, ref pos1);
        int pos2 = 1;
        GetPositionByNode(root, node2, ref pos2);
        int parentposition = 0;
        if (pos1 >= pos2)
        {
            parentposition = FindParentPosition(pos1, pos2);
        }
        else //pos1<pos2
        {
            parentposition = FindParentPosition(pos2, pos1);
        }
        return GetNodeByPosition(root, parentposition);
    }

    5.如何不用递归实现二叉树的前序/后序/中序遍历?

    算法思想:三种算法的思想都是让root的Left的Left的Left全都入栈。所以第一个while循环的逻辑,都是相同的。

    下面详细分析第2个while循环,这是一个出栈动作,只要栈不为空,就始终要弹出栈顶元素,由于我们之前入栈的都是Left节点,所以每次在出栈的时候,我们都要考虑Right节点是否存在。因为前序/后序/中序遍历顺序的不同,所以在具体的实现上有略为区别。

    1)前序遍历

    这个是最简单的。

    前序遍历是root->root.Left->root.Right的顺序。

    因为在第一个while循环中,每次进栈的都可以认为是一个root,所以我们直接打印,然后root.Right和root.Left先后进栈,那么出栈的时候,就能确保先左后右的顺序。

    static void PreOrder(BinNode root)
    {
        Stack stack = new Stack();
        BinNode temp = root;
        //入栈
        while (temp != null)
        {
            Console.WriteLine(temp.Element);
            if (temp.Right != null)
                stack.Push(temp.Right);
            temp = temp.Left;
        }
        //出栈,当然也有入栈
        while (stack.Count > 0)
        {
            temp = (BinNode)stack.Pop();
            Console.WriteLine(temp.Element);
            while (temp != null)
            {
                if (temp.Right != null)
                    stack.Push(temp.Right);
                temp = temp.Left;
            }
        }
    }
    //后序遍历比较麻烦,需要记录上一个访问的节点,然后在本次循环中判断当前节点的Right或Left是否为上个节点,当前节点的Right为null表示没有右节点。
    static void PostOrder(BinNode root)
    {
        Stack stack = new Stack();
        BinNode temp = root;
        //入栈
        while (temp != null)
        {
            if (temp != null)
                stack.Push(temp);
            temp = temp.Left;
        }
        //出栈,当然也有入栈
        while (stack.Count > 0)
        {
            BinNode lastvisit = temp;
            temp = (BinNode)stack.Pop();
            if (temp.Right == null || temp.Right == lastvisit)
            {
                Console.WriteLine(temp.Element);
            }
            else if (temp.Left == lastvisit)
            {
                stack.Push(temp);
                temp = temp.Right;
                stack.Push(temp);
                while (temp != null)
                {
                    if (temp.Left != null)
                        stack.Push(temp.Left);
                    temp = temp.Left;
                }
            }
        }
    }
    //中序遍历,类似于前序遍历
    static void InOrder(BinNode root)
    {
        Stack stack = new Stack();
        BinNode temp = root;
        //入栈
        while (temp != null)
        {
            if (temp != null)
                stack.Push(temp);
            temp = temp.Left;
        }
        //出栈,当然也有入栈
        while (stack.Count > 0)
        {
            temp = (BinNode)stack.Pop();
            Console.WriteLine(temp.Element);
            if (temp.Right != null)
            {
                temp = temp.Right;
                stack.Push(temp);
                while (temp != null)
                {
                    if (temp.Left != null)
                        stack.Push(temp.Left);
                    temp = temp.Left;
                }
            }
        }
    }

    6.在二叉树中找出和为某一值的所有路径

    算法思想:这道题目的苦恼在于,如果用递归,只能打出一条路径来,其它符合条件的路径打不出来。

    为此,我们需要一个Stack,来保存访问过的节点,即在对该节点的递归前让其进栈,对该节点的递归结束后,再让其出栈——深度优先原则(DFS)。

    此外,在递归中,如果发现某节点(及其路径)符合条件,如何从头到尾打印是比较头疼的,因为DFS使用的是stack而不是queue,为此我们需要一个临时栈,来辅助打印。

    static void FindBinNode(BinNode root, int sum, Stack stack)
    {
        if (root == null)
            return;
        stack.Push(root.Element);
        //Leaf
        if (root.IsLeaf())
        {
            if (root.Element == sum)
            {
                Stack tempStack = new Stack();
                while (stack.Count > 0)
                {
                    tempStack.Push(stack.Pop());
                }
                while (tempStack.Count > 0)
                {
                    Console.WriteLine(tempStack.Peek());
                    stack.Push(tempStack.Pop());
                }
                Console.WriteLine();
            }
        }
        if (root.Left != null)
            FindBinNode(root.Left, sum - root.Element, stack);
        if (root.Right != null)
            FindBinNode(root.Right, sum - root.Element, stack);
        stack.Pop();
    }

    7.怎样编写一个程序,把一个有序整数数组放到二叉树中?

    算法思想:我们该如何构造这棵二叉树呢?当然是越平衡越好,如下所示:

             ////                 arr[0]
            ////       arr[1]               arr[2] 
            //// arr[3]    arr[4]      arr[5]     
    

    相应编码如下:

    public static void InsertArrayIntoTree(int[] arr, int pos, ref BinNode root)
    {
        root = new BinNode(arr[pos], null, null);
        root.Element = arr[pos];
        //if Left value less than arr length
        if (pos * 2 + 1 > arr.Length - 1)
        {
            return;
        }
        else
        {
            InsertArrayIntoTree(arr, pos * 2 + 1, ref root.Left);
        }
        //if Right value less than arr length
        if (pos * 2 + 2 > arr.Length - 1)
        {
            return;
        }
        else
        {
            root.Right = new BinNode(arr[pos * 2 + 2], null, null);
            InsertArrayIntoTree(arr, pos * 2 + 2, ref root.Right);
        }
    }
     

    8.判断整数序列是不是二叉搜索树的后序遍历结果

    比如,给你一个数组: int a[] = [1, 6, 4, 3, 5] ,则F(a) => false

    算法思想:在后续遍历得到的序列中,最后一个元素为树的根结点。从头开始扫描这个序列,比根结点小的元素都应该位于序列的左半部分;从第一个大于跟 结点开始到跟结点前面的一个元素为止,所有元素都应该大于跟结点,因为这部分元素对应的是树的右子树。根据这样的划分,把序列划分为左右两部分,我们递归 地确认序列的左、右两部分是不是都是二元查找树。

    由于不能使用动态数组,所以我们每次递归都使用同一个数组arr,通过start和length来模拟“部分”数组。

    public static bool VerifyArrayOfBST(int[] arr, int start, int length)
    {
        if (arr == null || arr.Length == 0 || arr.Length == 1)
        {
            return false;
        }
        int root = arr[length + start - 1];
        int i = start;
        for (; i < length - 1; i++)
        {
            if (arr[i] >= root)
                break;
        }
        int j = i;
        for (; j < length - 1; j++)
        {
            if (arr[j] < root)
                return false;
        }
        bool left = true;
        if (i > start)
        {
            left = VerifyArrayOfBST(arr, start, i - start);
        }
        bool right = true;
        if (j > i)
        {
            right = VerifyArrayOfBST(arr, i, j - i + 1);
        }
        return left && right;
    }

    9.求二叉树的镜像

    算法1:利用上述遍历二叉树的方法(比如说前序遍历),把访问操作修改为交换左右节点的逻辑:

    static void PreOrder(ref BinNode root)
    {
        if (root == null)
            return;
        //visit current node
        BinNode temp = root.Left;
        root.Left = root.Right;
        root.Right = temp;
        PreOrder(ref root.Left);
        PreOrder(ref root.Right);
    }

    算法2:使用循环也可以完成相同的功能。

    static void PreOrder2(ref BinNode root)
    {
        if (root == null)
            return;
        Stack stack = new Stack();
        stack.Push(root);
        while (stack.Count > 0)
        {
            //visit current node
            BinNode temp = root.Left;
            root.Left = root.Right;
            root.Right = temp;
    
            if (root.Left != null)
                stack.Push(root.Left);
            if (root.Right != null)
                stack.Push(root.Right);
        }
    }

    10.一棵排序二叉树(即二叉搜索树BST),令 f=(最大值+最小值)/2,设计一个算法,找出距离f值最近、大于f值的结点。复杂度如果是O(n2)则不得分。

    算法思想:最小最大节点分别在最左下与最右下节点,O(N)

    static BinNode Find(BinNode root)
    {
        BinNode min = FindMinNode(root);
        BinNode max = FindMaxNode(root);
        double find = (double)(min.Element + max.Element) / 2;
        return FindNode(root, find);
    }
    static BinNode FindMinNode(BinNode root)
    {
        BinNode min = root;
        while (min.Left != null)
        {
            min = min.Left;
        }
        return min;
    }
    static BinNode FindMaxNode(BinNode root)
    {
        BinNode max = root;
        while (max.Right != null)
        {
            max = max.Right;
        }
        return max;
    }
    递归寻找BST的节点,O(logN)。
    static BinNode FindNode(BinNode root, double mid)
    {           
        //如果小于相等,则从右边找一个最小值
        if (root.Element <= mid)
        {
            if (root.Right == null)
                return root;
            BinNode find = FindNode(root.Right, mid);
            //不一定找得到
            return find.Element < mid ? root : find;
        }
        //如果大于,则找到Left
        else  //temp.Element > find
        {
            if (root.Left == null)
                return root;
            BinNode find = FindNode(root.Left, mid);
            //不一定找得到
            return find.Element < mid ? root : find;
        }
    }  

    11.把二叉搜索树转变成排序的双向链表,如

    ////      13
    ////   10      15
    //// 5   11        17
    ////              16    22

    转变为Link:5=10=11=13=15=16=17=22

    算法思想:这个就是中序遍历啦,因为BST的中序遍历就是一个从小到大的访问顺序。局部修改中序遍历算法,于是有如下代码:

    static void ConvertNodeToLink(BinNode root, ref DoubleLink link)
    {
        if (root == null)
            return;
        BinNode temp = root;
        if (temp.Left != null)
            ConvertNodeToLink(temp.Left, ref link);
        //visit current node
        link.Next = new DoubleLink(link, null, root);
        link = link.Next;
        if (temp.Right != null)
            ConvertNodeToLink(temp.Right, ref link);
    }

    但是我们发现,这样得到的Link是指向双链表最后一个元素22,而我们想要得到的是表头5,为此,我们不得不额外进行while循环,将指针向前移动到表头:

    static DoubleLink ReverseDoubleLink(BinNode root, ref DoubleLink link)
    {
        ConvertNodeToLink(root, ref link);
        DoubleLink temp = link;
        while (temp.Prev != null)
        {
            temp = temp.Prev;
        }
        return temp;
    }
    这么写有点蠢,为什么不直接在递归中就把顺序反转呢?于是有算法2:
     
    算法2:观察算法1的递归方法,访问顺序是Left -> Root –> Right,所以我们要把访问顺序修改为Right -> Root –> Left。
    此外,算法的节点访问逻辑,是连接当前节点和新节点,同时指针link向前走,即5=10=11=13=15=16=17=22=link
    代码如下所示:
    link.Next = new DoubleLink(link, null, root);
    link = link.Next;
    那么,即使我们颠倒了访问顺序,新的Link也只是变为:22=17=16=15=13=11=10=5=link。
    为此,我们修改上面的节点访问逻辑——将Next和Prev属性交换:
    link.Prev = new DoubleLink(null, link, root);
    link = link.Prev;

    这样,新的Link就变成这样的顺序了:link=5=10=11=13=15=16=17=22

    算法代码如下所示:

    static void ConvertNodeToLink2(BinNode root, ref DoubleLink link)
    {
        if (root == null)
            return;
        BinNode temp = root;
        if (temp.Right != null)
            ConvertNodeToLink2(temp.Right, ref link);
        //visit current node
        link.Prev = new DoubleLink(null, link, root);
        link = link.Prev;
        if (temp.Left != null)
            ConvertNodeToLink2(temp.Left, ref link);
    }

    以下算法属于二叉树的基本概念,未列出:

    1.Huffman Tree的生成、编码和反编码

    2.BST的实现

    3.Heap的实现,优先队列

    4.非平衡二叉树如何变成平衡二叉树?

    http://www.cppblog.com/bellgrade/archive/2009/10/12/98402.html

    玩二叉树,基本都要用到递归算法。

    唉,对于递归函数,我一直纠结,到底要不要返回值?到底先干正事还是先递归?到底要不要破坏原来的数据结构?到底要不要额外做个 stack/queue/link/array来转存,还是说完全在递归里面实现?到底终结条件要写成什么样子? ref在递归里面貌似用的很多哦。

  • 相关阅读:
    The commands of Disk
    How to build a NFS Service
    Apache的dbutils的架构图
    Spring使用ThreadLocal解决线程安全问题
    NIO流程
    Servlet 生命周期、工作原理
    forward和redirect的区别
    笔记:Java 性能优化权威指南 第9、10、11章 GlassFish、Web应用、Web Service、EJB性能调优
    几个关于Java内存泄露方面的面试题
    MAT 检测 Java内存泄露检测
  • 原文地址:https://www.cnblogs.com/UnGeek/p/3327300.html
走看看 - 开发者的网上家园