数据结构-链表的经典面试题

在前面的博客中我们对链表做了一些基本操作，所以在此不再赘述。直接来看，有哪些和链表有关的面试题以及如何去实现它们。
1.头文件声明

linklist.h
#pragma once 

typedef char LinkNodeType;

typedef struct LinkNode
{
    LinkNodeType data;
    struct LinkNode *next;
}LinkNode;

//逆序打印链表
void LinkListReversePrint(LinkNode* head);

//链表逆序（先删除节点再头插）
void LinkListReverse(LinkNode** head);

//链表逆序（用三个指针）       
void LinkListReverse2(LinkNode** head);

//约瑟夫环
LinkNode* JosephCircle(LinkNode* head,int M);

//冒泡排序
void LinkListBubbleSort(LinkNode* head);

//将两个有序链表合并成一个有序链表
LinkNode* LinkListMerge(LinkNode* head1,LinkNode* head2);

//找一个链表的中间结点
LinkNode* LinkListFindMidNode(LinkNode* head);

//查找链表的倒数第k个结点
LinkNode* LinkListFindLastKNode(LinkNode* head,int k)

//删除链表的第倒数k个结点
void LinkListEraseLastKNode(LinkNode** head,int k);

//判断链表是否有环
LinkNode* LinkListHasCycle(LinkNode* head);

//判断环的长度
int  LinkListCycleLen(LinkNode* head);

//判断环的入口点
LinkNode* LinkListCycleEntry(LinkNode* head);

//判断两个链表是否相交
int LinkListCross(LinkNode* head1,LinkNode* head2);

//链表相交，求交点
LinkNode* LinkListHasCross(LinkNode* head1,LinkNode* head2);

//判断两个链表是否相交（链表可能带环）
int LinkListCrossWithCycle(LinkNode* head1,LinkNode* head2);

//链表相交，求交点
LinkNode* LinkListHasCrossWithCycle(LinkNode* heda1,LinkNode* head2);

//求两个已排序单链表中相同的数据
LinkNode* LinkListUnionSet(LinkNode* head1,LinkNode* head2);

2.各个函数的具体实现

//逆序打印单链表，采用递归的思想
void LinkListReversePrint(LinkNode* phead)
{
    if(phead != NULL)
    {
        if(phead->next != NULL)
        {
            LinkListReversePrint(phead->next); //递归打印
        }
        printf("%c ",phead->data);
    }
    return;
}

//逆序单链表，第一种方法，先删除结点再进行头插
void LinkListReverse(LinkNode** phead)
{
    if(phead == NULL)
        return;                //非法输入

    if(*phead == NULL)
        return;                //空链表

    if((*phead)->next == NULL)
        return;                //只有一个元素的链表

    LinkNode* cur = *phead;
    while(cur->next != NULL)
    {
        LinkNode* to_delete = cur->next;
        //删除这个结点
        cur->next = to_delete->next;
        //把刚删除的元素插入到链表头部
        to_delete->next = *phead;
        *phead = to_delete;
    }
}

//逆序单链表，第二种方法，通过不断修改三个指针的指向
void LinkListReverse2(LinkNode** phead)
{

    if(phead == NULL)
        return;                //非法输入

    if(*phead == NULL)
        return;                //空链表

    if((*phead)->next == NULL)
        return;                //只有一个元素的链表

    LinkNode* cur = (*phead)->next;
    LinkNode* pre = (*phead);
    pre->next = NULL;
    while(cur != NULL)
    {
        LinkNode* next = cur->next;
        //修改cur->next的指向
        cur->next = pre;
        //更新pre cur
        pre = cur;
        cur = next;

    }
    *phead = pre;

}

//约瑟夫环的实现
LinkNode* JosephCircle(LinkNode* head,int M)
{
    if(head == NULL)
        return NULL;           //空链表

    LinkNode* cur = head;
    while(cur->next != cur)
    {
        int i = 1;
        //定义的基数M,一次查找走M步
        for( ;i < M;i++)
        {
            cur = cur->next;
        }
        //cur指向的元素，就是倒霉的人，即要删除的结点
        printf("%c\n",cur->data);
        //删除这个结点
        cur->data = cur->next->data;
        LinkNode* to_delete = cur->next;
        cur->next = to_delete->next;
        DestroyNode(to_delete);
    }
    return cur;
}

//交换函数
void Swap(LinkNodeType* a,LinkNodeType* b)
{
    LinkNodeType tmp = *a;
    *a = *b;
    *b = tmp;
    return;
}
//冒泡排序
void LinkListBubbleSort(LinkNode* phead)
{
    if(phead == NULL)
        return;    //空链表

    LinkNode* count = phead;//记录冒多少次
    LinkNode* tail = NULL;
    for( ;count != NULL;count = count->next)
    {
        LinkNode* cur = phead;//每冒一次需要遍历链表的长度
        for( ;cur->next != tail;cur = cur->next)
        {
            if(cur->data > cur->next->data)//升序
            {
                Swap(&cur->data,&cur->next->data);
            }
        }
        tail = cur;//更新tail指针
    }
    return;
}
//合并两个有序链表，合并后依然有序
 LinkNode* LinkListMerge(LinkNode* head1,LinkNode* head2)
{
    //如果两个链表任意一个为空，则返回另外一个链表
    if(head1 == NULL)
        return head2;
    if(head2 == NULL)
        return head1;

    LinkNode* cur1 = head1;
    LinkNode* cur2 = head2;
    //定义新链表的头结点和尾结点
    LinkNode* new_head = NULL;
    LinkNode* new_tail = NULL;
    //遍历两个链表
    while(cur1 != NULL && cur2 != NULL)
    {
        //如果cur1的值小于cur2,就把cur1插入新链表，然后将 cur1指向它的下一个结点 ；否则，将cur2插入新链表，更新cur2指针
    if(cur1->data < cur2->data)
        {
            if(new_tail == NULL)
            {
                new_head = new_tail = cur1;
            }
            else
            {
                new_tail->next = cur1;
                new_tail = new_tail->next;
            }
            cur1 = cur1->next;
        }
        else
        {

            if(new_tail == NULL)
            {
                new_head = new_tail = cur2;
            }
            else
            {
                new_tail->next = cur2;
                new_tail = new_tail->next;
            }
            cur2 = cur2->next;
        }
    }
    //有一方已经先到达末尾，需要把剩余的一方追加到新链表后面
    if(cur1 != NULL)
    {
        new_tail->next = cur1;
    }
    else
    {
        new_tail->next = cur2;
    }
    return new_head;
}

//查找链表的中间结点，定义快慢指针只遍历一次链表
LinkNode* LinkListFindMidNode(LinkNode* phead)
{
    if(phead == NULL)
    {
        return NULL;//空链表
    }
    LinkNode* slow = phead;
    LinkNode* fast = phead;
    while(fast != NULL && fast->next != NULL)
    {
        slow = slow->next;//慢指针一次走一步
        fast = fast->next->next;//快指针一次走两步
    }
    return slow;
}

//查找倒数第k个结点
LinkNode* LinkListFindLastKNode(LinkNode* phead,int k)
{
    if(phead == NULL)
        return;           //空链表

    LinkNode* fast = phead;
    LinkNode* slow = phead;
    // 让快指针先走k步
    int i = 0;
    for( ;i < k;i++)
    {
        if(fast == NULL)
        {
            break;
        }
        fast = fast->next;
    }
    if(i != k)
    {
        //没走完,k的长度超过了链表长度
        return NULL;
    }
    while(fast != NULL)
    {
        //快慢指针每次各走一步，快指针指向空的时候，慢指针刚好指向倒数第K个结点
        fast = fast->next;
        slow = slow->next;
    }
    return slow;
}

//删除倒数第K个结点，思想找到它的一个结点
void LinkListEraseLastKNode(LinkNode** phead,int k)
{
    if(phead == NULL)
        return;             //非法输入
    if(*phead == NULL)
        return;             //空链表

    int len = LinkListSize(*phead);
    if(k == len)
    {
        //要删除的元素，刚好是第一个元素，头删
        LinkNode* to_delete = *phead;
        *phead = (*phead)->next;
        DestroyNode(to_delete);
        return;
    }
    //遍历链表，找到要删除结点的前一个结点
    LinkNode* pre = *phead;
    int i = 0;
    for(;i < len-k-1;i++)
    {
        pre = pre->next;
    }
    //循环结束后，表明pre节点已经指向了要删除元素的前一个结点
    LinkNode* to_delete = pre->next;
    pre->next = to_delete->next;
    DestroyNode(to_delete);
    return;
}

//判断链表是否带环
//   第一种思路：建一个顺序表，初始化后，在遍历链表同时
//在顺序表里查找该元素，如果该元素已经存在，说明链表带环，
//如果不存在，就将该元素插入到顺序表中。但是这种算法时间
//复杂度为O(n^2),空间复杂度为O(n).
//   第二种思路，定义快慢指针，让快指针一次走两步，慢指针
//走一步，如果快慢指针最后相遇，说明该链表带环。这种算法
//时间复杂度为O(n),空间复杂度为O(1).

LinkNode* LinkListHasCycle(LinkNode* phead)
{
    if(phead == NULL)
        return NULL;

    LinkNode* slow = phead;
    LinkNode* fast = phead;
    while(fast != NULL && fast->next != NULL)
    {
        fast = fast->next->next;
        slow = slow->next;
        if(fast == slow)
        {
            return slow;
        }
    }
    return NULL;
}
//求环的长度
int LinkListCycleLen(LinkNode* phead)
{
    if(phead == NULL)
    {
        return 0;
    }
    //记录快慢指针相遇的位置
    LinkNode* meet_node = LinkListHasCycle(phead);
    if(meet_node == NULL)
    {
        return 0;
    }
    //记录下相遇位置的下一个，等再回到该位置，走了几步环就有多长
    LinkNode* cur = meet_node->next;
    int Len = 1;
    while(cur != meet_node)
    {
        cur = cur->next;
        ++Len;
    }
    return Len;
}

//求环的入口点
LinkNode* LinkListCycleEntry(LinkNode* phead)
{
    if(phead == NULL)
    {
        return NULL;
    }

    LinkNode* meet_node = LinkListHasCycle(phead);
    if(meet_node == NULL)
    {
        return NULL;
    }
    //定义cur1指向头结点，cur2指向相遇的位置
    LinkNode* cur1 = phead;
    LinkNode* cur2 = meet_node;
    while(cur1 != cur2)
    {
    //cur1和cur2每次各走一步，直到它俩相遇，相遇的位置就是入口点
        cur1 = cur1->next;
        cur2 = cur2->next;
    }
    return cur1;
}

判断两个链表是否相交

思路：让cur1走到最后一个节点，再让cur2也走向最后一个节点，如果两个相等，说明cur1和cur2相交

//判断两个链表是否相交
int LinkListCross(LinkNode* head1,LinkNode* head2)
{
    if(head1 == NULL||head2 == NULL)
    {
        return 0;
    }
    //1.定义cur1指向head1;
    LinkNode* cur1 = head1;
    //2.让cur1遍历链表head1,走到最后一个节点
    while(cur1->next != NULL)
    {
        cur1 = cur1->next;
    }
    //3.定义cur2指向head2;
    LinkNode* cur2 = head2;
    //4.让cur2遍历链表head2，走到最后一个节点
    while(cur2->next != NULL)
    {
        cur2 = cur2->next;
    }
    //5.判断，如果此时cur1和cur2相等，则相交；否则，不相交
    if(cur1 == cur2)
    {
        return 1;
    }
    else
    {

        return 0;
    }
}
//求交点
LinkNode* LinkListHasCross(LinkNode* head1,LinkNode* head2)
{
    if(head1 == NULL||head2 == NULL)
    {
        return NULL;
    }
    //1.分别计算两个链表的长度
    int len1 = LinkListSize(head1);
    int len2 = LinkListSize(head2);
    //2.定义两个指针分别指向两个链表的头部
    LinkNode* cur1 = head1;
    LinkNode* cur2 = head2;
    //3.让比较长的链表先走长度之差步（让两个指针在统一起跑线）
    if(len1 > len2)
    {
        size_t i = 0;
        for( ;i < len1-len2;++i)
        {
            cur1 = cur1->next;
        }
    }
    else
    {
        size_t i = 0;
        for( ;i < len2-len1;++i)
        {
            cur2 = cur2->next;
        }
    }
    //4.让两个指针同时开始走，一次走一步
    //5.如果两指针重合，则说明此位置就是交点
    while(cur1 != NULL && cur2 != NULL)
    {
        if(cur1 == cur2)
        {
            return cur1;
        }
        cur1 = cur1->next;
        cur2 = cur2->next;
    }
    return NULL;

}

判断两个链表是否相交，相交，若相交，求交点（链表可能带环）
带环的四种情况：

int LinkListCrossWithCycle(LinkNode* head1,LinkNode* head2)
{
    //1.分别求两个链表的环的入口点
    LinkNode* entry1 = LinkListCycleEntry(head1);
    LinkNode* entry2 = LinkListCycleEntry(head2);
    //2.如果两个链表都不带环，直接用前面的方式判定相交
    if(entry1 == NULL && entry2 == NULL)
    {
        return LinkListCross(head1,head2);
    }
    //3.如果一个带环，一个不带环，那么直接返回不相交
    if((entry1 == NULL && entry2 != NULL)||(entry1 != NULL && entry2 == NULL))
    {
        return 0;
    }
    //4.如果两个链表都带环
    //   a)如果这两个入口点重合，说明相交，并且是环外相交
    if(entry1 == entry2)
    {
        return 1;
    }
    //   b)如果从一个入口点出发，绕环一周，能到达第二个入口点，说明是环上相交
    LinkNode* cur = entry1->next;
    while(cur != entry1)
    {
        if(cur == entry2)
        {
            return 1;
        }
        cur = cur->next;
    }
    //   c)如果不是上面这两种情况，说明不相交
    return 0;
}

//求交点
LinkNode* LinkListHasCrossWithCycle(LinkNode* head1,LinkNode* head2)
{
    if(head1 == NULL||head2 == NULL)
    {
        return NULL;
    }
    int i = LinkListCrossWithCycle(head1,head2);
    if(i == 0)
    {
       return NULL;
    }
    //1.求环的入口点
    LinkNode* entry1 = LinkListCycleEntry(head1);
    LinkNode* entry2 = LinkListCycleEntry(head2);
    //2.判断是那种情况相交
    if(entry1 != entry2)//环上相交
    {
        return entry2;
    }
    //3.标记入口点
    LinkNode* end = entry1;
    //4.另一种情况，环外相交，分别计算两个链表头到入口点的长度
    //5.定义两个指针分别指向两个链表的头部
    int len1 = 0;
    int len2 = 0;
    LinkNode* cur1 = head1;
    LinkNode* cur2 = head2;
    for( ;cur1 != end;cur1 = cur1->next)
    {
         len1++;
    }
    for( ;cur2 != end;cur2 = cur2->next)
    {
         len2++;
    }
    //6.让比较长的链表先走长度之差步（让两个指针在统一起跑线）
    if(len1 > len2)
    {
        size_t i = 0;
        for( ;i < len1-len2;++i)
        {
            cur1 = cur1->next;
        }
    }
    else
    {
        size_t i = 0;
        for( ;i < len2-len1;++i)
        {
            cur2 = cur2->next;
        }
    }
    //7.让两个指针同时开始走，一次走一步
    //8.如果两指针重合，则说明此位置就是交点
    while(cur1 != end->next && cur2 != end->next)
    {
        if(cur1 == cur2)
        {
            return cur1;
        }
        cur1 = cur1->next;
        cur2 = cur2->next;
    }
    return NULL;

}

求两个已排序单链表中相同的数据

思路：遍历两个链表，cur1指向head1，cur2指向head2,如果两个元素相等，则重新创建一个结点，值等于该元素，并将其插入到新链表中；如果不相等，则更新两个指针

LinkNode* LinkListUnionSet(LinkNode* head1,LinkNode* head2)
{
    if(head1 == NULL || head2  == NULL)
    {
        return NULL;
    }
    LinkNode* cur1 = head1;
    LinkNode* cur2 = head2;

    LinkNode* new_head = NULL;
    LinkNode* new_tail = NULL;
    while(cur1 != NULL && cur2 != NULL)
    {
        if(cur1->data < cur2->data)
        {
            cur1 = cur1->next;
        }
        else if(cur1->data > cur2->data)
        {
            cur2 = cur2->next;
        }
        else
        {
            if(new_head == NULL)
            {
                new_head = new_tail = CreateNode(cur1->data);
            }
            else
            {
                new_tail->next = CreateNode(cur1->data);
                new_tail =new_tail->next;
            }

            cur1 = cur1->next;
            cur2 = cur2->next;
        }
    }
    return new_head;
}

复杂链表的复制，复杂链表相比较普通链表多了一个random指针，而这个指针的指向是任意的，所以复制的难点就在于如何让新链表的random指针保持和旧链表的一致性，有两种思路：
一种是先忽略random指针，按简单链表的方式进行复制，然后求得random指针相对于头结点的偏移量，最后在新链表里根据偏移量进行设置。
第二种是遍历链表，给每个结点后插入一个新的结点，这个新结点值和它的前一个元素相等，新结点的random指针就等于旧结点random指针的下一个，最后再将新结点拆除。

typedef struct ComplexNode
{
    LinkNodeType data;
    struct ComplexNode* next;
    struct ComplexNode* random;
}ComplexNode;
//创建复杂结点
ComplexNode* CreateComplexNode(LinkNodeType value)
{
    ComplexNode* new_node = (ComplexNode*)malloc(sizeof(ComplexNode));
    new_node->data = value;
    new_node->next = NULL;
    new_node->random = NULL;
    return new_node;
}
//求偏移量
size_t Diff(ComplexNode* src,ComplexNode* dest)
{
    size_t offset = 0;
    while(src != NULL)
    {
        if(src == dest)
        {
            break;
        }
        offset++;
        src = src->next;
    }
    if(src == NULL)
    {
        return (size_t)-1;
    }
    return offset;

}
//设置random指针
ComplexNode* Step(ComplexNode* head,size_t offset)
{
    ComplexNode* cur = head;
    size_t i = 0;
    while(1)
    {
        if(cur == NULL)
        {
            return NULL;
        }
        if(i >= offset)
        {
            return cur;
        }
        ++i;
        cur = cur->next;    
    }
    return cur;
}
ComplexNode* CopyComplexList(ComplexNode* head)
{
    //1.先按照简单链表的方式进行复制
    ComplexNode* new_head = NULL;
    ComplexNode* new_tail = NULL;
    ComplexNode* cur = head;
    for( ;cur != NULL;cur = cur->next)
    {
        ComplexNode* new_node = CreateComplexNode(cur->data);
        if(new_head == NULL)
        {
            new_head = new_tail = new_node;
        }
        else
        {
            new_tail->next = new_node;
            new_tail = new_tail->next;
        }
    }
    //2.遍历旧链表，找到每个链表节点的random指针相对于链表头节点的偏移量
    //3.遍历新链表，根据偏移量，设置新链表的random指针
    ComplexNode* new_cur = new_head;
    for(cur = head;cur != NULL;cur = cur->next,new_cur = new_cur->next)
    {
        if(cur->random == NULL)
        {
            new_cur->random = NULL;
                continue;
        }
        //通过Diff函数找到random的偏移量
        size_t offset = Diff(head,cur->random);
        //通过Step函数设置新链表的Random指针
        new_cur->random = Step(new_head,offset);
    }
    return new_head;
}

ComplexNode* CopyComplexList2(ComplexNode* head)
{
    //1.遍历链表，给每个结点之后插入新结点
    ComplexNode* cur = head;
    for( ;cur != NULL;cur = cur->next->next)
    {
        ComplexNode* new_node = CreateComplexNode(cur->data);
        new_node->next = cur->next;
        cur->next = new_node;
    }
    //2.维护新结点的randon指针
    for(cur = head;cur != NULL;cur = cur->next->next)
    {
        ComplexNode* new_cur = cur->next;
        if(cur->random == NULL)
        {
            new_cur->random = NULL;
            continue;
        }
        new_cur->random = cur->random->next;
    }
    //3.将新结点拆除
    ComplexNode* new_head = NULL;
    ComplexNode* new_tail = NULL;
    for(cur = head;cur != NULL;cur = cur->next)
    {
        ComplexNode* new_cur = cur->next;
        cur->next = new_cur->next;
        if(new_head == NULL)
        {
            new_head = new_tail = new_cur;
        }
        else
        {
            new_tail->next = new_cur;
            new_tail = new_tail->next;
        }
    }

    return new_head;
}

3.测试代码：

#define TEST_HEADER printf("\n=====================%s====================\n",__FUNCTION__)

void LinkListPrintChar(LinkNode* head,const char* msg)
{
    printf("[%s]\n",msg);
    LinkNode* cur = head;
    for( ;cur != NULL;cur = cur->next)
    {
        printf("[%c|%p] ",cur->data,cur);
    }
    printf("\n");

}
void TestReversePrint()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);

    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    printf("[逆序打印链表]\n");
    LinkListReversePrint(head);
}

void TestReverse()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);

    LinkListReverse(&head);
    LinkListPrintChar(head,"尝试对空链表操作");

    LinkListPushBack(&head,'a');
    LinkListReverse(&head);
    LinkListPrintChar(head,"对只有一个元素的链表逆序");

    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListReverse(&head);
    LinkListPrintChar(head,"逆序链表");
}
void TestReverse2()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);

    LinkListReverse2(&head);
    LinkListPrintChar(head,"尝试对空链表操作");

    LinkListPushBack(&head,'a');
    LinkListReverse2(&head);
    LinkListPrintChar(head,"对只有一个元素的链表逆序");

    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListReverse2(&head);
    LinkListPrintChar(head,"逆序链表");
}

void TestJosephCircle()
{
    TEST_HEADER;
    LinkNode* a = CreateNode('a');
    LinkNode* b = CreateNode('b');
    LinkNode* c = CreateNode('c');
    LinkNode* d = CreateNode('d');
    LinkNode* e = CreateNode('e');
    LinkNode* f = CreateNode('f');
    LinkNode* g = CreateNode('g');
    LinkNode* h = CreateNode('h');
    a->next = b;
    b->next = c;
    c->next = d;
    d->next = e;
    e->next = f;
    f->next = g;
    g->next = h;
    h->next = a;

    LinkNode* survive = JosephCircle(a,5);
    printf("survive is %c\n",survive->data);
}

void TestBubbleSort()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);

    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'f');
    LinkListPushBack(&head,'e');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'g');
    LinkListPushBack(&head,'h');
    LinkListPushBack(&head,'d');

    LinkListBubbleSort(head);
    LinkListPrintChar(head,"冒泡排序");
}
void TestMerge()
{
    TEST_HEADER;
    LinkNode* head1;
    LinkNode* head2;
    LinkNode* head3;
    LinkListInit(&head1);
    LinkListInit(&head2);
    LinkListInit(&head3);

    LinkListPushBack(&head1,'a');
    LinkListPushBack(&head1,'b');
    LinkListPushBack(&head1,'c');
    LinkListPushBack(&head1,'d');
    LinkListPushBack(&head2,'e');
    LinkListPushBack(&head2,'f');
    LinkListPushBack(&head2,'g');
    LinkListPushBack(&head2,'h');

    head3 = LinkListMerge(head1,head2);
    LinkListPrintChar(head3,"将已经有序的两个链表合并成一个有序链表");
}

void TestFindMidNode()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);

    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');

    LinkNode* Mid = LinkListFindMidNode(head);
    LinkListPrintChar(head,"查找链表的中间节点");
    printf("Mid expected is c,actual is %c\n ",Mid->data);
}

void TestFindLastKNode()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);

    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');

    LinkNode* LastK = LinkListFindLastKNode(head,2);
    LinkListPrintChar(head,"查找链表的倒数第2个节点");
    printf("Mid expected is d,actual is %c\n ",LastK->data);
}

void TestEraseLastKNode()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);

    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');

    LinkListEraseLastKNode(&head,2);
    LinkListPrintChar(head,"删除链表的倒数第2个节点");
}

void TestHasCycle()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);

    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');

    LinkNode* pos_e = LinkListFind(head,'e');
    pos_e->next =head->next->next;

    LinkNode* meet_node= LinkListHasCycle(head);

    printf("meet_node expected is d,actual is %c\n",meet_node->data);
}

void TestCycleLen()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);

    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');

    LinkNode* pos_e = LinkListFind(head,'e');
    pos_e->next =head->next->next;

    int len= LinkListCycleLen(head);
    printf("len expected is 3,actual is %d\n",len);
}

void TestCycleEntry()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);

    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');

    LinkNode* pos_e = LinkListFind(head,'e');
    pos_e->next =head->next->next;

    LinkNode* entry_node = LinkListCycleEntry(head);
    printf("entry_node expected is c,actual is %c\n",entry_node->data);
}

void TestCross()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');

    LinkNode* head2;
    LinkListInit(&head2);
    LinkListPushBack(&head2,'a');
    LinkListPushBack(&head2,'b');
    LinkListPushBack(&head2,'c');
    LinkNode* pos_c = LinkListFind(head2,'c');
    pos_c->next = head->next;

    int ret = LinkListCross(head,head2);
    printf("ret excepted is 1,actual is %d\n",ret);
}

void TestHasCross()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');

    LinkNode* head2;
    LinkListInit(&head2);
    LinkListPushBack(&head2,'a');
    LinkListPushBack(&head2,'b');
    LinkListPushBack(&head2,'c');
    LinkNode* pos_c = LinkListFind(head2,'c');
    pos_c->next = head->next;

    LinkNode* cross = LinkListHasCross(head,head2);
    printf("cross expected is b,actual is %c\n",cross->data);
}

void TestCrossWithCycle()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');

    LinkNode* head1;
    LinkListInit(&head1);
    LinkListPushBack(&head1,'a');
    LinkListPushBack(&head1,'b');
    LinkListPushBack(&head1,'c');
    LinkListPushBack(&head1,'d');

    int ret1 = LinkListCrossWithCycle(head,head1);
    printf("[两个链表都不带环]\n");
    printf("ret1 expected is 0,actual is %d\n",ret1);

    LinkNode* head2;
    LinkListInit(&head2);   
    LinkListPushBack(&head2,'a');
    LinkListPushBack(&head2,'b');
    LinkListPushBack(&head2,'c');
    LinkListPushBack(&head2,'d');
    LinkListPushBack(&head2,'e');
    LinkNode* pos_e = LinkListFind(head2,'e');
    pos_e->next =head2->next->next;

    LinkNode* head3;
    LinkListInit(&head3);   
    LinkListPushBack(&head3,'a');
    LinkListPushBack(&head3,'b');
    LinkListPushBack(&head3,'c');
    LinkListPushBack(&head3,'d');
    LinkListPushBack(&head3,'e');
    LinkNode* pos_2e = LinkListFind(head3,'e');
    pos_2e->next =head3->next;

    int ret2 = LinkListCrossWithCycle(head2,head3);
    printf("[两个链表都带环]\n");
    printf("ret2 expected is 0,actual is %d\n",ret2);

    LinkNode* head4;
    LinkListInit(&head4);
    LinkListPushBack(&head4,'a');
    LinkListPushBack(&head4,'b');
    LinkListPushBack(&head4,'c');
    LinkNode* pos_c = LinkListFind(head4,'c');
    pos_c->next = head2->next;

    int ret3 = LinkListCrossWithCycle(head2,head4);
    printf("[两个链表都带环，满足a情况]\n");
    printf("ret3 expected is 1,actual is %d\n",ret3);

    LinkNode* head5;
    LinkListInit(&head5);
    LinkListPushBack(&head5,'a');
    LinkListPushBack(&head5,'b');
    LinkListPushBack(&head5,'c');
    LinkListPushBack(&head5,'d');
    LinkNode* pos_d = LinkListFind(head5,'d');
    pos_d->next =head2->next->next->next;

    int ret4 = LinkListCrossWithCycle(head2,head5);
    printf("[两个链表都带环，满足b情况]\n");
    printf("ret4 expected is 1,actual id %d\n",ret4);
}

void TestHasCrossWithCycle()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');    
    LinkNode* pos_e = LinkListFind(head,'e');
    pos_e->next =head->next->next;

    LinkNode* head1;
    LinkListInit(&head1);
    LinkListPushBack(&head1,'a');
    LinkListPushBack(&head1,'b');
    LinkListPushBack(&head1,'c');
    LinkListPushBack(&head1,'d');
    LinkNode* pos_d = LinkListFind(head1,'d');
    pos_d->next = head->next;

    LinkNode* cross = LinkListHasCrossWithCycle(head,head1);
    printf("[两个链表都带环，环外相交]\n");
    printf("cross expected c,actual %c\n",cross->data);

    LinkNode* head2;
    LinkListPushBack(&head2,'a');
    LinkListPushBack(&head2,'b');
    LinkListPushBack(&head2,'c');
    LinkListPushBack(&head2,'d');
    LinkNode* pos_d2 = LinkListFind(head2,'d');
    pos_d2->next =head->next->next->next;

    LinkNode* cross2 = LinkListHasCrossWithCycle(head,head2);
    printf("[两个链表都带环，入口点就是交点]\n");
    printf("cross2 expected c或者d,actual %c\n",cross2->data);
}
void TestUnionSet()
{

    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);
    LinkListPushBack(&head,'a');
    LinkListPushBack(&head,'b');
    LinkListPushBack(&head,'c');
    LinkListPushBack(&head,'d');
    LinkListPushBack(&head,'e');

    LinkNode* head1;
    LinkListInit(&head1);
    LinkListPushBack(&head1,'a');
    LinkListPushBack(&head1,'c');
    LinkListPushBack(&head1,'e');
    LinkListPushBack(&head1,'f');
    LinkListPushBack(&head1,'h');
    LinkNode* union_set = LinkListUnionSet(head,head1);
    LinkListPrintChar(union_set,"链表的交集是：");
}

void PrintComplexList(ComplexNode* head,const char* msg)
{
    printf("[%s]\n",msg);
    ComplexNode* cur = head;
    for( ;cur != NULL;cur = cur->next)
    {
        printf("[%c]",cur->data);
    }
    printf("\n");
    for(cur = head ;cur != NULL;cur = cur->next)
    {
        if(cur->random == NULL)
        {
            printf("[NULL]");
            continue;
        }
        printf("[%c]",cur->random->data);
    }
    printf("\n");
}
void TestCopyComplexList()
{
    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);
    ComplexNode* a = CreateComplexNode('a');
    ComplexNode* b = CreateComplexNode('b');
    ComplexNode* c = CreateComplexNode('c');
    ComplexNode* d = CreateComplexNode('d');
    a->next = b;
    b->next = c;
    c->next = d;
    d->next = NULL;
    a->random = c;
    b->random = a;
    c->random = NULL;
    d->random = d;

    ComplexNode*  new_head= CopyComplexList(a);
    PrintComplexList(new_head,"复杂链表的复制");
}

void TestCopyComplexList2()
{
    TEST_HEADER;
    LinkNode* head;
    LinkListInit(&head);
    ComplexNode* a = CreateComplexNode('a');
    ComplexNode* b = CreateComplexNode('b');
    ComplexNode* c = CreateComplexNode('c');
    ComplexNode* d = CreateComplexNode('d');
    a->next = b;
    b->next = c;
    c->next = d;
    d->next = NULL;
    a->random = c;
    b->random = a;
    c->random = NULL;
    d->random = d;

    ComplexNode*  new_head = CopyComplexList2(a);
    PrintComplexList(new_head,"复杂链表的复制");
}
int main()
{
    TestReversePrint();
    TestReverse();
    TestReverse2();
    TestJosephCircle();
    TestBubbleSort();
    TestMerge();
    TestFindMidNode();
    TestFindLastKNode();
    TestEraseLastKNode();
    TestHasCycle();
    TestCycleLen();
    TestCycleEntry();
    TestCross();
    TestHasCross();
    TestCrossWithCycle();
    TestHasCrossWithCycle();
    TestUnionSet();
    TestCopyComplexList();
    TestCopyComplexList2();
    printf("\n");
    return 0;
}