剑指Offer-26-复杂链表的复制

原创 2015年11月21日 11:27:01

题目:
有一个复杂链表,其结点除了有一个m_pNext指针指向下一个结点外,还有一个m_pSibling指向链表中的任一结点或者NULL。其结点的C++定义如下:
struct ComplexNode
{
int m_nValue;
ComplexNode* m_pNext;
ComplexNode* m_pSibling;
};
这里写图片描述
请完成函数ComplexNode* Clone(ComplexNode* pHead),以复制一个复杂链表。

第一种方法:
分成两步:第一步是复制原始链表上的每个链表,并用m_pNext链接起来。第二步,假设原始链表中的某节点N的m_pSibling指向结点S。由于S的位置在链表上有可能在N的前面也可能在N的后面,所以要定位N的位置我们需要从原始链表的头结点开始找。假设从原始链表的头结点开始经过s步找到结点S。那么在复制链表上结点N的m_pSibling的S’,离复制链表的头结点的距离也是s。用这种办法我们就能为复制链表上的每个结点设置m_pSibling了。
对一个含有n个结点的链表,由于定位每个结点的m_pSibling,都需要从链表头结点开始经过O(n)步才能找到,因此这种方法的总时间复杂度是O(n2)。

下一篇将使用o(n)复杂度的算法,实现该功能。

#include <iostream>
using namespace std;

struct ComplexListNode {
    int m_nValue;
    ComplexListNode* m_pNext;
    ComplexListNode* m_pSibling;
};

/**
 * 使用一般方式进行复制,时间复杂度o(n*n)
 */
ComplexListNode* clone(ComplexListNode *pHead) {
    if(pHead == NULL)
        return NULL;
    ComplexListNode *pNewHead = new ComplexListNode();
    pNewHead->m_nValue = pHead->m_nValue;
    pNewHead->m_pNext = NULL;
    pNewHead->m_pSibling = NULL;

    ComplexListNode *p = pHead->m_pNext;
    ComplexListNode *preNewP = pNewHead;

    //第一步:复制原始链表的每一个结点,按照p->m_pNext连接起来
    while(p) {
        ComplexListNode *newP = new ComplexListNode();
        newP->m_nValue = p->m_nValue;
        newP->m_pNext = NULL;
        newP->m_pSibling = NULL;

        preNewP->m_pNext = newP;
        preNewP = newP;

        p=p->m_pNext;
    }

    p = pHead;
    ComplexListNode *newp = pNewHead;
    //第二步:设置每个结点的m_pSibling指针
    //如果原始链表的头结点开始沿着m_pNext经过s步找到结点S,那么复制链表上结点N的N'的m_pSibling(S')
    //离复制链表的头结点的距离也是沿着m_pNext指针s步。
    while(p) {
        if(p->m_pSibling != NULL) {
            ComplexListNode *sibling = pHead;
            ComplexListNode *newSibling = pNewHead;
            while(sibling != p->m_pSibling) {
                sibling = sibling->m_pNext;
                newSibling = newSibling->m_pNext;
            }
            newp->m_pSibling = newSibling;
        }
        p = p->m_pNext;
        newp = newp->m_pNext;
    }
    return pNewHead;
}



ComplexListNode* CreateNode(int nValue)
{
    ComplexListNode* pNode = new ComplexListNode();

    pNode->m_nValue = nValue;
    pNode->m_pNext = NULL;
    pNode->m_pSibling = NULL;

    return pNode;
}

void BuildNodes(ComplexListNode* pNode, ComplexListNode* pNext, ComplexListNode* pSibling)
{
    if(pNode != NULL)
    {
        pNode->m_pNext = pNext;
        pNode->m_pSibling = pSibling;
    }
}

void PrintList(ComplexListNode* pHead)
{
    ComplexListNode* pNode = pHead;
    while(pNode != NULL)
    {
        cout<<"The value of this node is:"<<pNode->m_nValue<<".";

        if(pNode->m_pSibling != NULL)
            cout<<"The value of its sibling is:"<<pNode->m_pSibling->m_nValue<<".";
        else
            cout<<"This node does not have a sibling.";

        cout<<endl;

        pNode = pNode->m_pNext;
    }
}

// ====================测试代码====================
void Test(char* testName, ComplexListNode* pHead)
{
    if(testName != NULL)
        cout<<testName;

    cout<<"The original list is:"<<endl;
    PrintList(pHead);

    ComplexListNode* pClonedHead = clone(pHead);

    cout<<"The cloned list is:"<<endl;
    PrintList(pClonedHead);
}

//          -----------------
//         \|/              |
//  1-------2-------3-------4-------5
//  |       |      /|\             /|\
//  --------+--------               |
//          -------------------------
void Test1()
{
    ComplexListNode* pNode1 = CreateNode(1);
    ComplexListNode* pNode2 = CreateNode(2);
    ComplexListNode* pNode3 = CreateNode(3);
    ComplexListNode* pNode4 = CreateNode(4);
    ComplexListNode* pNode5 = CreateNode(5);

    BuildNodes(pNode1, pNode2, pNode3);
    BuildNodes(pNode2, pNode3, pNode5);
    BuildNodes(pNode3, pNode4, NULL);
    BuildNodes(pNode4, pNode5, pNode2);

    Test("Test1", pNode1);
}

// m_pSibling指向结点自身
//          -----------------
//         \|/              |
//  1-------2-------3-------4-------5
//         |       | /|\           /|\
//         |       | --             |
//         |------------------------|
void Test2()
{
    ComplexListNode* pNode1 = CreateNode(1);
    ComplexListNode* pNode2 = CreateNode(2);
    ComplexListNode* pNode3 = CreateNode(3);
    ComplexListNode* pNode4 = CreateNode(4);
    ComplexListNode* pNode5 = CreateNode(5);

    BuildNodes(pNode1, pNode2, NULL);
    BuildNodes(pNode2, pNode3, pNode5);
    BuildNodes(pNode3, pNode4, pNode3);
    BuildNodes(pNode4, pNode5, pNode2);

    Test("Test2", pNode1);
}

// m_pSibling形成环
//          -----------------
//         \|/              |
//  1-------2-------3-------4-------5
//          |              /|\
//          |               |
//          |---------------|
void Test3()
{
    ComplexListNode* pNode1 = CreateNode(1);
    ComplexListNode* pNode2 = CreateNode(2);
    ComplexListNode* pNode3 = CreateNode(3);
    ComplexListNode* pNode4 = CreateNode(4);
    ComplexListNode* pNode5 = CreateNode(5);

    BuildNodes(pNode1, pNode2, NULL);
    BuildNodes(pNode2, pNode3, pNode4);
    BuildNodes(pNode3, pNode4, NULL);
    BuildNodes(pNode4, pNode5, pNode2);

    Test("Test3", pNode1);
}

// 只有一个结点
void Test4()
{
    ComplexListNode* pNode1 = CreateNode(1);
    BuildNodes(pNode1, NULL, pNode1);

    Test("Test4", pNode1);
}

// 鲁棒性测试
void Test5()
{
    Test("Test5", NULL);
}

int main() {
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    return 0;
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

剑指Offer-26-复杂链表的复制-优化

前面文章所使用的方法时间主要花费在定位结点的m_pSibling上面,我们试着在这方面去做优化。 我们还是分为两步: 第一步仍然是复制原始链表上的每个结点N,并创建N’,然后把这些创建出来的结点链...
  • qing0706
  • qing0706
  • 2015年11月21日 11:58
  • 132

【面试题】剑指Offer-26-复杂链表的复制

题目概述
  • qq_31828515
  • qq_31828515
  • 2017年04月10日 10:41
  • 158

剑指Offer_25_复杂链表的复制

题目描述输入一个复杂链表(每个节点中有节点值,以及两个指针,一个指向下一个节点,另一个特殊指针指向任意一个节点),返回结果为复制后复杂链表的head。(注意,输出结果中请不要返回参数中的节点引用,否则...
  • ggmfengyangdi
  • ggmfengyangdi
  • 2016年08月17日 09:34
  • 87

剑指Offer-复杂链表的复制

题目描述输入一个复杂链表(每个节点中有节点值,以及两个指针,一个指向下一个节点,另一个特殊指针指向任意一个节点),返回结果为复制后复杂链表的head。(注意,输出结果中请不要返回参数中的节点引用,否则...
  • wangyang1354
  • wangyang1354
  • 2017年06月20日 13:08
  • 250

剑指Offer--复杂链表的复制

复制复杂链表
  • strongyoung88
  • strongyoung88
  • 2015年10月20日 20:35
  • 319

剑指Offer--026-复杂链表的复制

链接 牛客OJ:复杂链表的复制 九度OJ:http://ac.jobdu.com/problem.php?pid=1524 GitHub代码: 026-复杂链表的复制 ...
  • gatieme
  • gatieme
  • 2016年04月23日 20:02
  • 3678

剑指offer--复杂链表的复制

题目描述 输入一个复杂链表(每个节点中有节点值,以及两个指针,一个指向下一个节点,另一个特殊指针指向任意一个节点)。 /* public class RandomListNode { in...
  • kangaroo835127729
  • kangaroo835127729
  • 2015年04月11日 22:13
  • 1022

剑指offer-26复杂链表的复制

输入一个复杂链表(每个节点中有节点值,以及两个指针,一个指向下一个节点,另一个特殊指针指向任意一个节点)。 /* struct RandomListNode { int label; ...
  • lw952799980
  • lw952799980
  • 2016年05月26日 22:32
  • 133

剑指offer---复杂链表的复制

题目描述 输入一个复杂链表(每个节点中有节点值,以及两个指针,一个指向下一个节点,另一个特殊指针指向任意一个节点),返回结果为复制后复杂链表的head。(注意,输出结果中请不要返回参数中的节点引...
  • qq_22238021
  • qq_22238021
  • 2017年10月01日 21:22
  • 46

剑指offer-25.复杂链表的复制

题目:输入一个复杂链表(每个节点中有节点值,以及两个指针,一个指向下一个节点,另一个特殊指针指向任意一个节点),返回结果为复制后复杂链表的head。(注意,输出结果中请不要返回参数中的节点引用,否则判...
  • I_love_blog
  • I_love_blog
  • 2017年04月29日 19:42
  • 469
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:剑指Offer-26-复杂链表的复制
举报原因:
原因补充:

(最多只允许输入30个字)