/***********************************************************************************
xxx.h:
Copyright Inc.(2013), All rights reserved.
Purpose: C语言实现单链表--不带头结点实现
Author: MaJing
Reviser: yyy
Created Time: 2016_9
************************************************************************************/
#pragma once
#include
#include
#include
#include
typedef int DataType;
typedef struct ListNode
{
DataType _data; // 数据
struct ListNode* _next; // 指向下一个节点的指针
}ListNode, *PListNode;
//
// ps:PushBack/PopBack等接口的参数使用PListNode*的二级指针做参数,
// 如:void PushBack (PListNode& ppList, DataType x);
//
/////////////////////////////////////////////////////////////////////////////////
// 单链表的基本操作
// 初始化/销毁/打印单链表
void InitSList(PListNode* ppList);
void DestorySList(PListNode* ppList);
void PrintSList(PListNode pList);
int GetLength(PListNode pList);
// 尾插/尾删/头插/头删
void PushBack (PListNode* ppList, DataType x);
void PopBack (PListNode* ppList);
void PushFront (PListNode* ppList, DataType x);
void PopFront (PListNode* ppList);
// 查找/删除/插入
ListNode* Find (PListNode pList, DataType x);
int Remove (PListNode* ppList, DataType x);
void Erase (PListNode* ppList, ListNode* n);
void Insert (PListNode* ppList, ListNode* n, DataType x);
void InitSList(PListNode* ppList)
{
assert(ppList);
*ppList = 0;
}
void DestorySList(PListNode* ppList)
{
ListNode* begin = *ppList;
assert(ppList);
while (begin)
{
ListNode* tmp = begin;
begin = begin->_next;
free (tmp);
}
*ppList = 0;
}
void PrintSList(PListNode pList)
{
ListNode* begin = pList;
printf("PListNode:");
while (begin)
{
printf("->%d", begin->_data);
begin = begin->_next;
}
printf("->NULL\n");
}
int GetLength(PListNode ppList)
{
int length = 0;
ListNode* begin = ppList;
while (begin)
{
length++;
begin = begin->_next;
}
return length;
}
ListNode* CreateNode (DataType x)
{
ListNode* n = (ListNode*)malloc (sizeof(ListNode));
n->_data = x;
n->_next = 0;
return n;
}
void PushBack (PListNode* ppList, DataType x)
{
ListNode* n = 0;
assert(ppList);
n = CreateNode (x);
// 没有节点/一个以上
if (*ppList == NULL)
{
*ppList = n;
}
else
{
ListNode* begin = *ppList;
while (begin->_next)
{
begin = begin->_next;
}
begin->_next = n;
}
}
void PopBack (PListNode* ppList)
{
ListNode* begin = 0;
assert(ppList);
// 1.没有节点
if (*ppList == 0)
{
return;
}
// 2.一个节点
if ((*ppList)->_next == 0)
{
free(*ppList);
*ppList = 0;
return;
}
// 3.有两个以上的节点
begin = *ppList;
while(begin->_next->_next != NULL)
{
begin = begin->_next;
}
free(begin->_next);
begin->_next = 0;
}
void PushFront (PListNode* ppList, DataType x)
{
ListNode* n = 0;
assert(ppList);
n = CreateNode(x);
//
// 1:没有节点
// 2:一个或以上节点
//
if (*ppList == NULL)
{
*ppList = n;
}
else
{
n->_next = *ppList;
*ppList = n;
}
}
void PopFront (PListNode* ppList)
{
ListNode* n = 0;
assert(ppList);
// 1.没有节点
if (*ppList == NULL)
{
return;
}
// 2.一个节点
if((*ppList)->_next == NULL)
{
free(*ppList);
*ppList = NULL;
return;
}
// 3.两个节点以上
n = *ppList;
*ppList = n->_next;
free(n);
}
ListNode* Find (PListNode ppList, DataType x)
{
ListNode* begin = 0;
assert(ppList);
begin = ppList;
while (begin)
{
if (begin->_data == x)
{
return begin;
}
begin = begin->_next;
}
return 0;
}
void Erase (PListNode* ppList, ListNode* n)
{
ListNode* del = 0;
assert(ppList);
assert(n);
// 处理尾节点的情况
if(n->_next == 0)
{
PopBack(ppList);
return;
}
// 将n的下一个next节点的值赋值给n, 删除n的next节点。
n->_data = n->_next->_data;
del = n->_next;
n->_next = n->_next->_next;
free(del);
}
int Remove (PListNode* ppList, DataType x)
{
ListNode* prev = 0;
ListNode* begin = 0;
ListNode* del = 0;
assert(ppList);
begin = *ppList;
while (begin)
{
if (begin->_data == x)
{
ListNode* del = begin;
// 头节点 or 中间节点
if (*ppList == begin)
{
*ppList = (*ppList)->_next;
}
else
{
prev->_next = begin->_next;
}
free(del);
return 0;
}
prev = begin;
begin = begin->_next;
}
return -1;
}
void Insert (PListNode* ppList, ListNode* n, DataType x)
{
ListNode* tmp = 0;
assert(ppList);
tmp = CreateNode(x);
// 没有节点 / 一个以上节点
if(*ppList == NULL)
{
*ppList = tmp;
}
else
{
assert(n);
tmp->_next = n->_next;
n->_next = tmp;
}
}
//////////////////////////////////////////////////////////////////////////////////////
// 链表相关面试题
//
//1. 比较顺序表和链表的优缺点,说说它们分别在什么场景下使用?
//2. 从尾到头打印单链表
//3. 删除一个无头单链表的非尾节点
//4. 在无头单链表的一个非头节点前插入一个节点
//5. 单链表实现约瑟夫环
//6. 逆置/反转单链表
//7. 单链表排序(冒泡排序&快速排序)
//8. 合并两个有序链表,合并后依然有序
//9. 查找单链表的中间节点,要求只能遍历一次链表
//10. 查找单链表的倒数第k个节点,要求只能遍历一次链表
//11. 判断单链表是否带环?若带环,求环的长度?求环的入口点?并计算每个算法的时间复杂度&空间复杂度。
//12. 判断两个链表是否相交,若相交,求交点。(假设链表不带环)
//13. 判断两个链表是否相交,若相交,求交点。(假设链表可能带环)【升级版】
//14. 复杂链表的复制。一个链表的每个节点,有一个指向next指针指向下一个节点,还有一个random指针指向这个链表中的一个随机节点或者NULL,现在要求实现复制这个链表,返回复制后的新链表。
//15.求两个已排序链表中相同的数据。void UnionSet(ListNode* l1, ListNode* l2);
//
// 删除单链表的一个非尾节点
void DelNonTailNode (ListNode* n)
{
ListNode* del = 0;
// 断言是否是尾节点
assert(n->_next);
// 将n的下一个next节点的值赋值给n, 删除n的next节点。
n->_data = n->_next->_data;
del = n->_next;
n->_next = n->_next->_next;
free(del);
}
// 在当前节点前插入一个数据x
void InsertFrontNode (ListNode* n, DataType x)
{
DataType tmpData;
ListNode* tmpNode = CreateNode(x);
assert(n);
// 数据插到当前节点后
tmpNode->_next = n->_next;
n->_next = tmpNode;
// 交换数据
tmpData = n->_data;
n->_data = tmpNode->_data;
tmpNode->_data = tmpData;
}
//
//约瑟夫环(约瑟夫问题)是一个数学的应用问题:已知n个人(以编号1,2,3...n分别表示)围坐在一张//圆桌周围。从编号为k的人开始报数,数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人//又出列;依此规律重复下去,直到圆桌周围的人全部出列。
//
ListNode* JosephCycle(PListNode pList, int m)
{
ListNode* begin = pList;
assert(pList);
while (1)
{
ListNode* del = 0;
int i = 0;
// 判断只有一个节点时退出
if (begin->_next == begin)
{
break;
}
// 跳m-1步
for (; i < m-1 ; ++i)
{
begin = begin->_next;
}
printf("%d ", begin->_data);
// 替换删除法进行删除
del = begin->_next;
begin->_data = begin->_next->_data;
begin->_next = begin->_next->_next;
free(del);
}
return begin;
}
// 逆置
void Reverse (PListNode& pList)
{
ListNode* newHead = NULL;
ListNode* cur = pList;
// 从第二个节点开始进行头插。
while (cur)
{
// 摘节点
ListNode* tmp = cur;
cur = cur->_next;
// 头插
tmp->_next = newHead;
newHead = tmp;
}
// 更新头结点指针
pList = newHead;
}
// 排序-(冒泡升序排序)
void BubbleSort(PListNode pList)
{
ListNode* prev = NULL;
ListNode* next = NULL;
ListNode* tail = NULL;
// tail做冒泡排序的尾标记
while (tail != pList)
{
// 优化标记
int exchange = 0;
// 将数据向后冒
prev = pList;
next = pList->_next;
while(next != tail)
{
if (prev->_data > next->_data)
{
DataType tmp = prev->_data;
prev->_data = next->_data;
next->_data = tmp;
exchange = 1;
}
prev = next;
next = next->_next;
}
if (exchange == 0)
return;
// 更新尾标记
tail = prev;
}
}
//
// 使用前后指针版的快速排序
//
void PartionSort(ListNode* left, ListNode* right)
{
if (left == right || left->_next == right)
return;
// left和right是[)的区间
ListNode* key = left;
// 一前一后指针在调整序列
ListNode* prev = left, *next = left->_next;
while (next != right)
{
// 如果找到比key小的值则进行交换
if (next->_data <= key->_data)
{
prev = prev->_next;
if (prev != next)
{
swap(prev->_data, next->_data);
}
}
next = next->_next;
}
if (prev != key)
{
swap(prev->_data, key->_data);
}
PartionSort(left, prev);
PartionSort(prev->_next, right);
}
// 排序优化->快速排序 left和right是[)的区间
void QucikSort(PListNode pList)
{
PartionSort(pList, NULL);
}
// 合并两个有序链表,合并后的链表依然有序
PListNode Merge(PListNode pList1, PListNode pList2)
{
// 若其中一个链表为空,则返回另一个链表
if (pList1 == NULL)
{
return pList2;
}
if (pList2 == NULL)
{
return pList2;
}
PListNode newList, tail;
// 取出数据小的节点为新链表的头结点。
if (pList1->_data < pList2->_data)
{
newList = pList1;
pList1 = pList1->_next;
}
else
{
newList = pList2;
pList2 = pList2->_next;
}
// 标记尾节点,方便归并的数据尾插。
tail = newList;
while (pList1 && pList2)
{
if (pList1->_data < pList2->_data)
{
tail->_next = pList1;
pList1 = pList1->_next;
tail = tail->_next;
}
else
{
tail->_next = pList2;
pList2 = pList2->_next;
tail = tail->_next;
}
}
// 链接剩余尾链表
if (pList1)
{
tail->_next = pList1;
}
if (pList2)
{
tail->_next = pList2;
}
return newList;
}
// 递归实现链表合并
PListNode MergeRecursive(PListNode pList1, PListNode pList2)
{
PListNode mergePList;
// 若两个链表相同,则直接返回
if (pList1 == pList2)
{
return pList1;
}
// 若其中一个链表为空,则返回另一个链表
if (pList1 == NULL)
{
return pList2;
}
if (pList2 == NULL)
{
return pList2;
}
if (pList1->_data < pList2->_data)
{
mergePList = pList1;
mergePList->_next = MergeRecursive(pList1->_next, pList2);
}
else
{
mergePList = pList2;
mergePList->_next = MergeRecursive(pList1, pList2->_next);
}
return mergePList;
}
// 【快慢指针问题】
// 查找单链表的中间节点
PListNode FindMidNode(PListNode pList)
{
// 快慢指针,快指针一次走两步,慢指针一次走一步。
PListNode slow, fast;
slow = pList;
fast = pList;
while (fast && fast->_next)
{
slow = slow->_next;
fast = fast->_next->_next;
}
//
// fast 为空则链表长度为偶数,slow为中间节点。
// fast->next为空则链表长度为奇数,slow为中间节点。
//
return slow;
}
// 删除单链表的倒数第k个节点(k > 1 && k < 链表的总长度);
// 时间复杂度O(N)
void DelKNode(PListNode pList, int k)
{
PListNode slow, fast;
slow = pList;
fast = pList;
assert(k > 1);
// 快指针走k步以后,慢指针才开始移动
while (fast)
{
if (--k < 0)
{
slow = slow->_next;
}
fast = fast->_next;
}
if (k < 0)
{
ListNode* del = slow->_next;
slow->_data = slow->_next->_data;
slow->_next = slow->_next->_next;
free(del);
}
}
// 【链表带环问题】
// 判断链表是否带环, 若链表带环则求环的长度和相遇节点,不带环返回-1
int CheckCycle(PListNode pList, PListNode* meetNode)
{
PListNode slow, fast;
if (pList == NULL)
{
return -1;
}
slow = pList;
fast = pList;
//
// 使用快慢指针,当快指针追上慢指针,则表示有环,否则表示无环。
//
while (fast && fast->_next)
{
slow = slow->_next;
fast = fast->_next->_next;
if (slow == fast)
{
// 慢指针再跑一圈,计算环的长度。
int cycleLength = 0;
*meetNode = fast;
do{
slow = slow->_next;
++cycleLength;
}while (slow != fast);
return cycleLength;
}
}
// 链表不带环则返回-1
return -1;
}
//
// 获取环入口点
// 获取环的入口点还有另外一种简单的方法--一个指针从相遇点开始走
// 另外一个指针从头开始走,两个指针相遇时,则是入口点,请进行证明!^^
//
ListNode* GetCycleEntryNode(PListNode pList, PListNode meetNode)
{
int length1 = 0, length2 = 0, interval = 0;
ListNode* begin1 = pList, *begin2 = meetNode->_next;
assert(pList);
assert(meetNode);
//
// 1:模拟从相遇节点断开环,则转换为两单链表相交,求交点的问题。
//
while (begin1 != meetNode)
{
begin1 = begin1->_next;
++length1;
}
while (begin2 != meetNode)
{
begin2 = begin2->_next;
++length2;
}
// 2:先计算两个链表的长度,长的链表先走interval(两链表长度的差值)步。
begin1 = pList, begin2 = meetNode->_next; // 重置链表起点
if (length1 > length2)
{
interval = length1 - length2;
while (interval--)
{
begin1 = begin1->_next;
}
}
else if(length1 < length2)
{
interval = length2 - length1;
while (interval--)
{
begin2 = begin2->_next;
}
}
// 3:则第一次相遇的节点为环的入口点。
while (begin1 != begin2)
{
begin1 = begin1->_next;
begin2 = begin2->_next;
}
return begin1;
}
// 【链表相交问题】
//
// 判断两个链表是否相交,假设两个链表都不带环。
// 求环的交点,长链表先走n步(n为两链表的长度差),然后再一起走,第一个相遇点则为交点。(未实现)
// 这里还需要考虑链表带环时,链表的相交问题。
//
int CheckCross(PListNode pList1, PListNode pList2)
{
ListNode* end1 = 0, *end2 = 0;
assert(pList1 && pList2);
while (pList1)
{
end1 = pList1;
pList1 = pList1->_next;
}
while (pList2)
{
end2 = pList2;
pList2 = pList2->_next;
}
if (end1 == end2)
{
return 1;
}
return 0;
}
//
// 复杂链表的复制。
// 一个链表的每个节点,有一个指向next指针指向下一个节点,还有一个random指针指向这
// 个链表中的一个随机节点或者NULL,现在要求实现复制这个链表,返回复制后的新链表。
//
typedef struct ComplexNode
{
DataType _data; // 数据
struct ComplexNode* _next; // 指向下一个节点的指针
struct ComplexNode* _random; // 指向随机节点
}ComplexNode;
ComplexNode* CreateComplexNode(DataType x)
{
ComplexNode* tmp = new ComplexNode;
tmp->_data = x;
tmp->_next = NULL;
tmp->_random = NULL;
return tmp;
}
void CreateComplexList(ComplexNode*& head)
{
ComplexNode* n1 = CreateComplexNode(1);
ComplexNode* n2 = CreateComplexNode(2);
ComplexNode* n3 = CreateComplexNode(3);
ComplexNode* n4 = CreateComplexNode(4);
n1->_next = n2;
n2->_next = n3;
n3->_next = n4;
n4->_next = NULL;
n1->_random = n4;
n2->_random = n3;
n3->_random = n2;
n4->_random = n1;
head = n1;
}
void PrintComplexList(ComplexNode* head)
{
while (head)
{
printf("【%d】", head->_data);
printf(":random->%d", head->_random->_data);
printf(":next->");
head = head->_next;
}
printf("NULL\n");
}
ComplexNode* CopyComplexList(ComplexNode* cpList)
{
ComplexNode* head = cpList;
// 1.将copy出新链表的节点插在原链表每个节点的后面
head = cpList;
while (head)
{
ComplexNode* tmp = CreateComplexNode(head->_data);
ComplexNode* prev = head;
head = head->_next;
prev->_next = tmp;
tmp->_next = head;
}
// 2.处理copy链表节点的random指向
head = cpList;
while (head)
{
ComplexNode* random = head->_random;
ComplexNode* next = head->_next;
if (random)
{
next->_random = random->_next;
}
head = head->_next->_next;
}
// 3.摘下copy链表节点,构建出copy链表
head = cpList;
ComplexNode* newHead, *newTail;
if (head)
{
newHead = head->_next;
newTail = head->_next;
// 摘下copy节点
head->_next = head->_next->_next;
head = head->_next;
}
while (head)
{
newTail->_next = head->_next;
newTail = newTail->_next;
// 摘下copy节点
head->_next = head->_next->_next;
head = head->_next;
}
return newHead;
}
// 测试PushBack
void Test1()
{
PListNode pList;
printf("Test PushBack begin\n");
InitSList(&pList);
PushBack(&pList, 1);
PushBack(&pList, 2);
PushBack(&pList, 3);
PushBack(&pList, 4);
PrintSList(pList);
DestorySList(&pList);
printf("Test PushBack end\n\n");
}
// 测试PopBack
void Test2()
{
PListNode pList;
printf("Test PopBack begin\n");
InitSList(&pList);
PushBack(&pList, 1);
PushBack(&pList, 2);
PushBack(&pList, 3);
PushBack(&pList, 4);
PrintSList(pList);
PopBack(&pList);
PopBack(&pList);
PopBack(&pList);
PopBack(&pList);
PrintSList(pList);
DestorySList(&pList);
printf("Test PopBack end\n\n");
}
// PushFront
void Test3()
{
PListNode pList;
printf("Test PushFront begin\n");
InitSList(&pList);
PushFront(&pList, 1);
PushFront(&pList, 2);
PushFront(&pList, 3);
PushFront(&pList, 4);
PrintSList(pList);
DestorySList(&pList);
printf("Test PushFront end\n\n");
}
// PopFront
void Test4()
{
PListNode pList;
printf("Test PopFront begin\n");
InitSList(&pList);
PushFront(&pList, 1);
PushFront(&pList, 2);
PushFront(&pList, 3);
PushFront(&pList, 4);
PrintSList(pList);
PopFront(&pList);
PopFront(&pList);
PopFront(&pList);
PopFront(&pList);
PrintSList(pList);
DestorySList(&pList);
printf("Test PopFront end\n\n");
}
// Find
void Test5()
{
PListNode pList;
printf("Test Find begin\n");
InitSList(&pList);
PushFront(&pList, 1);
PushFront(&pList, 2);
PushFront(&pList, 3);
PushFront(&pList, 4);
PrintSList(pList);
if(Find(pList, 4))
{
printf("Find 4 Success\n");
}
if(Find(pList, 5) == 0)
{
printf("Not Find 5\n");
}
DestorySList(&pList);
printf("Test Find end\n\n");
}
// Remove
void Test6()
{
PListNode pList;
printf("Test Remove begin\n");
InitSList(&pList);
PushFront(&pList, 1);
PushFront(&pList, 2);
PushFront(&pList, 3);
PushFront(&pList, 4);
PrintSList(pList);
Remove(&pList, 1);
Remove(&pList, 2);
Remove(&pList, 3);
Remove(&pList, 4);
PrintSList(pList);
DestorySList(&pList);
printf("Test Remove end\n\n");
}
// Insert
void Test7()
{
PListNode pList;
printf("Test Insert begin\n");
InitSList(&pList);
Insert(&pList, pList, 1);
Insert(&pList, pList, 2);
Insert(&pList, pList, 3);
PrintSList(pList);
DestorySList(&pList);
printf("Test Insert end\n\n");
}
// Erase
void Test8()
{
ListNode* del = 0;
PListNode pList;
printf("Test Erase begin\n");
InitSList(&pList);
PushFront(&pList, 1);
PushFront(&pList, 2);
PrintSList(pList);
del = Find(pList, 1);
Erase(&pList, del);
del = Find(pList, 2);
Erase(&pList, del);
PrintSList(pList);
DestorySList(&pList);
printf("Test Erase end\n\n");
}
/////////////////////////////////////////////////////////////////////////////////
// 面试题测试
// Reverse
void Test9()
{
ListNode* del = 0;
PListNode pList;
printf("Test Reverse begin\n");
InitSList(&pList);
PushFront(&pList, 1);
PushFront(&pList, 2);
PushFront(&pList, 3);
PushFront(&pList, 4);
PrintSList(pList);
Reverse(pList);
PrintSList(pList);
DestorySList(&pList);
printf("Test Reverse end\n\n");
}
// Sort & SortOP
void Test10()
{
ListNode* del = 0;
PListNode pList;
printf("Test Sort begin\n");
InitSList(&pList);
//PushFront(&pList, 6);
//PushFront(&pList, 4);
//PushFront(&pList, 1);
//PushFront(&pList, 5);
//PushFront(&pList, 3);
//PushFront(&pList, 2);
//PushFront(&pList, 7);
//PushFront(&pList, 8);
//PushFront(&pList, 8);
//PushFront(&pList, 9);
//PushFront(&pList, 0);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 4);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 4);
PushBack(&pList, 4);
PushBack(&pList, 4);
PushBack(&pList, 4);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 2);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 4);
PushBack(&pList, 4);
PushBack(&pList, 4);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 3);
PushBack(&pList, 4);
PrintSList(pList);
//BubbleSort(pList);
QucikSort(pList);
PrintSList(pList);
DestorySList(&pList);
printf("Test Sort end\n\n");
}
// Merge
void Test11()
{
ListNode* del = 0;
PListNode pList1;
PListNode pList2;
PListNode mergePList;
printf("Test Merge begin\n");
InitSList(&pList1);
InitSList(&pList2);
InitSList(&mergePList);
PushFront(&pList1, 1);
PushFront(&pList1, 2);
PushFront(&pList1, 3);
PushFront(&pList1, 4);
PushFront(&pList2, 10);
PrintSList(pList1);
PushFront(&pList2, 0);
PushFront(&pList2, 1);
PushFront(&pList2, 5);
PushFront(&pList2, 8);
PushFront(&pList2, 9);
PrintSList(pList2);
BubbleSort(pList1);
BubbleSort(pList2);
mergePList = Merge(pList1, pList2);
PrintSList(mergePList);
DestorySList(&mergePList);
printf("Test Merge end\n\n");
}
// MergeRecursive
void Test12()
{
ListNode* del = 0;
PListNode pList1;
PListNode pList2;
PListNode mergePList;
printf("Test MergeRecursive begin\n");
InitSList(&pList1);
InitSList(&pList2);
InitSList(&mergePList);
PushFront(&pList1, 1);
PushFront(&pList1, 2);
PushFront(&pList1, 3);
PushFront(&pList1, 4);
PushFront(&pList2, 10);
PrintSList(pList1);
PushFront(&pList2, 0);
PushFront(&pList2, 1);
PushFront(&pList2, 5);
PushFront(&pList2, 8);
PushFront(&pList2, 9);
PrintSList(pList2);
BubbleSort(pList1);
BubbleSort(pList2);
mergePList = MergeRecursive(pList1, pList2);
PrintSList(mergePList);
DestorySList(&mergePList);
printf("Test MergeRecursive end\n\n");
}
// DelNonTailNode
void Test13()
{
ListNode* del = 0;
PListNode pList;
printf("Test DelMidNode begin\n");
InitSList(&pList);
PushFront(&pList, 1);
PushFront(&pList, 2);
PushFront(&pList, 3);
PushFront(&pList, 4);
PrintSList(pList);
del =Find(pList, 3);
DelNonTailNode(del);
PrintSList(pList);
DestorySList(&pList);
printf("Test DelMidNode end\n\n");
}
// InsertFrontNode
void Test14()
{
ListNode* n = 0;
PListNode pList;
printf("Test InsertFrontNode begin\n");
InitSList(&pList);
PushFront(&pList, 1);
PushFront(&pList, 2);
PushFront(&pList, 3);
PushFront(&pList, 4);
PrintSList(pList);
n =Find(pList, 3);
InsertFrontNode(n, 0);
PrintSList(pList);
DestorySList(&pList);
printf("Test InsertFrontNode end\n\n");
}
// FindMidNode
void Test15()
{
ListNode* n = 0;
PListNode pList;
printf("Test FindMidNode begin\n");
InitSList(&pList);
PushBack(&pList, 1);
PushBack(&pList, 2);
PushBack(&pList, 3);
PushBack(&pList, 4);
PrintSList(pList);
n =FindMidNode(pList);
printf("Mid: %d\n", n->_data);
PushBack(&pList, 5);
PrintSList(pList);
n =FindMidNode(pList);
printf("Mid: %d\n", n->_data);
DestorySList(&pList);
printf("Test FindMidNode end\n\n");
}
// DelKNode
void Test16()
{
ListNode* n = 0;
PListNode pList;
printf("Test DelKNode begin\n");
InitSList(&pList);
PushBack(&pList, 1);
PushBack(&pList, 2);
PushBack(&pList, 3);
PushBack(&pList, 4);
PrintSList(pList);
DelKNode(pList, 3);
PrintSList(pList);
DestorySList(&pList);
printf("Test DelKNode end\n\n");
}
// CheckCycle
void Test17()
{
int length = 0;
ListNode* realEntry = 0, *getEntry = 0;
ListNode* end = 0;
PListNode pList;
PListNode meetNode = 0;
printf("Test CheckCycle begin\n");
InitSList(&pList);
PushBack(&pList, 1);
PushBack(&pList, 2);
PushBack(&pList, 3);
PushBack(&pList, 4);
PushBack(&pList, 5);
PushBack(&pList, 6);
PushBack(&pList, 7);
PrintSList(pList);
length = CheckCycle(pList, &meetNode);
printf("Plist Length:%d\n", length);
// 创建带环链表
end = Find(pList, 7);
realEntry = Find(pList, 4);
end->_next = realEntry;
printf("realEntry:%d\n", realEntry->_data);
length = CheckCycle(pList, &meetNode);
printf("Plist Length:%d, meetNode: %d\n", length, meetNode->_data);
getEntry = GetCycleEntryNode(pList, meetNode);
printf("realEntry:%d, getEntry: %d\n", realEntry->_data, getEntry->_data);
// 解环
end->_next = 0;
DestorySList(&pList);
printf("Test CheckCycLeLength end\n\n");
}
// CheckCross
void Test18()
{
PListNode pList1, pList2;
ListNode* realCrossNode, *end;
printf("Test CheckCross begin\n");
InitSList(&pList1);
InitSList(&pList2);
PushBack(&pList1, 1);
PushBack(&pList1, 2);
PushBack(&pList1, 3);
PushBack(&pList1, 4);
PushBack(&pList1, 5);
PushBack(&pList1, 6);
PushBack(&pList1, 7);
PrintSList(pList1);
PushBack(&pList2, 10);
PushBack(&pList2, 11);
PushBack(&pList2, 12);
PrintSList(pList2);
printf("Cross: %d\n", CheckCross(pList1, pList2));
// 创建相交链表
realCrossNode = Find(pList1, 4);
end = Find(pList2, 12);
end->_next = realCrossNode;
printf("Cross: %d\n", CheckCross(pList1, pList2));
// 解开
end->_next = NULL;
DestorySList(&pList1);
DestorySList(&pList2);
printf("Test CheckCycLeLength end\n\n");
}
// JosephCycle
void Test19()
{
ListNode* end;
PListNode pList;
printf("Test JosephCycle begin\n");
InitSList(&pList);
PushBack(&pList, 1);
PushBack(&pList, 2);
PushBack(&pList, 3);
PushBack(&pList, 4);
PushBack(&pList, 5);
PushBack(&pList, 6);
PushBack(&pList, 7);
PrintSList(pList);
// 创建带环链表
end = Find(pList, 7);
end->_next = pList;
printf("JosephCycle:%d\n", JosephCycle(pList, 3)->_data);
printf("Test JosephCycle end\n\n");
}
// 复杂链表的复制
void Test20()
{
ComplexNode* cpList;
CreateComplexList(cpList);
PrintComplexList(cpList);
ComplexNode* copyList = CopyComplexList(cpList);
PrintComplexList(copyList);
}