<笔试><面试>C/C++单链表（最综合）最全工程从建立到相关函数实现

（1）打印链表 
（2）使用引用 定义别名的方法实现尾插 
（3）尾删 
（4）头插 
（5）头删 
（6）寻找data为x的结点 
（7）在pos处插入新结点 
（8）删除pos位置的结点 
（9）从尾到头打印链表 
（10）删除一个无头链表的非尾结点 
（11）在无头单链表的一个非头结点前插入一个结点 
（12）逆置链表 
（13）查找单链表的中间结点，要求只遍历一次链表 
（14）查找链表的倒数第K个结点，要求只遍历一次链表 
（15）约瑟夫环 
（16）单链表排序（冒泡） 
（17）判断链表是否有环 
（18）求链表环长度 
（19）找环入口 
（20）找环入口_链表相交法 
（21）判断两链表是否相交，求交点（假设链表不带环） 
（22）判断两链表是否相交，求交点（假设链表可能带环）

//**********SListNode.h****************
#pragma once

#ifndef __SLISTNODE_H__
#define __SLISTNODE_H__

//--------添加头文件-----------
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//--------链表结构------------

typedef int DateType;  //定义数据类型为 int

typedef int DataType;

typedef struct SListNode
{
 DataType data;
 struct SListNode *next;
}SListNode;


//--------函数-------------
void PrintNode(SListNode *&pHead);//打印链表
void PushBack(SListNode* &pHead, DataType x);//使用引用 定义别名的方法实现尾插
void PushBack_p(SListNode **ppHead, DataType x);
void PopBack(SListNode* &pHead);//尾删
void PushFront(SListNode* &pHead, const DataType x);//头插
void PopFront(SListNode* &pHead);//头删
SListNode* Find(SListNode* pHead, const DataType x);//寻找data为x的结点
void Insert(SListNode* pos, const DataType x);//在pos处插入新结点
void Erase(SListNode*&pHead,SListNode* pos);//删除pos位置的结点
void Print_T_to_H(SListNode*&pHead); //从未到头打印链表
void Del_N_tail(SListNode* pos);  //删除一个无头链表的非尾结点
void InsertFront(SListNode*, const DataType x);  //在无头单链表的一个非头结点前插入一个结点
void Turn(SListNode*&pHead);  //逆置链表
SListNode* FindMidOnce(SListNode*& pHead);//查找单链表的中间结点，要求只遍历一次链表
SListNode* FindLKOnce(SListNode* pHead, int K);//查找链表的倒数第K个结点，要求只遍历一次链表

SListNode* Joseph(SListNode *&pos, int K); //约瑟夫环
void BubbleSortNode(SListNode *&pHead); //单链表排序（冒泡）

SListNode* IsRing(SListNode *&pHead); //判断链表是否有环
int RingLength(SListNode *&pHead);//求链表环长度
SListNode* RingEntry(SListNode *&pHead);//找环入口
SListNode* RingEntry_Point(SListNode *&pHead);//找环入口_链表相交法
//int _LengthNode(SListNode*& pHead);

SListNode* Intersect(SListNode *&L, SListNode *&M);//判断两链表是否相交，求交点（假设链表不带环）
SListNode* IntersectRing(SListNode *&L, SListNode *&M);//判断两链表是否相交，求交点（假设链表可能带环）


#endif   //__SLISTNODE_H__


//***********SListNode.cpp****函数实现*******

#include"SListNode.h"

SListNode *_BuyNode(DataType x)//开辟新结点
{
 SListNode *tmp = (SListNode *)malloc(sizeof(SListNode));
 tmp->data = x;
 tmp->next = NULL;
 return tmp;
}

void PushBack_p(SListNode **ppHead, DataType x)
{
 assert(ppHead);
 if (*ppHead == NULL)
 {
  *ppHead = _BuyNode(x);
 }
 else
 {
  SListNode *tail = *ppHead;
  while (tail!=NULL)
  {
   tail = tail->next;
  }
  tail = _BuyNode(x);
 }
}

void PushBack(SListNode* &pHead, DataType x)//使用引用 定义别名的方法实现尾插
{
 //不需断言
 if (pHead == NULL)
 {
  pHead = _BuyNode(x);
 }
 else
 {
  SListNode *tail = pHead;
  while (tail->next != NULL)
  {
   tail = tail->next;
  }
  tail->next = _BuyNode(x);
 }
}

void PopBack(SListNode* &pHead)//尾删 
{
 //不需断言
 //注意 空、一个节点 、多个节点三种情况
 if (pHead == NULL)
 {
  printf("SListNode is NULL\n");
  return;
 }
 if (pHead->next == NULL)
 {
  free(pHead);
  pHead = NULL;
 }
 else
 {
  SListNode *tail = pHead;
  while (tail->next->next != NULL)
  {
   tail = tail->next;
  }
  free(tail->next);
  tail->next = NULL;
 }
}

void PushFront(SListNode* &pHead, const DataType x)//头插
{
 //无需断言
 if (pHead == NULL)
 {
  pHead = _BuyNode(x);
 }
 else
 {
  SListNode *tmp = _BuyNode(x);
  tmp->next = pHead;  //针对没有头结点的情况
  pHead = tmp;
 }
}

void PopFront(SListNode* &pHead)//头删
{
 //不需断言
 //注意 空、多个节点三种情况
 if (pHead == NULL)
 {
  printf("SListNode is NULL\n");
  return;
 }
 else
 {
  SListNode *head = pHead->next;
  free(pHead);
  pHead = head;
 }
}

SListNode* Find(SListNode* pHead, const DataType x)
{
 assert(pHead);
 SListNode*tmp = pHead;
 while (tmp != NULL)
 {
  if (tmp->data == x)
   return tmp;
  tmp = tmp->next;
 }
 printf("%d 不在此链表中\n", x);
 return NULL;
 }

void Insert(SListNode* pos, const DataType x)//在pos后插入新结点
{
 if (pos == NULL)
 {
  pos = _BuyNode(x);
 }
 else
 {
  SListNode* tmp = _BuyNode(x);
  tmp->next = pos->next;
  pos->next = tmp;
 }
}

void Erase(SListNode*&pHead, SListNode* pos)//删除pos位置后面的一个元素
{
 //考虑 空、 首元结点、 非首元结点、 不存在pos位置
 assert(pHead);
 assert(pos);
 if (pHead == pos)
 {
  pHead = pHead->next;
  free(pos);
 }
 SListNode* prev = pHead;
 while (prev)
 {
  if (prev->next == pos)
  {
   prev->next = pos->next;
   free(pos);
   pos = NULL;
   break;
  }
  prev = prev->next;
 }
 return;
}

void PrintNode(SListNode *&pHead)
{
 SListNode *tmp = pHead;
 while (tmp)
 {
  printf("%d->", tmp->data);
  tmp = tmp->next;
 }
 printf("NULL\n");
}

void Print_T_to_H(SListNode*&pHead)//从尾到头打印链表
{
 //可用递归实现，以结点为空为结束条件
 if (pHead != NULL)
 {
  Print_T_to_H(pHead->next);
  printf("%d ", pHead->data);
 }
}

void Del_N_tail(SListNode* pos) //删除一个无头链表的非尾结点
{
 //当为空、尾时不删除
 //思路：转换为删除pos的下一个结点，删除之前把值传给pos结点
 if (pos->next)
 {
  pos->data = pos->next->data;
  SListNode *tmp = pos->next;
  pos->next = tmp->next;
  free(tmp);
  tmp = NULL;
 }
}

void InsertFront(SListNode*pos, const DataType x)  //在无头单链表的一个非头结点前插入一个结点
{
 //初步思路：在pos后插入元素，再与pos的值互换(若传入的是头结点则也可运行)
 //还能进行优化为：在pos后插入值为pos->data的结点，再将pos值变为x
 SListNode *tmp = _BuyNode(pos->data);
 tmp->next = pos->next;
 pos->next = tmp;
 pos->data = x;
}

void Turn(SListNode*&pHead)  //逆置链表
{
 //思路：从第二个开始顺次将结点放在头结点位置
 //assert(pHead);//考虑到可能传入NULL时也合理，所以在这里不能使用断言assert
 if (pHead)
 {
  SListNode*NewHead = pHead;
  SListNode*cur = pHead;
  while (cur->next)
  {
   SListNode*tmp = cur->next;
   cur->next = tmp->next;
   tmp->next = NewHead;
   NewHead = tmp;
  }
  pHead = NewHead;
 }
}


SListNode* FindMidOnce(SListNode*&pHead)//查找单链表的中间结点，要求只遍历一次链表
{
 //思路：两个指针一快一慢，快指针走两步，慢指针走一步
 assert(pHead);
 SListNode* fast = pHead;
 SListNode* slow = pHead;
 while (fast&&fast->next)
 {
  slow = slow->next;
  fast = fast->next->next;
 }
 return slow;
}
SListNode* FindLKOnce(SListNode*pHead, int K)//查找链表的倒数第K个结点，要求只遍历一次链表
{
 //思路：两个指针一快一慢，快指针先走K步，然后快慢指针一起走
 assert(pHead);
 if (K <= 0)
  return NULL;
 SListNode* fast = pHead;
 SListNode* slow = pHead;
 while (K--&&fast)
 {
  fast = fast->next;
 }
 if (K >= 0)
 {
  return NULL;
 }
 while (fast)
 {
  fast = fast->next;
  slow = slow->next;
 }
 return slow;
}

SListNode* Joseph(SListNode *&pos, int K) //约瑟夫环直到剩下最后一个结点，求最后一个结点
{
 assert(pos);
 if (K > 0)
 {
  SListNode *tmp = pos;
  while (1)
  {
   int count = K;
   while (--count)
   {
    tmp = tmp->next;
   }
   if (tmp->next == tmp)
    return tmp;
   SListNode *cur = tmp->next;//删除tmp位置的结点，思路：pos与下一位置结点元素值进行交换后，删除下一结点
   DataType Tmpcount = cur->data;
   tmp->next = cur->next;
   cur->data = tmp->data;
   tmp->data = Tmpcount;
   free(cur);
  }
 }
 return NULL;
}


void BubbleSortNode(SListNode *&pHead)//单链表排序
{
 assert(pHead);
 SListNode *tail = NULL;
 int Bool = 0;  //若没有进行交换提前返回

 while (tail!=pHead->next)
 {
  Bool = 0;
  SListNode *tmp = pHead;
  SListNode *tmpnext = tmp->next;
  while (tmp->next != tail)
  {
   if (tmp->data > tmpnext->data)
   {
    DataType x = tmp->data;
    tmp->data = tmpnext->data;
    tmpnext->data = x;
    Bool = 1;
   }
   tmp = tmp->next;
   tmpnext = tmpnext->next;
  } 
  if (Bool == 0)// 已排好序提前返回
   return;
  tail = tmp;
 }
}

SListNode* IsRing(SListNode *&pHead) //判断链表是否有环，求相聚点（环上一点）
{
 //判空、有、没有
 //思路：两个指针从头开始一快（2步）一慢（1步）,若最后可以相聚，则链表有环
 if (pHead)
 {
  SListNode *fast = pHead;
  SListNode *slow = pHead;
  while (fast&&fast->next)
  {
   fast = fast->next->next;
   slow = slow->next;
   if (slow == fast)
    return fast;
  }
  return NULL;
 }
 return NULL;
}

int RingLength(SListNode *&pHead)//求链表环长度
{
 //先判断链表有环
 //思路：从IsRing得到的点开始走一圈环，记录结点个数
 if (pHead)//判空
 {
  SListNode* point = IsRing(pHead);
  if (point != NULL)//无环情况
  {
   int count = 1;
   SListNode *tmp = point->next;
   while (tmp != point)
   {
    tmp = tmp->next;
    count++;
   }
   return count;
  }
 }
 return 0;
}

SListNode* RingEntry(SListNode *&pHead)//找环入口
{
 //判是否为空、有环
 //思路：判断有环，找到快慢指针的相聚点，然后一个指针从聚点开始，一个从头开始，每次一步，相遇点就为入口节点

 if (pHead)//判空
 {
  SListNode *tmp = IsRing(pHead);
  if (tmp)//判有环
  {
   SListNode *cur = pHead;
   while (cur!=tmp)
   {
    cur = cur->next;
    tmp = tmp->next;
   }
   return cur;
  }
  return NULL;
 }
 return NULL;
}

int _LengthNode(SListNode*& pHead)//RingEntry_Point内部函数，求链表长度
{
 if (pHead)
 {
  SListNode *tmp = pHead;
  int count = 0;
  while (tmp)
  {
   count++;
   tmp = tmp->next;
  }
  return count;
 }
 return 0;
}
SListNode* RingEntry_Point(SListNode *&pHead)//找环入口_链表相交法
{
 //判是否为空、有环
 //思路：在快慢指针相聚点截断，将环链表变为两个相交链表，因为相交链表尾部重合呈Y字型，
 //     求两个链表长度之差K，再令一个指针从长链表开始先走K步，令另一个指针从短链表头开始，
 //     两链表一起走，相遇点就为入口点
 //
 //经过调试发现 还必须在返回之前将链表复原，不然会出现丢失链表结点的情况，应对函数进行修改
 //在实现函数功能之后将环复原
 //
 if (pHead)//判空
 {
  SListNode *tmp = IsRing(pHead);
  if (tmp)//判有环
  {
   SListNode *cur = pHead;
   SListNode *NewNode = tmp->next;
   SListNode*tmp_fail = tmp;//将截断处保存
   SListNode*tmp_head = NewNode;
   tmp->next = NULL;//将环从tmp处截断
   int c1 = _LengthNode(cur);
   int c2 = _LengthNode(NewNode);
   int minus = _LengthNode(cur) - _LengthNode(NewNode);
   if (minus > 0)
   {
    while (minus--)
    {
     cur = cur->next;
    }
   }
   else
   {
    int tmp = -minus;
    while (tmp--)
    {
     NewNode = NewNode->next;
    }
   }
   while (NewNode!=cur)
   {
    NewNode = NewNode->next;
    cur = cur->next;
   }
   tmp_fail->next = tmp_head;//将原环修复
   return cur;
  }
  return NULL;
 }
 return NULL;
}

SListNode* Intersect(SListNode *&L, SListNode *&M)//判断两链表是否相交，求交点（假设链表不带环）
{
 //思路：若不带环，只有相交/不想交两种情况
 // 与RingEntry_Point()函数方法相同：
 //     求两个链表长度之差K，再令一个指针从长链表开始先走K步，令另一个指针从短链表头开始，
 //     两链表一起走，相遇点就为入口点
 if (L != NULL&&M != NULL)
 {
  SListNode *cur = L;
  SListNode *NewNode = M;
  int c1 = _LengthNode(cur);
  int c2 = _LengthNode(NewNode);
  int minus = _LengthNode(cur) - _LengthNode(NewNode);
  if (minus > 0)
  {
   while (minus--)
   {
    cur = cur->next;
   }
  }
  else
  {
   int tmp = -minus;
   while (tmp--)
   {
    NewNode = NewNode->next;
   }
  }
  while (NewNode != cur&&NewNode != NULL&&cur != NULL)
  {
   NewNode = NewNode->next;
   cur = cur->next;
  }
  if (NewNode == NULL || cur == NULL)
   return NULL;
  return cur;
 }
 return NULL;
}
 

SListNode* IntersectRing(SListNode *&L, SListNode *&M)//判断两链表是否相交，求交点（假设链表可能带环）
{
 //思路：考虑全部情况：1、不带环 相交/不相交  2、带环 一条带环一条不带环/两条都带环（其中又分交点不在环上/交点在环上）
 //等函数见前篇
 //区分是哪一种情况，分别实现
 if (L != NULL&&M != NULL)
 {
  if (!IsRing(L) && !IsRing(M))//不带环
   return Intersect(L, M);
  else if ((IsRing(L) && !IsRing(M)) || (!IsRing(L) && IsRing(M)))//一条带环一条不带环
   return NULL;
  else
  {
   //先求两链表的环入口点，若入口点一样，则为第5种情况否则是第4、6种情况
   SListNode *re1 = RingEntry(L);
   SListNode *re2 = RingEntry(M);
   if (re1 == re2)//第5种情况 化为不带环相交链表问题
   {
    SListNode* m1 = IsRing(L);
    SListNode*recover = m1->next;// 复原仿照RingEntry_Point()函数
    m1->next = NULL;
    SListNode*cur = Intersect(L, M);
    m1->next = recover;
    return cur;
   }
   else//第4、6种情况若其中一个环入口点在另一个环上，则为第6种情况，否则为第4种情况
   {
    SListNode *tmp = re1->next;
    while (tmp != re1&&tmp != re2)
     tmp = tmp->next;
    if (tmp == re1)//第4种情况
     return NULL;
    printf("两链表带环，并且有两个交点\n");//第6种情况
    SListNode *tmp1 = re1->next;
    re1->next = NULL;
    PrintNode(re1);
    re1->next = tmp1;
    return re2;
   }
  }
 }
 else
  return NULL;
}


//***********test.cpp****************
#define _CRT_SECURE_NO_WARNINGS

#include"SListNode.h"

void Test1()  //PushBack\PopBack
{
 printf("//Test1() PushFront/PopFront\n");
 SListNode *LL = NULL;
 PushBack(LL, 1);
 PushBack(LL, 2);
 PushBack(LL, 3);
 PushBack(LL, 4);
 PrintNode(LL);

 PopBack(LL);
 PrintNode(LL);
 PopBack(LL);
 PrintNode(LL);
 PopBack(LL);
 PrintNode(LL);
 PopBack(LL);
 PrintNode(LL);
 PopBack(LL);
 PrintNode(LL);
}
void Test2()//PushFront\PopFront
{
 printf("//Test2() PushFront/PopFront\n");
 SListNode *LL = NULL;
 PushFront(LL, 1);
 PushFront(LL, 2);
 PushFront(LL, 3);
 PushFront(LL, 4);
 PrintNode(LL);

 PopFront(LL);
 PrintNode(LL);
 PopFront(LL);
 PrintNode(LL);
 PopFront(LL);
 PrintNode(LL);
 PopFront(LL);
 PrintNode(LL);
 PopFront(LL);
 PrintNode(LL);
}
void Test3()
{
 printf("//Test3() Insert/Erase \n");
 SListNode *LL = NULL;
 PushBack(LL, 1);
 PushBack(LL, 2);
 PushBack(LL, 4);
 PushBack(LL, 5);
 PrintNode(LL);
 Insert(LL, 0);
 PrintNode(LL);
 Insert(Find(LL, 5), 6);
 PrintNode(LL);
 Insert(Find(LL, 2), 3);
 PrintNode(LL);

 Erase(LL, Find(LL, 6));
 PrintNode(LL);
 Erase(LL, Find(LL, 0));
 PrintNode(LL);
 Erase(LL, Find(LL, 1));
 PrintNode(LL);
 Erase(LL, Find(LL, 5));
 PrintNode(LL);
 Erase(LL, Find(LL, 2));
 PrintNode(LL);
 Erase(LL, Find(LL, 4));
 PrintNode(LL);
 Erase(LL, Find(LL, 6));//当出现链表中不存在的元素Fine函数会返回NULL，
 //Erase函数第二个参数为NULL，断言assert检测到会返回错误
 //在Erase(LL, Find(LL, 6));处插入断点
 PrintNode(LL);
 Erase(LL, Find(LL, 3));
 PrintNode(LL);
 free(LL);
}

void Test4()// Print_T_to_H/Del_N_tail
{
 printf("//Test4() Print_T_to_H/Del_N_tail \n");
 SListNode *LL = NULL;
 PushBack(LL, 1);
 PushBack(LL, 2);
 PushBack(LL, 3);
 PushBack(LL, 4);
 PrintNode(LL);
 Print_T_to_H(LL);
 printf("\n");
 Del_N_tail(Find(LL,3));//中间结点
 Print_T_to_H(LL);
 printf("\n");
 Del_N_tail(Find(LL, 1));//首元结点
 Print_T_to_H(LL);
 printf("\n");
 Del_N_tail(Find(LL, 4));//尾结点
 Print_T_to_H(LL);
}


void Test5()  //InsertFront/Turn
{
 printf("//Test5() InsertFront/Turn \n");
 SListNode *LL = NULL;
 PushBack(LL, 1);
 PushBack(LL, 2);
 PushBack(LL, 3);
 PushBack(LL, 5);
 PrintNode(LL);
 InsertFront(Find(LL,1),0);
 PrintNode(LL);
 InsertFront(Find(LL, 5), 4);
 PrintNode(LL);
 Turn(LL);
 PrintNode(LL);
}

void Test6()  //  FindMidOnce/FindLKOnce
{
 printf("//Test6() FindMidOnce/FindLKOnce \n");
 SListNode *LL = NULL;
 SListNode *tmp = NULL;
 PushBack(LL, 1);
 PushBack(LL, 2);
 PushBack(LL, 3);
 PushBack(LL, 5);
 PrintNode(LL);

 printf("FindMidOnce = %d \n", FindMidOnce(LL)->data);

 tmp = FindLKOnce(LL, 0);
 printf("\n(找倒数第0个结点)\nFindMidOnce = ");
 PrintNode(tmp);

 tmp = FindLKOnce(LL, 1);
 printf("\n(找倒数第1个结点)\nFindMidOnce = ");
 PrintNode(tmp);

 tmp = FindLKOnce(LL, 4);
 printf("\n(找倒数第4个结点)\nFindMidOnce = ");
 PrintNode(tmp);

 tmp = FindLKOnce(LL, 5);
 printf("\n(找不存在的结点倒数第5个结点)\nFindMidOnce = ");
 PrintNode(tmp);
 
}

void Test7()// Joseph
{
 printf("//Test7() Joseph \n");
 SListNode *LL = NULL;
 PushBack(LL, 1);
 PushBack(LL, 2);
 PushBack(LL, 3);
 PushBack(LL, 4);
 PushBack(LL, 5);
 PushBack(LL, 6);
 PushBack(LL, 7);
 Find(LL, 7)->next = Find(LL, 1);
 printf("%d\n", Joseph(LL, 3)->data);
}

void Test8()//BubbleSortNode
{
 printf("//Test8() BubbleSortNode \n");
 SListNode *LL = NULL;
 PushBack(LL, 1);
 PushBack(LL, 2);
 PushBack(LL, 6);
 PushBack(LL, 3);
 PushBack(LL, 7);
 PushBack(LL, 0);
 PushBack(LL, 3);
 PrintNode(LL);

 BubbleSortNode(LL);
 PrintNode(LL);
}

void Test9()  //IsRing/RingLength/RingEntry/RingEntry_Point
{
 printf("//Test9() IsRing/RingLength/RingEntry/RingEntry_Point \n");
 SListNode *LL = NULL;
 PushBack(LL, 1);
 PushBack(LL, 2);
 PushBack(LL, 3);
 PushBack(LL, 4);
 PushBack(LL, 5);
 PrintNode(LL);
 //printf("%d\n", _LengthNode(LL));

 printf("\nRingLength = %d\n", RingLength(LL));//不是环
 SListNode*tmp = RingEntry(LL);
 PrintNode(tmp);
 tmp = RingEntry_Point(LL);
 PrintNode(tmp);

 Find(LL, 5)->next = Find(LL, 5);//尾结点呈环
 printf("\nRingLength = %d\n", RingLength(LL));
 printf("RingEntry = %d\n", RingEntry(LL)->data);
 printf("RingEntry_Point = %d\n", RingEntry_Point(LL)->data);

 Find(LL, 5)->next = Find(LL, 3);//中间结点开始呈环
 printf("\nRingLength = %d\n", RingLength(LL));
 printf("RingEntry = %d\n", RingEntry(LL)->data);
 printf("RingEntry_Point = %d\n", RingEntry_Point(LL)->data);//由于函数实现时没有将断开的环闭合，导致丢失数据
 //函数RingEntry_Point在此处将原链表破坏丢失元素5，所以在函数实现时必须将环复原

 Find(LL, 5)->next = Find(LL, 1);//整个链表为环链表已不存在元素为5的结点 出现错误 所以在函数实现时必须将环复原
 //整个链表为环

 printf("\nRingLength = %d\n", RingLength(LL));
 printf("RingEntry = %d\n", RingEntry(LL)->data);
 printf("RingEntry_Point = %d\n", RingEntry_Point(LL)->data);
}

void Test10()
{
 printf("//Test10() Intersect() \n");
 SListNode *LL = NULL;
 PushBack(LL, 1);
 PushBack(LL, 2);
 PushBack(LL, 3);
 PushBack(LL, 4);
 PushBack(LL, 5);
 PrintNode(LL);

 SListNode *MM = NULL;
 PushBack(MM, 1);
 PushBack(MM, 2);
 MM->next->next = LL->next->next->next;
 PrintNode(MM);

 SListNode *NN = NULL;
 PushBack(NN, 7);
 PushBack(NN, 8);
 PushBack(NN, 9);
 PushBack(NN, 0);
 PrintNode(NN);
 SListNode* c1 = Intersect(LL, MM);
 SListNode* c2 = Intersect(LL, NN);
 PrintNode(c1);
 PrintNode(c2);
}

void Test11()
{
 printf("//Test11() IntersectRing() \n");
 SListNode *LL = NULL;
 PushBack(LL, 1);
 PushBack(LL, 2);
 PushBack(LL, 3);
 PushBack(LL, 4);
 PushBack(LL, 5);
 PrintNode(LL);

 SListNode *NN = NULL;
 PushBack(NN, 6); 
 PushBack(NN, 7);
 PushBack(NN, 8);
 PushBack(NN, 9);
 PushBack(NN, 0);
 PrintNode(NN);

 SListNode* c1 = IntersectRing(LL, NN);//第1种
 PrintNode(c1);
 printf("\n");

 SListNode *MM = NULL;//第2种
 PushBack(MM, 0);
 PushBack(MM, 1);
 MM->next->next = LL->next;
 SListNode* c2 = IntersectRing(LL, MM);
 PrintNode(c2);
 printf("\n");

 Find(LL, 5)->next = Find(LL, 3);//第3种
 SListNode* c3 = IntersectRing(LL, NN);
 SListNode* c4 = IntersectRing(NN, LL);
 PrintNode(c3);
 PrintNode(c4);
 printf("\n");

 Find(NN, 0)->next = Find(NN, 8);//第4种
 SListNode* c5 = IntersectRing(NN, LL);
 PrintNode(c5);
 printf("\n");

 SListNode* c6 = IntersectRing(MM, LL);//第5种
 SListNode* c7 = IntersectRing(LL, MM);
 SListNode* tmp1 = c6->next;
 c6->next = NULL;
 PrintNode(c6);
 c6->next = tmp1;

 SListNode* tmp2 = c7->next;
 c7->next = NULL;
 PrintNode(c7);
 c7->next = tmp2;
 printf("\n");

 Find(NN, 0)->next = Find(LL, 4);//第6种
 SListNode* c9 = IntersectRing(NN, LL);
 SListNode* tmp3 = c9->next;
 c9->next = NULL;
 PrintNode(c9);
 c9->next = tmp3;
 SListNode* c10 = IntersectRing(LL, NN);
 SListNode* tmp4 = c10->next;
 c10->next = NULL;
 PrintNode(c10);
 c10->next = tmp4;
 printf("\n");

 Find(LL, 5)->next = Find(LL, 1);//第6种
 Find(NN, 0)->next = Find(LL, 4);
 SListNode* c11 = IntersectRing(NN, LL);
 SListNode* tmp5 = c11->next;
 c11->next = NULL;
 PrintNode(c11);
 c11->next = tmp5;
 SListNode* c12 = IntersectRing(LL, NN);
 SListNode* tmp6 = c12->next;
 c12->next = NULL;
 PrintNode(c12);
 c12->next = tmp6;
 printf("\n");

}

int main()
{
 //Test1();
 //Test2();
 //Test3();
 //Test4();
 //Test5();
 //Test6();
 //Test7();
 //Test8();
 //Test9();
 //Test10();
 Test11();
 system("pause");
 return 0;
}