这里的交叉链表,是Y型交叉链表。

话不多说,上代码:

首先定义一些用到的宏和链表节点,这里使用最简单的单向链表

#define ARRAY_SIZE(a) sizeof((a)) / sizeof((a)[0])
#define ABS(a) (a) > 0 ? (a) : (-(a))

typedef struct _Node 
{
    int data;
    _Node* pNext;
}Node, *PNode;

下面是建立链表函数:

/*
    新建链表
    若pTarget不为空,把新链表尾节点链到pTarget上
    若pTarget为空则新链表尾节点置空
*/
PNode BuildList(PNode pTarget, int data[], int num)
{
    PNode pHead = NULL;
    PNode pTail = NULL;
    PNode p = NULL;

    for (int i = 0; i < num; i++){
        if (pHead == NULL)
        {
            pHead = new Node();
            pHead->data = data[i];
            pHead->pNext = NULL;
            pTail = p = pHead;
        } else {
            p = new Node();
            p->data = data[i];
            p->pNext = NULL;
            pTail->pNext = p;
            pTail = p;
        }
    }

    if (pTail && pTarget){
        pTail->pNext = pTarget;
    }
    return pHead;
}

下面是遍历链表,打印所有节点数据的函数:

/*
    遍历链表
*/
void RecursiveList(PNode pHead)
{
    PNode p = pHead;
    while (p) {
        printf("%d---", p->data);
        p = p->pNext;
    }
}

下面建立两个链表:

int _tmain(int argc, _TCHAR* argv[])
{
    int data1[] = {1, 2, 3, 4, 5, 6, 7, 8, 10086};
    int data2[] = {11, 22, 33, 44, 55, 66, 77, 88};
    PNode pHeadList1 = NULL;
    PNode pHeadList2 = NULL;

    //
    // 建立链表1
    //
    pHeadList1 = BuildList(NULL, data1, ARRAY_SIZE(data1));
    RecursiveList(pHeadList1);
    printf("\n\n");

    //
    // 建立链表2
    //
    pHeadList2 = BuildList(NULL, data2, ARRAY_SIZE(data2));
    RecursiveList(pHeadList2);
    printf("\n\n");
}

输出结果如下:

img

下面,我们通过手动操作,让这两个链表构成Y型交叉链表:

int _tmain(int argc, _TCHAR* argv[])
{
    int data1[] = {1, 2, 3, 4, 5, 6, 7, 8, 10086};
    int data2[] = {11, 22, 33, 44, 55, 66, 77, 88};
    PNode pHeadList1 = NULL;
    PNode pHeadList2 = NULL;
    PNode pXXXNode = NULL;

    //
    // 建立链表1
    //
    pHeadList1 = BuildList(NULL, data1, ARRAY_SIZE(data1));
    RecursiveList(pHeadList1);
    printf("\n\n");

    //
    // 手动选取交叉节点
    //
    pXXXNode = pHeadList1->pNext->pNext->pNext;

    //
    // 建立链表2
    //
    pHeadList2 = BuildList(pXXXNode, data2, ARRAY_SIZE(data2));
    RecursiveList(pHeadList2);
    printf("\n\n");
}

这一次的输出结果如下:

img

可以发现,链表1与链表2在“4”这个节点相交了。

下面是比较常见的方法获取交点思路:

step 1: 使用两个指针指向两链表头,分别从头拨到尾,统计两个链表到终点的步数分别为 d1, d2。

step 2: 让两链表中距离交点远的一方指针先向后拨动 |d1-d2| 步,使两指针处于距离交点相同位置。

step 3: 然后两边指针同时向交点进发,每拨动一次就判断一次,看是否两指针指向了同一个点,若是,则到达交叉点

下面函数实现了上述算法:

/*
    方法一:找到链表相交点
*/
PNode FindIntersecNode(PNode ListLeft, PNode ListRight)
{
    PNode pNode_X = NULL;
    PNode pTailLeft = NULL;
    PNode pTailRight = NULL;
    PNode p = NULL;
    PNode q = NULL;

    int nStepLeft = 0;
    int nStepRight = 0;

    //
    // 遍历左边链表,统计步数,并定位尾节点
    //
    for (p = ListLeft; p; p = p->pNext) {
        nStepLeft++;
        pTailLeft = p;
    }

    //
    // 遍历右边链表,统计步数,并定位尾节点
    //
    for (p = ListRight; p; p = p->pNext) {
        nStepRight++;
        pTailRight = p;
    }

    //
    // 如果两链表尾节点不同,则两链表不相交
    //
    if (pTailLeft != pTailRight) {
        printf("These two list have no intersection.\n");
        return NULL;
    } else {
        //
        // 让步数多的一方先走 |nStepLeft - nStepRight| 步
        //
        p = nStepLeft > nStepRight ? ListLeft : ListRight;
        q = nStepLeft < nStepRight ? ListLeft : ListRight;
        int d = ABS(nStepLeft - nStepRight);
        for (int i = 0; i < d; i++) {
            p = p->pNext;
        }

        //
        // 接下来两边距离交点相同,一起向交点出发
        //
        while (p && q) {
            if (p == q) {
                pNode_X = p;
                break;
            }
            p = p->pNext;
            q = q->pNext;
        }
        return pNode_X;
    }
}

通过调用此函数获得的交叉点可以和我们手动选取进行判断是否一致:

int _tmain(int argc, _TCHAR* argv[])
{
    int data1[] = {1, 2, 3, 4, 5, 6, 7, 8, 10086};
    int data2[] = {11, 22, 33, 44, 55, 66, 77, 88};
    PNode pHeadList1 = NULL;
    PNode pHeadList2 = NULL;
    PNode pXXXNode = NULL;

    //
    // 建立链表1
    //
    pHeadList1 = BuildList(NULL, data1, ARRAY_SIZE(data1));
    RecursiveList(pHeadList1);
    printf("\n\n");

    //
    // 选取交叉节点
    //
    pXXXNode = pHeadList1->pNext->pNext->pNext;

    //
    // 建立链表2
    //
    pHeadList2 = BuildList(pXXXNode, data2, ARRAY_SIZE(data2));
    RecursiveList(pHeadList2);
    printf("\n\n");

    //
    // 通过程序找到选取的交叉节点
    //
    PNode pXXXNode_Find = FindIntersecNode(pHeadList1, pHeadList2);

    printf("选取的链表相交点:%d\n", pXXXNode->data);
    printf("找到的链表相交点:%d\n", pXXXNode_Find->data);
}

执行结果如下:

img

可以发现,上面算法成功找出了交叉点,正是我们选取的那个点:“4”

下面,我们另辟蹊径,使用一个投机取巧的方式来找到这个点:

step 1: 遍历链表1,并把所有节点的pNext域加上0x80000000,使其指向系统内核地址空间。

step 2: 遍历链表2,使用try except捕获异常,当第一次出现访问异常,则当前指针就是交叉点的pNext域,如此可获取交叉节点

step 3: 重新遍历链表1,把所有pNext域减去0x80000000,恢复原有值。

下面是上面思路的实现:

/*
    使用异常处理来获取交点
*/
PNode FindIntersecNode_ByException(PNode ListLeft, PNode ListRight)
{
    PNode pNode_X = NULL;
    PNode p = NULL;

    //
    // 遍历左边链表,将所有指针值加上0x80000000,使其指向内核区
    //
    p = ListLeft;
    while (p) {
        PNode pTemp = p->pNext;
        p->pNext = (PNode)((long)p->pNext + 0x80000000);
        p = pTemp;
    }

    //
    // 遍历右边链表,第一次出现访问异常则到了交叉点后一个节点
    //
    p = ListRight;
    __try {
        PNode pTemp = NULL;
        while (p) {
            pTemp = p;

            //
            // 这一句当p为内核区地址时将触发异常
            // 后面pNode_X = pTemp;将不会得到执行
            // 故pNode_X指向为上一轮的位置,也就是交点
            p = p->pNext;

            pNode_X = pTemp;
        }
    } __except(1) {
        //
        // 恢复左边链表的地址值
        //
        p = ListLeft;
        while (p) {
            p->pNext = (PNode)((long)p->pNext - 0x80000000);
            p = p->pNext;
        }
    }

    return pNode_X;
}

下面是调用代码:

int _tmain(int argc, _TCHAR* argv[])
{
    int data1[] = {1, 2, 3, 4, 5, 6, 7, 8, 10086};
    int data2[] = {11, 22, 33, 44, 55, 66, 77, 88};
    PNode pHeadList1 = NULL;
    PNode pHeadList2 = NULL;
    PNode pXXXNode = NULL;

    //
    // 建立链表1
    //
    pHeadList1 = BuildList(NULL, data1, ARRAY_SIZE(data1));
    RecursiveList(pHeadList1);
    printf("\n\n");

    //
    // 选取交叉节点
    //
    pXXXNode = pHeadList1->pNext->pNext->pNext;

    //
    // 建立链表2
    //
    pHeadList2 = BuildList(pXXXNode, data2, ARRAY_SIZE(data2));
    RecursiveList(pHeadList2);
    printf("\n\n");

    //
    // 通过程序找到选取的交叉节点
    //
    PNode pXXXNode_Find = FindIntersecNode(pHeadList1, pHeadList2);
    PNode pXXXNode_Find_ByException = FindIntersecNode_ByException(pHeadList1, pHeadList2);

    printf("选取的链表相交点:%d\n", pXXXNode->data);
    printf("找到的链表相交点:%d\n", pXXXNode_Find->data);
    printf("[异常]找到的链表相交点:%d\n", pXXXNode_Find_ByException->data);
}

下面是执行结果:

img

可以发现,我们成功的找到了这个交点。

对于第一种方法:**最坏情况下交点在最后一个,设两链表长度分别为a和b,那么最坏情况下两者都将遍历两遍 2a+2b = 2(a+b)**

对于第二种方法:**同样最坏情况下交点在最后一个,那么链表1由于对pNext域操作和恢复需要遍历两次2a,另外一个链表b,则总共2a+b,比上一种方法优越。**

下面是释放一个单链表所有节点:

/*
    释放链表节点内存
*/
void FreeList(PNode pHead)
{
    PNode p = pHead;
    PNode pTemp = NULL;

    //
    // 使用pTemp临时保存下一个节点地址
    // 然后把当前节点释放
    //
    while (p) {
        pTemp = p->pNext;
        delete p;
        p = pTemp;
    }
}

由于是Y型链表,那么释放的时候要注意交叉部分不能出现二次释放,将引发错误。

可将交叉点的前趋的pNext域置空,这样,先释放Y型的左边一个分叉,然后再释放右边分叉和下面的交集,代码如下:

int _tmain(int argc, _TCHAR* argv[])
{
    int data1[] = {1, 2, 3, 4, 5, 6, 7, 8, 10086};
    int data2[] = {11, 22, 33, 44, 55, 66, 77, 88};
    PNode pHeadList1 = NULL;
    PNode pHeadList2 = NULL;
    PNode pXXXNode = NULL;

    //
    // 建立链表1
    //
    pHeadList1 = BuildList(NULL, data1, ARRAY_SIZE(data1));
    RecursiveList(pHeadList1);
    printf("\n\n");

    //
    // 选取交叉节点
    //
    pXXXNode = pHeadList1->pNext->pNext->pNext;

    //
    // 建立链表2,将之链接到交叉节点pXXXNode上
    //
    pHeadList2 = BuildList(pXXXNode, data2, ARRAY_SIZE(data2));
    RecursiveList(pHeadList2);
    printf("\n\n");

    //
    // 通过程序找到选取的交叉节点
    //
    PNode pXXXNode_Find = FindIntersecNode(pHeadList1, pHeadList2);
    PNode pXXXNode_Find_ByException = FindIntersecNode_ByException(pHeadList1, pHeadList2);

    printf("选取的链表相交点:%d\n", pXXXNode->data);
    printf("找到的链表相交点:%d\n", pXXXNode_Find->data);
    printf("[异常]找到的链表相交点:%d\n", pXXXNode_Find_ByException->data);

    //
    // 把交叉点前趋的pNext域置为空,防止交叉部分二次释放
    //
    PNode pPreXXXNode = GetPreNode(pHeadList1, pXXXNode);
    pPreXXXNode->pNext = NULL;

    //
    // 释放链表1和2
    //
    FreeList(pHeadList1);
    FreeList(pHeadList2);
    pHeadList1 = pHeadList2 = NULL;
    printf("\n");
    return 0;
}

到这里就结束了。

说明一下:

1、仅仅是想着以一种新思路来解决传统问题,并没有一定要说谁优谁劣。另外获取交叉链表交点还有很多其他方法,比如构造环等。

2、这里为了达到效果,省去了很多异常检查和链表检查的代码,对传入的链表默认就是一个单向链表,不存在其他复杂的结构。

2、这里使用+0x80000000的方式存在着平台的限制,比如在Windows x86平台上适用,因为它们进程都是4GB地址空间,同时0x80000000以上是内核地址空间。要换了其他系统或者64位,则这种方法就不见得好用了。