单链表问题集合

主要解决的问题有

// 逆序打印单链表 
void PrintListFromTail2Head(PNode pHead);

// 删除单链表的非尾结点 
void DeleteNonEnd(PNode pos);

// 在无头单链表某节点前插入值为data新节点 
void InsertFront(PNode pos, DataType data);

// 用单链表模拟实现约瑟夫环 
void JosephCircle(PNode* ppHead, size_t M);

// 单链表的逆置--三个指针 
void ReverseList(PNode* ppHead);

// 单链表的逆置---头插法 
PNode ReverseList_P(PNode pHead);

// 使用冒泡排序对单链表进行排序 
void BubbleSort(PNode pHead);

// 查找单链表的中间结点，要求只能遍历一次链表 
PNode FindMiddleNode(PNode pHead);

// 查找链表的倒数第K个结点 
PNode FindLastKNode(PNode pHead, size_t K);

// 删除单链表的倒数第K个结点 
int DeleteLastKNode(PNode* ppHead, size_t K);

// 合并两个已序链表，合并之后依然有序 
PNode MergeList(PNode pHead1, PNode pHead2);

// 判断单链表是否带环 
PNode HasCircle(PNode pHead);

// 求环的长度 
size_t GetCircleLen(PNode pHead);

// 求环的入口点 
PNode GetEnterNode(PNode pHead, PNode pMeetNode);

// 判断两个不带环单链表是否相交？若干相交求交点 
int IsCrossWithoutCircle(PNode pHead1, PNode pHead2);
PNode GetCorssNode(PNode pHead1, PNode pHead2);

---

代码实现

编译环境（Visual Studio 2017）

• test.c 文件

#include <windows.h>
#include <stdio.h>
#include <assert.h>
#include <malloc.h>
#include "List.h"


int main()
{
    // 逆序打印单链表 测试
    PrintListFromTail2Head_test( );

    // 删除单链表的非尾结点 测试
    DeleteNonEnd_test( );

    // 在无头单链表某节点前插入值为data新节点 测试
    InsertFront_test();

    // 用单链表模拟实现约瑟夫环 测试
    JosephCircle_test();

    // 单链表的逆置--三个指针 测试
    ReverseList_test();

    // 单链表的逆置--头插法 测试
    ReverseList_p_test();

    // 使用冒泡排序堆单链表进行排序 测试
    BubbleSort_test();

    // 查找单链表的中间结点，要求只能遍历一次链表 测试
    FindMiddleNode_test( );

    // 查找链表的倒数第K个结点 测试
    FindLastKNode_test( );

    // 删除单链表的倒数第K个结点 测试
    DeleteLastKNode_test( );

    // 合并两个已序链表，合并之后依然有序 测试
    MergeList_test( );

    // 判断单链表是否带环 测试
    HasCircle_test( );

    // 求环的长度 测试
    GetCircleLen_test( );

    // 求环的入口点 测试
    GetEnterNode_test( );

    // 判断两个不带环单链表是否相交？若干相交求交点 测试
    IsCrossWithoutCircle_test( );


    system("pause");
    return 0;

}

• List.h 文件

#pragma once

#ifndef _SLISTNODE_H_
#define _SLISTNODE_H_

typedef int DataType;

typedef struct SListNode
{
    DataType _data;
    struct SListNode* _pNext; // 指向下一个结点的指针 
}Node, *PNode;


// 初始化单链表 
void SListInit(PNode* ppHead);

// 尾插 
void SListPushBack(PNode* ppHead, DataType data);

// 尾删 
void SListPopBack(PNode* ppHead);

// 头插 
void SListPushFront(PNode* ppHead, DataType data);

// 头删 
void SListPopFront(PNode* ppHead);

// 在链表中查找元素data，返回该结点在链表中的位置 
PNode Find(PNode pHead, DataType data);

// data插入在pos之前 
void SListInsert(PNode* ppHead, PNode pos, DataType data);

// 删除链表中pos位置的结点 
void SListErase(PNode* ppHead, PNode pos);

// 获取链表中结点的个数 
size_t Size(PNode pHead);

// 销毁单链表 
void SListDestroy(PNode* pHead);

// 创建结点 
PNode BuySListNode(DataType data);

// 打印单链表 
void SListPrint(PNode pHead);




///////////////////////////////////////////////////////////////////

// 逆序打印单链表 
void PrintListFromTail2Head(PNode pHead);

// 删除单链表的非尾结点 
void DeleteNonEnd(PNode pos);

// 在无头单链表某节点前插入值为data新节点 
void InsertFront(PNode pos, DataType data);

// 用单链表模拟实现约瑟夫环 
void JosephCircle(PNode* ppHead, size_t M);

// 单链表的逆置--三个指针 
void ReverseList(PNode* ppHead);

// 单链表的逆置---头插法 
PNode ReverseList_P(PNode pHead);

// 使用冒泡排序对单链表进行排序 
void BubbleSort(PNode pHead);

// 查找单链表的中间结点，要求只能遍历一次链表 
PNode FindMiddleNode(PNode pHead);

// 查找链表的倒数第K个结点 
PNode FindLastKNode(PNode pHead, size_t K);

// 删除单链表的倒数第K个结点 
int DeleteLastKNode(PNode* ppHead, size_t K);

// 合并两个已序链表，合并之后依然有序 
PNode MergeList(PNode pHead1, PNode pHead2);

// 判断单链表是否带环 
PNode HasCircle(PNode pHead);

// 求环的长度 
size_t GetCircleLen(PNode pHead);

// 求环的入口点 
PNode GetEnterNode(PNode pHead, PNode pMeetNode);

// 判断两个不带环单链表是否相交？若干相交求交点 
int IsCrossWithoutCircle(PNode pHead1, PNode pHead2);
PNode GetCorssNode(PNode pHead1, PNode pHead2);

#endif

• List.c 文件

#include <stdio.h>
#include <windows.h>
#include <assert.h>
#include <malloc.h>
#include "List.h"

///-----单链表基础功能
// 初始化单链表 
void SListInit(PNode* ppHead)
{
    *ppHead = NULL;
}

// 尾插 
void SListPushBack(PNode* ppHead, DataType data)
{
    assert(ppHead);
    PNode newP = BuySListNode(data);
    PNode P = *ppHead;
    if (*ppHead == NULL)
    {
        *ppHead = newP;
    }
    else
    {
        while (P->_pNext != NULL)
        {
            P = P->_pNext;
        }
        P->_pNext = newP;
    }
}

// 尾删 
void SListPopBack(PNode* ppHead)
{
    assert(ppHead);
    PNode Pre = NULL;
    PNode Del = NULL;
    if (*ppHead && (*ppHead)->_pNext == NULL)
    {
        free((*ppHead));
        *ppHead = NULL;
    }
    else if (*ppHead)
    {
        Del = *ppHead;
        while (Del->_pNext != NULL)
        {
            Pre = Del;
            Del = Del->_pNext;
        }
        Pre->_pNext = NULL;
        free(Del);
    }
}

// 头插 
void SListPushFront(PNode* ppHead, DataType data)
{
    assert(ppHead);
    PNode newP = BuySListNode(data);
    newP->_pNext = *ppHead;
    *ppHead = newP;
}

// 头删 
void SListPopFront(PNode* ppHead)
{
    assert(ppHead);

    PNode Del = NULL;
    if ((*ppHead) != NULL)
    {
        Del = *ppHead;
        *ppHead = (*ppHead)->_pNext;
        free(Del);
    }

}

// 在链表中查找元素data，返回该结点在链表中的位置 
PNode Find(PNode pHead, DataType data)
{
    while (pHead != NULL)
    {
        if (pHead->_data == data)
        {
            return pHead;
        }
        pHead = pHead->_pNext;
    }
    return NULL;
}

// data插入在pos之前 
void SListInsert(PNode* ppHead, PNode pos, DataType data)
{
    assert(ppHead);
    assert(pos);

    PNode Pnew = BuySListNode(data);
    PNode per = NULL;

    if (pos == *ppHead)
    {
        Pnew->_pNext = *ppHead;
        *ppHead = Pnew;
    }
    else
    {
        per = *ppHead;
        while (pos && per  && per->_pNext != pos)
        {
            per = per->_pNext;
        }
        if (per->_pNext == pos)
        {
            Pnew->_pNext = pos;
            per->_pNext = Pnew;
        }
    }
}

// 删除链表中pos位置的结点 
void SListErase(PNode* ppHead, PNode pos)
{
    assert(ppHead);
    PNode pre = *ppHead;

    if (pos == NULL || *ppHead == NULL)
    {
        return 0;
    }
    else if (pos == *ppHead)
    {
        *ppHead = pos->_pNext;
        free(pos);
    }
    else
    {
        while (pre && pre->_pNext != pos)
        {
            pre = pre->_pNext;
        }
        if (pre)
        {
            pre->_pNext = pos->_pNext;
            free(pos);
        }
    }
}


// 获取链表中结点的个数 
size_t Size(PNode pHead)
{
    size_t num = 0;
    while (NULL != pHead)
    {
        num++;
        pHead = pHead->_pNext;
    }
    return num;
}

// 销毁单链表 
void SListDestroy(PNode* pHead)
{
    assert(pHead);

    if ((*pHead) != NULL)
    {
        SListDestroy(&((*pHead)->_pNext));
    }
    if ((*pHead) != NULL)
    {
        free((*pHead));
    }
}


// 创建结点 
PNode BuySListNode(DataType data)
{
    PNode newP = NULL;
    newP = (PNode)malloc(sizeof(Node));
    if (newP == NULL)
    {
        printf("error\n");
        return 0;
    }
    newP->_data = data;
    newP->_pNext = NULL;
    return newP;
}

// 打印单链表 
void SListPrint(PNode pHead)
{
    printf("pHead --> ");
    while (pHead != NULL)
    {
        printf("%d --> ", pHead->_data);
        pHead = pHead->_pNext;
    }
    printf("NULL");
    printf("\n");
}



//-------面试题

// 逆序打印单链表 1
void PrintListFromTail2Head(PNode pHead)
{
    if(NULL != pHead && NULL != pHead->_pNext)
    {
        PrintListFromTail2Head(pHead->_pNext);
    }
    if(pHead != NULL)
    printf("%d ", pHead->_data);
}

 逆序打印单链表 2
//void PrintListFromTail2Head(PNode pHead)
//{
//  DataType arr[100];
//  int i = 0;
//
//  while (pHead)
//  {
//      arr[i++] = pHead->_data;
//      pHead = pHead->_pNext;
//  }
//
//  while (i)
//  {
//      printf("%d ", arr[--i]);
//  }
//  printf("\n");
//}

 逆序打印单链表 3
//void PrintListFromTail2Head(PNode pHead)
//{
//  PNode PN = NULL;//创建一个新链表
//  while (NULL != pHead)//将数据头插进新链表 
//  {
//      SListPushFront(&PN, pHead->_data);
//      pHead = pHead->_pNext;
//  }
//  SListPrint(PN);
//  SListDestroy(&PN);
//}

// 删除单链表的非尾结点 
void DeleteNonEnd(PNode pos)
{
    PNode Del = NULL; 
    if (NULL != pos->_pNext)
    {
        Del = pos->_pNext;
        pos->_data = Del->_data;
        pos->_pNext = Del->_pNext;
        free(Del);
    }
}


// 在无头单链表某节点前插入值为data新节点 
void InsertFront(PNode pos, DataType data)
{
    PNode pNew = NULL;
    if(NULL != pos)
    {
        pNew = BuySListNode(pos->_data);
        pos->_data = data;
        pNew->_pNext = pos->_pNext;
        pos->_pNext = pNew;
    }
}

// 用单链表模拟实现约瑟夫环 
void JosephCircle(PNode* ppHead, size_t M)
{
    PNode car = NULL;
    PNode Del = NULL;
    int  num = M;
    assert(ppHead);
    car = (*ppHead);

    if(M != 1)
    {
        while (car->_pNext != car)
        {
            num = M;
            while (--num > 1)
            {
                car = car->_pNext;
            }
            Del = car->_pNext;
            car->_pNext = Del->_pNext;
            car = car->_pNext;
            free(Del);
        }
        car->_pNext = NULL;
        (*ppHead) = car;
    }
    else if (M == 1)
    {
        PNode pre = (*ppHead);
        while (car->_pNext != pre)
        {
            Del = car;
            car = Del->_pNext;
            free(Del);
        }
        car->_pNext = NULL;
    }
    (*ppHead) = car;
}

// 单链表的逆置--三个指针 
void ReverseList(PNode* ppHead)
{
    PNode pre = NULL;
    PNode cur = NULL;
    PNode Next = NULL;

    assert(ppHead);

    cur = (*ppHead);
    while (cur != NULL)
    {
        Next = cur->_pNext;
        cur->_pNext = pre;
        pre = cur;
        cur = Next;
    }
    (*ppHead) = pre;
}

// 单链表的逆置---头插法 
PNode ReverseList_P(PNode pHead)
{
    PNode pNewHead = NULL;
    SListInit(&pNewHead);

    while (pHead)
    {
        SListPushFront(&pNewHead, pHead->_data);
        pHead = pHead->_pNext;
    }
    return pNewHead;
}

// 使用冒泡排序对单链表进行排序 
void BubbleSort(PNode pHead)
{
    PNode cur = pHead;
    PNode pre = pHead;
    PNode End = NULL;
    int flag = 1;
    DataType Ex = 0;

    while (pre && pre->_pNext && flag)
    {
        flag = 0;
        cur = pHead;
        while (cur &&  cur ->_pNext != End)
        {
            if (cur->_data > cur->_pNext->_data)
            {
                flag = 1;
                Ex = cur->_data;
                cur->_data = cur->_pNext->_data;
                cur->_pNext->_data = Ex;
            }
            cur = cur->_pNext;
        }
        End = cur;
        pre = pre->_pNext;
    }
}

// 查找单链表的中间结点，要求只能遍历一次链表 
PNode FindMiddleNode(PNode pHead)
{
    PNode pFast = pHead;
    PNode pSlow = pHead;

    //pFast==NULL 代表奇数个
    //pFast->_pNext==NULL 偶数个
    while (pFast && pFast->_pNext)
    {
        pFast = pFast->_pNext->_pNext;
        pSlow = pSlow->_pNext;
    }

    return pSlow;
}

// 查找链表的倒数第K个结点 
PNode FindLastKNode(PNode pHead, size_t K)
{
    PNode pFast = pHead;
    PNode pSlow = pHead;

    if (K == 0)
    { 
        printf("不存在倒数第0个节点\n");
        return NULL;
    }

    while (--K && pFast && pFast->_pNext)
    {
        pFast = pFast->_pNext;
    }
    if(K)
    {
        printf("不存在该节点\n");
        return NULL;
    }
    while (pFast && pFast->_pNext)
    {
        pFast = pFast->_pNext;
        pSlow = pSlow->_pNext;
    }
    return pSlow;
}

// 删除单链表的倒数第K个结点 
int DeleteLastKNode(PNode* ppHead, size_t K)
{
    PNode Del = NULL;
    PNode Pre = NULL;
    assert(ppHead);

    Del = FindLastKNode((*ppHead), K);
    if (Del == (*ppHead))
    {
        *ppHead = Del->_pNext;
        free(Del);
        return;
    }
    else
    {
        Pre = (*ppHead);
        while (Pre && Pre->_pNext != Del)
        {
            Pre = Pre->_pNext;
        }
        if (Pre->_pNext == Del)
        {
            Pre->_pNext = Del->_pNext;
            free(Del);
        }
    }
}

// 合并两个已序链表，合并之后依然有序 
PNode MergeList(PNode pHead1, PNode pHead2)
{
    PNode pNewNode = NULL;

    if (!pHead1 && pHead2)
        return pHead2;
    else if (!pHead2 && pHead1)
        return pHead1;
    else if (!pHead1 && !pHead2)
        return NULL;

    while (pHead1 && pHead2)
    {
        if (pHead1->_data <= pHead2->_data)
        {
            SListPushBack(&pNewNode, pHead1->_data);
            pHead1 = pHead1->_pNext;
        }
        else if (pHead1->_data > pHead2->_data)
        {
            SListPushBack(&pNewNode, pHead2->_data);
            pHead2 = pHead2->_pNext;
        }
    }

    while (pHead1)
    {
        SListPushBack(&pNewNode, pHead1->_data);
        pHead1 = pHead1->_pNext;
    }
    while (pHead2)
    {
        SListPushBack(&pNewNode, pHead2->_data);
        pHead2 = pHead2->_pNext;
    }
    return pNewNode;
}

// 判断单链表是否带环 
PNode HasCircle(PNode pHead)
{
    PNode pFast = pHead;
    PNode pSlow = pHead;

    while (pFast && pFast->_pNext)
    {
        pFast = pFast->_pNext->_pNext;
        pSlow = pSlow->_pNext;
        if (pFast == pSlow)
            return pFast;
    }
    return NULL;

}


// 求环的长度 
size_t GetCircleLen(PNode pHead)
{
    size_t length = 1;
    PNode pN = NULL;
    PNode EndNode = NULL;

    if (pN = HasCircle(pHead))
    {
        EndNode = pN;
        while (pN->_pNext != EndNode)
        {
            length++;
            pN = pN->_pNext;
        }
    }
    return length;
}


// 求环的入口点 
PNode GetEnterNode(PNode pHead, PNode pMeetNode)
{
    PNode entry = NULL;

    if (!pHead || !pMeetNode)
    {
        return NULL;
    }

    while (pMeetNode != pHead)
    {
        pMeetNode = pMeetNode->_pNext;
        pHead = pHead->_pNext;
    }
    return pMeetNode;
}

// 判断两个不带环单链表是否相交？若干相交求交点 
int IsCrossWithoutCircle(PNode pHead1, PNode pHead2)
{
    while (pHead1 && pHead1->_pNext)
    {
        pHead1 = pHead1->_pNext;
    }
    while (pHead2 && pHead2->_pNext)
    {
        pHead2 = pHead2->_pNext;
    }
    if (pHead1 = pHead2)
    {
        return 1;
    }
    else return 0;
}
PNode GetCorssNode(PNode pHead1, PNode pHead2)
{
    int size1 = 0;
    int size2 = 0;
    int size3 = 0;
    size1 = Size(pHead1);
    size2 = Size(pHead2);
    size3 = size1 - size2;
    if (!IsCrossWithoutCircle(pHead1, pHead2))
    {
        return NULL;
    }

    if (size3 >= 0)
    {
        while ( size3-- )
        {
            pHead1 = pHead1->_pNext;
        }
        while (pHead1 != pHead2)
        {
            pHead1 = pHead1->_pNext;
            pHead2 = pHead2->_pNext;
        }
    }
    else
    {
        while (size3++)
        {
            pHead2 = pHead2->_pNext;
        }
        while (pHead1 != pHead2)
        {
            pHead1 = pHead1->_pNext;
            pHead2 = pHead2->_pNext;
        }
    }
    return pHead1;
}


///-----------------测试
// 逆序打印单链表 测试
void PrintListFromTail2Head_test()
{

    PNode pHead = NULL;
    SListInit(&pHead);
    printf("-----逆序打印测试-----------------\n");
    printf("原始链表: ");
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPrint(pHead);
    printf("测试结果: ");
    PrintListFromTail2Head(pHead);
    printf("\n");
    printf("\n");
}

// 删除单链表的非尾结点 测试
void DeleteNonEnd_test()
{
    PNode pHead = NULL;
    SListInit(&pHead);
    printf("-----非尾节点删除测试-----------------\n");
    printf("原始链表: ");
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPrint(pHead);

    printf("测试结果: ");
    DeleteNonEnd(Find(pHead, 2)); 
    SListPrint(pHead);
    DeleteNonEnd(Find(pHead, 0));
    SListPrint(pHead);
    DeleteNonEnd(Find(pHead, 1));
    SListPrint(pHead);
    DeleteNonEnd(Find(pHead, 4));
    SListPrint(pHead);
    DeleteNonEnd(Find(pHead, 3));
    SListPrint(pHead);
    printf("\n");
}

// 在无头单链表某节点前插入值为data新节点 测试
void InsertFront_test()
{
    PNode pHead = NULL;
    SListInit(&pHead);
    printf("-----无头单链表插入测试-----------------\n");
    printf("原始链表: ");
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPrint(pHead);
    printf("测试结果: \n");
    InsertFront(Find(pHead, 0), 9);
    SListPrint(pHead);
    InsertFront(Find(pHead, 1), 9);
    SListPrint(pHead);
    InsertFront(Find(pHead, 2), 9);
    SListPrint(pHead);
    InsertFront(Find(pHead, 3), 9);
    SListPrint(pHead);
    InsertFront(Find(pHead, 4), 9);
    SListPrint(pHead);
    printf("\n");
}

// 用单链表模拟实现约瑟夫环 测试
void JosephCircle_test() 
{
    PNode pHead;
    printf("-----模拟实现约瑟夫环测试-----------------\n");
    printf("原始链表: ");
    SListInit(&pHead);
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 6);
    SListPrint(pHead);
    Find(pHead, 6)->_pNext = pHead;
    JosephCircle(&pHead, 4);
    printf("测试结果: ");
    SListPrint(pHead);
    printf("\n");

}

// 单链表的逆置--三个指针 测试
void ReverseList_test()
{
    PNode pHead;
    printf("-----单链表（三个指针）逆置测试-----------------\n");
    printf("原始链表: ");
    SListInit(&pHead);
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 6);
    SListPrint(pHead);

    printf("测试结果: ");
    ReverseList(&pHead);
    SListPrint(pHead);
    printf("\n");

}

// 单链表的逆置--头插法 测试
void ReverseList_p_test()
{
    PNode pHead;
    printf("-----单链表（头插法）逆置测试-----------------\n");
    printf("原始链表: ");
    SListInit(&pHead);
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 6);
    SListPrint(pHead);

    printf("测试结果: ");
    pHead = ReverseList_P(pHead);
    SListPrint(pHead);
    printf("\n");
}


// 使用冒泡排序对单链表进行排序 测试
void BubbleSort_test()
{
    PNode pHead;
    printf("-----冒泡排序测试-----------------\n");
    printf("原始链表: ");
    SListInit(&pHead);
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 6);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 4);
    SListPrint(pHead);

    printf("测试结果: ");
    BubbleSort(pHead);
    SListPrint(pHead);
    printf("\n");
}

// 查找单链表的中间结点，要求只能遍历一次链表 测试
void FindMiddleNode_test()
{
    PNode pHead;
    PNode MidNode;
    printf("-----单链表中间结点 测试-----------------\n");
    printf("原始链表: ");
    SListInit(&pHead);
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 6);
    SListPrint(pHead);

    printf("测试结果: ");
    MidNode = FindMiddleNode(pHead);
    printf("MidNode: %d\n", MidNode->_data);
    printf("\n");

}

// 查找链表的倒数第K个结点 测试
void FindLastKNode_test()
{
    PNode pHead = NULL;
    PNode pLastK = NULL;
    printf("-----链表的倒数第K个结点 测试-----------------\n");
    printf("原始链表");
    SListInit(&pHead);
    SListPushBack(&pHead, 7);
    SListPushBack(&pHead, 6);
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 4);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 1);
    SListPrint(pHead);

    printf("测试结果:   ");
    pLastK = FindLastKNode(pHead, 1);
    printf("倒数第1个节点:%d  ",pLastK->_data);
    pLastK = FindLastKNode(pHead, 2);
    printf("倒数第2个节点:%d  ", pLastK->_data);
    pLastK = FindLastKNode(pHead, 3);
    printf("倒数第3个节点:%d  ", pLastK->_data);
    pLastK = FindLastKNode(pHead, 5);
    printf("倒数第5个节点:%d  ", pLastK->_data);
    pLastK = FindLastKNode(pHead, 7);
    printf("倒数第7个节点:%d\n", pLastK->_data);
    printf("\n");
}

// 删除单链表的倒数第K个结点 测试
void DeleteLastKNode_test()
{
    PNode pHead = NULL;
    printf("-----删除链表的倒数第K个结点 测试-----------------\n");
    printf("原始链表: ");
    SListInit(&pHead);
    SListPushBack(&pHead, 7);
    SListPushBack(&pHead, 6);
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 4);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 1);
    SListPrint(pHead);

    printf("测试结果: ");
    DeleteLastKNode(&pHead, 7);
    SListPrint(pHead);

    printf("\n");
}

// 合并两个已序链表，合并之后依然有序 测试
void MergeList_test()
{
    PNode pHead1 = NULL;
    PNode pHead2 = NULL;
    PNode pNewNode = NULL;
    printf("-----合并两个已序链表 测试-----------------\n");
    printf("原始链表1: ");
    SListInit(&pHead1);
    SListInit(&pHead2);
    SListPushBack(&pHead1, 2);
    SListPushBack(&pHead1, 4);
    SListPushBack(&pHead1, 6);
    SListPushBack(&pHead1, 7);
    SListPushBack(&pHead1, 8);
    SListPushBack(&pHead1, 10);
    SListPushBack(&pHead1, 11);
    SListPrint(pHead1);
    printf("原始链表2: ");
    SListPushBack(&pHead2, 1);
    SListPushBack(&pHead2, 5);
    SListPushBack(&pHead2, 9);
    SListPushBack(&pHead2, 10);
    SListPrint(pHead2);

    printf("测试结果:  ");
    pNewNode = MergeList(pHead2, pHead1);
    SListPrint(pNewNode);
    printf("\n");
}

// 判断单链表是否带环 测试
void HasCircle_test()
{
    PNode pHead;

    printf("-----判断单链表是否带环 测试-----------------\n");
    SListInit(&pHead);
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 6);
    Find(pHead, 6)->_pNext = Find(pHead, 4);

    if (HasCircle(pHead))
        printf("测试结果： 带环\n");
    else 
        printf("测试结果： 不带环\n");
    printf("\n");
}

// 求环的长度 测试
void GetCircleLen_test()
{
    PNode pHead;
    size_t length;

    printf("-----求环的长度 测试-----------------\n");
    SListInit(&pHead);
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 6);
    Find(pHead, 6)->_pNext = Find(pHead, 3);

    length = GetCircleLen(pHead);
    printf("测试结果：Circle Length: %d\n", length);
    printf("\n");

}


// 求环的入口点 测试
void GetEnterNode_test()
{
    PNode pHead;
    PNode Entry;

    printf("-----求环的入口点 测试-----------------\n");
    SListInit(&pHead);
    SListPushBack(&pHead, 0);
    SListPushBack(&pHead, 1);
    SListPushBack(&pHead, 2);
    SListPushBack(&pHead, 3);
    SListPushBack(&pHead, 4);
    SListPushBack(&pHead, 5);
    SListPushBack(&pHead, 6);
    Find(pHead, 6)->_pNext = Find(pHead, 3);

    Entry = GetEnterNode(pHead, HasCircle(pHead));
    printf("测试结果: ");
    printf("%d---> \n", Entry->_data);
    printf("\n");
}

// 判断两个不带环单链表是否相交？若干相交求交点 测试
void IsCrossWithoutCircle_test()
{
    PNode pHead1 = NULL;
    PNode pHead2 = NULL;
    PNode pCrossNode = NULL;
    printf("-----判断两个不带环单链表是否相交 测试-----------------\n");
    printf("原始链表1: ");
    SListInit(&pHead1);
    SListInit(&pHead2);
    SListPushBack(&pHead1, 11);
    SListPushBack(&pHead1, 12);
    SListPushBack(&pHead1, 13);
    SListPushBack(&pHead1, 14);
    SListPushBack(&pHead1, 5);
    SListPushBack(&pHead1, 6);
    SListPushBack(&pHead1, 7);
    SListPrint(pHead1);
    printf("原始链表2: ");
    SListPushBack(&pHead2, 21);
    SListPushBack(&pHead2, 22);
    SListPushBack(&pHead2, 23);
    SListPushBack(&pHead2, 24);
    //Find(pHead2, 24)->_pNext = Find(pHead1, 5);
    //Find(pHead2, 24)->_pNext = Find(pHead1, 11);
    pHead2 = pHead1;
    SListPrint(pHead2);

    printf("测试结果: ");
    if (IsCrossWithoutCircle(pHead1, pHead2))
    {
        pCrossNode = GetCorssNode(pHead1, pHead2);
        printf("有焦点\t 焦点: %d\n", pCrossNode->_data);
    }
    else 
    {
        printf("没有交点\n");
    }
    printf("\n");
}