一、題目：兩個連結串列的第一個公共節點

題目：輸入兩個連結串列，找出它們的第一個公共結點。

　　連結串列結點定義如下，這裡使用C#語言描述：

    public class Node
    {
        public int key;
        public Node nextNode;

        public Node(int key)
        {
            this.key = key;
        }
    }

二、解題思路

2.1 蠻力法

　　碰到這道題，很多人的第一反應就是蠻力法：在第一連結串列上順序遍歷每個結點，每遍歷到一個結點的時候，在第二個連結串列上順序遍歷每個結點。如果在第二個連結串列上有一個結點和第一個連結串列上的結點一樣，說明兩個連結串列在這個結點上重合，於是就找到了它們的公共結點。如果第一個連結串列的長度為m，第二個連結串列的長度為n，顯然該方法的時間複雜度是O(mn)

2.2 藉助外部空間法

　　首先，經過分析我們發現兩個有公共結點而部分重合的連結串列，拓撲形狀看起來像一個Y，而不可能像X，如下圖所示，兩個連結串列在值為6的結點處交匯：

　　如果兩個連結串列有公共結點，那麼公共結點出現在兩個連結串列的尾部。如果我們從兩個連結串列的尾部開始往前比較，最後一個相同的結點就是我們要找的結點。But，在單鏈表中只能從頭結點開始按順序遍歷，最後才能到達尾結點。最後到達的尾結點卻要最先被比較，這是“後進先出”的特性。於是，我們可以使用棧的特點來解決這個問題：分別把兩個連結串列的結點放入兩個棧裡，這樣兩個連結串列的尾結點就位於兩個棧的棧頂，接下來比較兩個棧頂的結點是否相同。如果相同，則把棧頂彈出接著比較下一個棧頂，直到找到最後一個相同的結點

    public static Node FindFirstCommonNode(Node head1, Node head2)
    {
        if(head1 == null || head2 == null)
        {
            return null;
        }

        Stack<Node> stack1 = new Stack<Node>();
        Stack<Node> stack2 = new Stack<Node>();

        
 
while(head1 != null)
        {
            stack1.Push(head1);
            head1 = head1.nextNode;
        }

        while(head2 != null)
        {
            stack2.Push(head2);
            head2 = head2.nextNode;
        }

        Node node1 = null;
        Node node2 = null;
        Node common = null;

        while(stack1.Count > 0 && stack2.Count > 0)
        {
            node1 = stack1.Peek();
            node2 = stack2.Peek();

            if (node1.key == node2.key)
            {
                common = node1;
                stack1.Pop();
                stack2.Pop();
            }
            else
            {
                break;
            }
        }

        return common;
    }

　　在上述思路中，我們需要用兩個輔助棧。如果連結串列的長度分別為m和n，那麼空間複雜度是O(m+n)。這種思路的時間複雜度也是O(m+n)。和最開始的蠻力法相比，時間效率得到了提高，相當於是用空間消耗換取了時間效率。

2.3 不借助外部空間法

　　那麼，可不可以不借助棧來實現了呢？答案是可以的，我們可以首先遍歷兩個連結串列得到它們的長度，就能知道哪個連結串列比較長，以及長的連結串列比短的連結串列多幾個結點。在第二次遍歷的時候，在較長的連結串列上先走若干步，接著再同時在兩個連結串列上遍歷，找到的第一個相同的結點就是它們的第一個公共結點。

　　比如在上圖的兩個連結串列中，我們可以先遍歷一次得到它們的長度分別為5和4，也就是較長的連結串列與較短的連結串列相比多一個結點。第二次先在長的連結串列上走1步，到達結點2。接下來分別從結點2和結點4出發同時遍歷兩個結點，直到找到它們第一個相同的結點6，這就是我們想要的結果。

    public static Node FindFirstCommonNode(Node head1, Node head2)
    {
        // 得到兩個連結串列的長度
        int length1 = GetListLength(head1);
        int length2 = GetListLength(head2);
        int diff = length1 - length2;

        Node headLong = head1;
        Node headShort = head2;
        if (diff < 0)
        {
            headLong = head2;
            headShort = head1;
            diff = length2 - length1;
        }
        // 先在長連結串列上走幾步
        for (int i = 0; i < diff; i++)
        {
            headLong = headLong.nextNode;
        }
        // 再同時在兩個連結串列上遍歷
        while (headLong != null && headShort != null && headLong != headShort)
        {
            headLong = headLong.nextNode;
            headShort = headShort.nextNode;
        }

        Node commonNode = headLong;
        return commonNode;
    }

    private static int GetListLength(Node head)
    {
        int length = 0;
        Node tempNode = head;
        while (tempNode != null)
        {
            tempNode = tempNode.nextNode;
            length++;
        }

        return length;
    }

　　上述思路與藉助棧的方法的時間複雜度都是O(m+n)，但我們不再需要輔助的棧，因此提高了空間效率。

三、單元測試

3.1 測試用例：功能測試與特殊輸入測試

    [TestClass]
    public class CommonNodeHelperTest
    {
        private void DestoryNode(Node node)
        {
            if (node != null)
            {
                node = null;
            }
        }

        // 第一個公共結點在連結串列中間
        // 1 - 2 - 3 \
        //            6 - 7
        //     4 - 5 /
        [TestMethod]
        public void FindTest1()
        {
            Node node1 = new Node(1);
            Node node2 = new Node(2);
            Node node3 = new Node(3);
            Node node4 = new Node(4);
            Node node5 = new Node(5);
            Node node6 = new Node(6);
            Node node7 = new Node(7);

            // first
            node1.nextNode = node2;
            node2.nextNode = node3;
            node3.nextNode = node6;
            node6.nextNode = node7;
            // second
            node4.nextNode = node5;
            node5.nextNode = node6;

            Node actual = CommonNodeHelper.FindFirstCommonNode(node1, node4);
            Assert.AreEqual(actual.key, 6);

            DestoryNode(node1);
            DestoryNode(node2);
            DestoryNode(node3);
            DestoryNode(node4);
            DestoryNode(node5);
            DestoryNode(node6);
            DestoryNode(node7);
        }

        // 沒有公共結點
        // 1 - 2 - 3 - 4
        //            
        // 5 - 6 - 7
        [TestMethod]
        public void FindTest2()
        {
            Node node1 = new Node(1);
            Node node2 = new Node(2);
            Node node3 = new Node(3);
            Node node4 = new Node(4);
            Node node5 = new Node(5);
            Node node6 = new Node(6);
            Node node7 = new Node(7);

            // first
            node1.nextNode = node2;
            node2.nextNode = node3;
            node3.nextNode = node4;
            
            // second
            node5.nextNode = node6;
            node6.nextNode = node7;

            Node actual = CommonNodeHelper.FindFirstCommonNode(node1, node5);
            Assert.AreEqual(actual, null);

            DestoryNode(node1);
            DestoryNode(node2);
            DestoryNode(node3);
            DestoryNode(node4);
            DestoryNode(node5);
            DestoryNode(node6);
            DestoryNode(node7);
        }

        // 公共結點是最後一個結點
        //         5 - 6 \
        //                7
        // 1 - 2 - 3 - 4 /
        [TestMethod]
        public void FindTest3()
        {
            Node node1 = new Node(1);
            Node node2 = new Node(2);
            Node node3 = new Node(3);
            Node node4 = new Node(4);
            Node node5 = new Node(5);
            Node node6 = new Node(6);
            Node node7 = new Node(7);

            // first
            node1.nextNode = node2;
            node2.nextNode = node3;
            node3.nextNode = node4;
            node4.nextNode = node7;
            // second
            node5.nextNode = node6;
            node6.nextNode = node7;

            Node actual = CommonNodeHelper.FindFirstCommonNode(node5, node1);
            Assert.AreEqual(actual.key, 7);

            DestoryNode(node1);
            DestoryNode(node2);
            DestoryNode(node3);
            DestoryNode(node4);
            DestoryNode(node5);
            DestoryNode(node6);
            DestoryNode(node7);
        }

        // 公共結點是第一個結點
        // 1 - 2 - 3 - 4 - 5
        // 兩個連結串列完全重合   
        [TestMethod]
        public void FindTest4()
        {
            Node node1 = new Node(1);
            Node node2 = new Node(2);
            Node node3 = new Node(3);
            Node node4 = new Node(4);
            Node node5 = new Node(5);
            Node node6 = new Node(6);
            Node node7 = new Node(7);

            // first & second
            node1.nextNode = node2;
            node2.nextNode = node3;
            node3.nextNode = node4;
            node4.nextNode = node5;

            Node actual = CommonNodeHelper.FindFirstCommonNode(node1, node1);
            Assert.AreEqual(actual.key, 1);

            DestoryNode(node1);
            DestoryNode(node2);
            DestoryNode(node3);
            DestoryNode(node4);
            DestoryNode(node5);
            DestoryNode(node6);
            DestoryNode(node7);
        }

        // 輸入的兩個連結串列有一個空連結串列
        [TestMethod]
        public void FindTest5()
        {
            Node node1 = new Node(1);
            Node node2 = new Node(2);
            Node node3 = new Node(3);
            Node node4 = new Node(4);
            Node node5 = new Node(5);

            // first & second
            node1.nextNode = node2;
            node2.nextNode = node3;
            node3.nextNode = node4;
            node4.nextNode = node5;

            Node actual = CommonNodeHelper.FindFirstCommonNode(node1, null);
            Assert.AreEqual(actual, null);

            DestoryNode(node1);
            DestoryNode(node2);
            DestoryNode(node3);
            DestoryNode(node4);
            DestoryNode(node5);
        }

        // 輸入的兩個連結串列均為空連結串列
        [TestMethod]
        public void FindTest6()
        {
            Node actual = CommonNodeHelper.FindFirstCommonNode(null, null);
            Assert.AreEqual(actual, null);
        }
    }

3.2 測試結果：用例通過情況與程式碼覆蓋率

　　（1）用例通過情況

　　（2）程式碼覆蓋率

作者：周旭龍

本文版權歸作者和部落格園共有，歡迎轉載，但未經作者同意必須保留此段宣告，且在文章頁面明顯位置給出原文連結。