无头节点无环单链表的基本操

LinkList.h

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include <stddef.h>
#include<stdlib.h>
typedef char LinkType;

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

/**
* @brief 初始化链表
*
* @param head
*/
void LinkListInit(LinkNode** head);

/**
* @brief 尾插一个元素到链表中
*
* @param head
* @param value
*/
LinkNode* LinkListPushBack(LinkNode** head, LinkType value);

/**
* @brief 尾删一个元素
*
* @param head
*/
void LinkListPopBack(LinkNode** head);

/**
* @brief 头插一个元素
*
* @param head
* @param value
*/
void LinkListPushFront(LinkNode** head, LinkType value);

/**
* @brief 头删一个元素
*
* @param head
*/
void LinkListPopFront(LinkNode** head);

/**
* @brief 查找元素在链表中的位置
*
* @param head
* @param to_find 要查找的值
*
* @return 这个值对应的节点的地址
*/
LinkNode* LinkListFind(LinkNode* head, LinkType to_find);

/**
* @brief 在pos之前插入元素
*
* @param head
* @param pos
* @param value
*/
void LinkListInsert(LinkNode** head, LinkNode* pos, LinkType value);

/**
* @brief 在pos之后插入元素
*
* @param head
* @param pos
* @param value
*/
void LinkListInsertAfter(LinkNode** head, LinkNode* pos, LinkType value);

/**
* @brief 删除指定位置的元素
*/
void LinkListErase(LinkNode** head, LinkNode* pos);

void LinkListErase2(LinkNode** head, LinkNode** pos);

/**
* @brief 删除指定值的元素
*
* @param head
* @param to_delete
*/
void LinkListRemove(LinkNode** head, LinkType to_delete);

/**
* @brief 指定值的所有元素都删掉.
*
* @param head
* @param value
*/
void LinkListRemoveAll(LinkNode** head, LinkType value);

/**
* @brief 判定链表为空
*
* @return 链表为空, 返回1, 否则返回0
*/
int LinkListEmpty(LinkNode* head);

/**
* @brief 求链表的元素个数
*
* @param head
*
* @return
*/
size_t LinkListSize(LinkNode* head);

/**
* @brief 逆序打印单链表.
*
* @param head
*/
void LinkListReversePrint(LinkNode* head);

/**
* @brief 不允许遍历链表, 在 pos之前插入
*
* @param head
* @param pos
* @param value
*/
void LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value);

LinkNode* JosephCycle(LinkNode* head, size_t food);






//

/**
* @brief 单链表逆置
*
* @param head
*/
void LinkListReverse(LinkNode** head);
void LinkListReverse2(LinkNode** head);

/**
* @brief 单链表的冒泡排序
*
* @param head
*/
void LinkListBubbleSort(LinkNode* head);

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

LinkNode* FindMidNode(LinkNode* head);

/**
* @brief 找到倒数第 K 个节点.
*
* @param head
*
* @return
*/
LinkNode* FindLastKNode(LinkNode* head, size_t K);

/**
* @brief 删除倒数第K个节点
*
* @param head
* @param K
*/
void EraseLastKNode(LinkNode** head, size_t K);

/**
* @brief 判定单链表是否带环. 如果带环返回1
*
* @param head
*
* @return
*/
int HasCycle(LinkNode* head);

/**
* @brief 如果链表带环, 求出环的长度
*
* @param head
*
* @return
*/
size_t GetCycleLen(LinkNode* head);

/**
* @brief 如果链表带环, 求出环的入口
*
* @param head
*
* @return
*/
LinkNode* GetCycleEntry(LinkNode* head);

/**
* @brief 判定两个链表是否相交, 并求出交点
*
* @param head1
* @param head2
*
* @return
*/
LinkNode* HasCross(LinkNode* head1, LinkNode* head2);

///第三次作业
/**
* @brief 判定两个链表是否相交. 但是链表可能带环
*
* @param head1
* @param head2
*
* @return 如果相交, 返回1, 否则返回0
*/
int HasCrossWithCycle(LinkNode* head1, LinkNode* head2);

/**
* @brief 求两个有序链表的交集
*
* @param head1
* @param head2
*
* @return 返回表示交集的新链表
*/
LinkNode* UnionSet(LinkNode* head1, LinkNode* head2);

typedef struct ComplexNode {
	LinkType data;
	struct ComplexNode* next;
	struct ComplexNode* random;
} ComplexNode;

/**
* @brief 拷贝复杂链表
*偏移量
* @param head
*
* @return
*/
ComplexNode* CopyComplex(ComplexNode* head);
ComplexNode* CopyComplex2(ComplexNode* head);

LinkList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Linklist.h"
#include<stdio.h>

#define PrintHeader printf("\n=================%s=================\n",__FUNCTION__)
void LinkListInit(LinkNode** head)
{
	if (head == NULL){
		return;
	}
	*head = NULL;
}
void Linklistprint(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("NULL\n");
}
LinkNode* LinkCreateNode(LinkType value)
{
	LinkNode* ptr = (LinkNode*)malloc(sizeof(LinkNode));
	ptr->data = value;
	ptr->next = NULL;
	return;
}
void LinklistFree(LinkNode* ptr)
{
	free(ptr);
}
LinkNode* LinkListPushBack(LinkNode** head, LinkType value)
{
	if (head == NULL){
		return NULL;
	}
	if (*head == NULL)
	{
		*head = LinkCreateNode(value);
		return *head;
	}
	LinkNode* cur = *head;
	while (cur->next != NULL){
		cur = cur->next;
	}
	cur->next = LinkCreateNode(value);
	return cur->next;

}
void LinkListPopBack(LinkNode** head)
{
	if (head == NULL){
		return;
	}
	if (*head == NULL){
		return;
	}
	LinkNode* cur = *head;
	if (cur->next == NULL){
		LinklistFree(cur);
		cur = NULL;
		return;

	}
	while (cur->next != NULL){
		if (cur->next->next == NULL){
			LinkNode* to_delete = cur->next;
			cur->next = NULL;
			LinklistFree(to_delete);
		}
		else{
			cur = cur->next;
		}
	}
	
}
void LinkListPushFront(LinkNode** head, LinkType value)
{
	if (head == NULL){
		return;
	}
	if (*head == NULL){
		*head = LinkCreateNode(value);
		return;
	}
	LinkNode* cur = LinkCreateNode(value);
	cur->next = *head;
	*head = cur;
	return;
}
void LinkListPopFront(LinkNode** head)
{
	if (head == NULL){
		return;
	}
	if (*head == NULL){
		return;
	}
	LinkNode* cur = *head;
	*head = (*head)->next;
	LinklistFree(cur);
	return;

}
LinkNode* LinkListFind(LinkNode* head, LinkType to_find)
{
	if (head == NULL){
		return NULL;
	}
	LinkNode* cur = head;
	if (cur->data== NULL){
		return NULL;
	}
	while (cur)
	{
		if (cur->data == to_find){
			return cur;
		}
		else{
			cur= cur->next;
		}
	}
	return NULL;
}
void LinkListInsert(LinkNode** head, LinkNode* pos, LinkType value)//之前
{
	if (head == NULL){
		return;
	}
	if (*head == NULL){
		LinkListPushFront(head, value);
		return;
	}
	if (*head == pos){
		*head = LinkCreateNode(value);
		return;
	}
	if (pos == NULL){
		LinkListPushBack(head, value);
		return;
	}
	LinkNode* cur = *head;
	while (cur->next != NULL){
		if (cur->next == pos){
			LinkNode* NewNode = LinkCreateNode(value);
			NewNode->next = pos;
			cur->next = NewNode;
			return;
		}
		else{
			cur = cur->next;
		}
	}
}
void LinkListInsertAfter(LinkNode** head, LinkNode* pos, LinkType value)
{
	if (head == NULL){
		return;
	}
	if (*head == NULL){
		LinkListPushFront(head, value);
		return;
	}
	if (pos == NULL){
		return;
	}
	if (*head == pos){
		LinkNode* cur = LinkCreateNode(value);
		cur->next = NULL;
		(*head)->next = cur;
		return;
	}
	LinkNode* cur = *head;	
	while (cur->next != NULL){
		if (cur->next== pos){
			LinkNode* NewNode = LinkCreateNode(value);
			LinkNode* next = cur->next->next;
			cur->next->next = NewNode;
			NewNode->next = next;			
			return;
		}
		else{
			cur = cur->next;
		}
	}
	return;
}
void LinkListErase(LinkNode** head, LinkNode* pos)
{
	if (head == NULL || pos == NULL){
		return;
	}
	if (*head == NULL){
		return;
	}
	if (*head == pos){
		*head = (*head)->next;
		LinklistFree(pos);
		return;
	}
	LinkNode* cur = *head;
	while (cur->next != NULL){
		if (cur->next == pos){
			cur->next = pos->next;
			LinklistFree(pos);
			return;
		}
		else{
			cur=cur->next;
		}
	}
	return;
}
void LinkListRemove(LinkNode** head, LinkType to_delete)
{
	if (head == NULL){
		return;
	}
	
	LinkNode* Node = LinkListFind(*head,to_delete);
	LinkListErase(head,Node);
}
void LinkListRemoveAll(LinkNode** head, LinkType value)
{
	if (head == NULL){
		return;
	}
	if (*head == NULL){
		return;
	}
	LinkNode* Node = LinkListFind(*head, value);
	while (Node){
		LinkListErase(head, Node);
		Node = LinkListFind(*head, value);
	}
	return;
}
int LinkListEmpty(LinkNode* head)
{
	return head == NULL ? 1 : 0;
}
size_t LinkListSize(LinkNode* head)
{
	size_t count = 0;
	LinkNode* cur = head;
	while (cur){
		count++;
		cur = cur->next;
	}
	return count;
}
void LinkListReversePrint(LinkNode* head)
{
	if (head == NULL){
		return;
	}
	LinkListReversePrint(head->next);
	printf("[%c|%p]->", head->data, head);
}
void LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value)
{
	if (head == NULL || pos == NULL){
		return;
	}
	if (*head == NULL){
		return;
	}
	LinkNode* NewNode = LinkCreateNode(pos->data);
	pos->data = value;
	NewNode->next = pos->next;
	pos->next = NewNode;
	return;
}
LinkNode* JosephCycle(LinkNode* head, size_t food)
{
	if (head == NULL){
		return NULL;
	}
	if (food == 0){
		return NULL;
	}
	LinkNode* cur = head;
	while (cur != cur->next){
		size_t i = 0;
		for (; i < food - 1; i++){
			cur = cur->next;
		}
		printf("%c\n", cur->data);
		cur->data = cur->next->data;
		LinkNode* to_delete = cur->next;
		cur->next = to_delete->next;
		LinklistFree(to_delete);
	}
	return cur;
}
void LinkListReverse(LinkNode** head)
{
	if (head == NULL){
		return;
	}
	if (*head == NULL || (*head)->next == NULL){
		return;
	}
	LinkNode* p1 = *head;
	LinkNode* p2 = (*head)->next;
	while (p1->next){
		LinkListPushFront(head, p2->data);
		p1->next = p2->next;
		LinklistFree(p2);
		p2 = p1->next;
	}
}
void LinkListReverse2(LinkNode** head)
{
	if (head == NULL){
		return;
	}
	if (*head == NULL||(*head)->next==NULL){
		return;
	}
	LinkNode* cur = *head;
	while (cur->next){
		LinkNode* to_delete = cur->next;
		cur->next = to_delete->next;
		to_delete->next = *head;
		*head = to_delete;
	}
}
void LinkListswap(LinkType* x, LinkType* y)
{
	LinkType tmp = *x;
	*x = *y;
	*y = tmp;
}
void LinkListBubbleSort(LinkNode* head)
{
	if (head == NULL||head->next==NULL){
		return;
	}
	size_t i =1;
	size_t j =1;
	size_t count = LinkListSize(head);
	for (i=1; i < count; i++){
		LinkNode* cur = head;
		for (j = 1; j <= count - i; j++){
			if ((cur->data)>(cur->next->data)){
				LinkListswap(&cur->data,&cur->next->data);//交换
			}
			cur = cur->next;
		}
	}
}
LinkNode* LinkListMerge(LinkNode* head1, LinkNode* head2)
{
	if (head1 == NULL){
		return head2;
	}
	if (head2 == NULL){
		return head1;
	}
	LinkNode* cur1 = head1;
	LinkNode* cur2 = head2;
	LinkNode* head = NULL;
	LinkNode* tail = NULL;
	while (cur1&&cur2){
		if (cur1->data < cur2->data){
			if (tail == NULL){
				head = tail = cur1;
			}
			else{
				tail->next = cur1;
				tail = tail->next;
			}
			cur1 = cur1->next;
		}else{
			if (tail == NULL){
				head = tail = cur2;
			}
			else{
				tail->next = cur2;
				tail = tail->next;
			}
			cur2 = cur2->next;
		}
	}
	if (cur1 != NULL){
		tail->next = cur1;
	}
	if (cur2 != NULL){
		tail->next = cur2;
	}
	return head;
}
LinkNode* FindMidNode(LinkNode* head)
{
	if (head == NULL){
		return -1;
	}
	if (head->next == NULL || head->next->next == NULL){
		return head;
	}
	LinkNode* fast = head;
	LinkNode* slow = head;
	while (fast->next != NULL){
		slow = slow->next;
		fast = fast->next->next;
	}
	return slow;

}
LinkNode* FindLastKNode(LinkNode* head, size_t K)//找到倒数第K个节点
{
	if (head == NULL){
		return -1;
	}
	if (K > LinkListSize(head)){
		return -1;
	}
	LinkNode* slow = head;
	LinkNode* fast = head;
	K = K - 1;
	while (K--){
		fast = fast->next;
	}
	while (fast->next != NULL){
		fast = fast->next;
		slow = slow->next;
	}
	return slow;
}
void EraseLastKNode(LinkNode** head, size_t K)
{
	if (head == NULL){
		return ;
	}
	if (*head == NULL){
		return;
	}
	size_t count = 0;
	LinkNode* cur = *head;
	while (cur){
		count++;
		cur = cur->next;
	}
	if (K == count){
		LinkListPopFront(head);
	}
	size_t i = 0;
	LinkNode* pre = *head;
	for (; i < count - K - 1; i++){
		pre = pre->next;
	}
	LinkNode* to_delete = pre->next;
	pre->next = to_delete->next;
	LinklistFree(to_delete);
}
int HasCycle(LinkNode* head)
{
	if (head == NULL||head->next==NULL){
		return -1;
	}
	LinkNode* slow = head;
	LinkNode* fast = head;
	while (fast->next != NULL){
		slow=slow->next;
		fast = fast->next->next;
		if (fast == slow){
			return 1;
		}
	}
	return -1;
}
size_t GetCycleLen(LinkNode* head)
{
	if (head == NULL || head->next == NULL){
		return 0;
	}
	LinkNode* slow = head;
	LinkNode* fast = head;
	while (fast->next != NULL){
		slow = slow->next;
		fast = fast->next->next;
		if (fast == slow){
			size_t i = 0;
			LinkNode* flag = slow->next;
			while (flag != slow){
				flag = flag->next;
				i++;
			}
			return i+1;

		}
	}
}
LinkNode* GetCycleEntry(LinkNode* head)
{
	if (head == NULL||head->next==NULL){
		return;
	}
	LinkNode* slow = head;
	LinkNode* fast = head;
	while (fast->next != NULL){
		slow = slow->next;
		fast = fast->next->next;
		if (fast == slow){
			LinkNode* flag = head;
			while (flag != slow){
				flag = flag->next;
				slow = slow->next;
			}
			return flag;
		}
	}
}
LinkNode* HasCross(LinkNode* head1, LinkNode* head2)
{
	if (head1 == NULL || head2 == NULL){
		return NULL;
	}
	LinkNode* cur1 = head1;
	LinkNode* cur2 = head2;
	size_t len1 = LinkListSize(head1);
	size_t len2 = LinkListSize(head2);
	size_t i = 0;
	if (len1 > len2){
		for (; i < len1 - len2; ++i){
			cur1 = cur1->next;
		}
	}else if (len2>len1){
		for (; i < len2 - len1; ++i){
			cur2 = cur2->next;
		}
	}
	while (cur1 != cur2){
		cur1 = cur1->next;
		cur2 = cur2->next;
	}
	return cur1;
}
int HasCrossWithCycle(LinkNode* head1, LinkNode* head2)
{
	if (head1 == NULL || head2 == NULL){
		return -1;
	}
	LinkNode* entry1 = GetCycleEntry(head1);
	LinkNode* entry2 = GetCycleEntry(head2);
	if (entry1 == NULL&&entry2 == NULL){
		return HasCross(head1, head2) != NULL ? 1 : 0;
	}
	//链表带环
	if (entry1 != NULL&&entry2 != NULL){
		if (entry1 == entry2){
			return 1;
		}
		else{
			//交点在环上
			LinkNode* cur = entry1->next;
			while (cur != entry1){
				if (cur == entry2){
					return 1;
				}
				cur = cur->next;
			}
			return 0;
		}
	}
	return 0;
}
LinkNode* UnionSet(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&&cur2){
		if (cur1->data > cur2->data){
			cur2 = cur2->next;
		}
		else if (cur1->data < cur2->data){
			cur1 = cur1->next;
		}
		else{
			LinkNode* new_node = LinkCreateNode(cur1->data);
			if (new_head==NULL){
				new_head = new_tail = new_node;
			}
			else
			{
				new_tail->next = new_node;
				new_tail = new_tail->next;
			}
			cur1 = cur1->next;
			cur2 = cur2->next;
		}
	}
	return new_head;
}
ComplexNode* createNode(LinkType value)
{
	ComplexNode* ptr = (ComplexNode*)malloc(sizeof(ComplexNode));
	ptr->data = value;
	ptr->next = NULL;
	ptr->random = NULL;
	return ptr;
}
size_t Diff(ComplexNode* head, ComplexNode* random)
{
	if (head == NULL || random == NULL){
		return (size_t)-1;
	}
	ComplexNode* cur = head;
	size_t count = 0;
	for (; cur != NULL; cur = cur->next){
		if (cur == random){
			break;
		}
		count++;
	}
	return count;
	if (cur == NULL){
		return (size_t)-1;
	}
}
ComplexNode* step(ComplexNode* pos, size_t offset)
{
	size_t i = 0;
	for (; i < offset; i++){
		if (pos == NULL){
			return NULL;
		}
		pos = pos->next;
	}
	return pos;
}
ComplexNode* CopyComplex(ComplexNode* head)
{
	if (head == NULL){
		return NULL;
	}
	//1.先把链表进行简单的复制
	ComplexNode* new_head = NULL;
	ComplexNode* new_tail = NULL;
	ComplexNode* cur = head;
	for (; cur != NULL; cur = cur->next){
		ComplexNode* new_node = createNode(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指针相对于头结点的偏移量
	ComplexNode* new_cur = new_head;
	for (cur = head; cur != NULL&&new_cur != NULL; cur = cur->next, new_cur = new_cur->next){
		if (cur->random == NULL){
			new_cur->random = NULL;
			continue;
		}
		size_t offset = Diff(head, cur->random);
		//3.根据偏移量，修改每个新链表节点的random指针
		new_cur->random = step(new_head, offset);
	}	
	return new_head;
}
ComplexNode* CopyComplex2(ComplexNode* head)
{
	//1.遍历旧链表，给每一个节点都创建一个对应的新节点，并且将这个新节点插入之后到旧节点
	ComplexNode* cur = head;
	for (; cur != NULL; cur = cur->next->next){
		ComplexNode* new_node = createNode(cur->data);
		new_node->next = cur->next;
		cur->next = new_node;
	}
	//2.再遍历链表，更新每个新节点的random指针 
	for (cur = head; cur != NULL; cur = cur->next){
		cur->next->random = cur->random->next;
	}
	//3.再遍历链表，把新节点依次拆下来，组装成一个新的链表
	ComplexNode* new_head = NULL;
	ComplexNode* new_tail = NULL;
	for (cur = head; cur != NULL; cur = cur->next){
		ComplexNode* to_delete = cur->next;
		cur->next = to_delete->next;
		if (new_head == NULL){
			new_head = new_tail = to_delete;
		}
		else{
			new_tail->next = to_delete;
			new_tail = new_tail->next;
		}
	}
	return new_head;
}
//测试代码//
void TestComplexCopy()
{
	PrintHeader;
	ComplexNode* a = createNode('a');
	ComplexNode* b = createNode('b');
	ComplexNode* c = createNode('c');
	ComplexNode* d = createNode('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 = CopyComplex(a);//ComplexNode* new_head = CopyComplex2(a);
	printf("new_head:%c\n", new_head->data);
}
void TestUnionSet()
{
	PrintHeader;
	LinkNode* head1;
	LinkListInit(&head1);
	LinkListPushBack(&head1, '2');
	LinkListPushBack(&head1, '4');
	LinkListPushBack(&head1, '6');
	LinkListPushBack(&head1, '8');
	LinkNode* head2;
	LinkListInit(&head2);
	LinkListPushBack(&head2, '2');
	LinkListPushBack(&head2, '4');
	LinkListPushBack(&head2, '7');
	LinkListPushBack(&head2, '9');
	LinkNode* ret = UnionSet(head1, head2);
	Linklistprint(ret, "相同的节点为");
}
void TestCrossWithCycle()
{
	PrintHeader;
	LinkNode* head1;
	LinkListInit(&head1);
	LinkListPushBack(&head1, 'b');
	LinkNode* pos1 = LinkListPushBack(&head1, 'c');
	LinkListPushBack(&head1, 'e');
	LinkListPushBack(&head1, 'd');
	LinkNode* pos2 = LinkListPushBack(&head1, 'h');
	pos2->next = pos1;
	LinkNode* head2;
	LinkListInit(&head2);
	LinkListPushBack(&head2, 'f');
	LinkNode* pos3 = LinkListPushBack(&head2, 'd');
	pos3->next = pos2;
	int ret = HasCrossWithCycle(head1, head2);
	printf("%d\n", ret);
}
void TestHasCross()
{
	PrintHeader;
	LinkNode* head1;
	LinkListInit(&head1);
	LinkListPushBack(&head1, 'a');
	LinkListPushBack(&head1, 'b');
	LinkNode* pos1=LinkListPushBack(&head1, 'c');
	LinkListPushBack(&head1, 'd');
	LinkListPushBack(&head1, 'e');
	LinkListPushBack(&head1, 'f');
	LinkNode* head2;
	LinkListInit(&head2);
	LinkListPushBack(&head2, 'x');
	LinkNode* pos2=LinkListPushBack(&head2, 'd');
	pos2->next=pos1;
	LinkNode* ret = HasCross(head1, head2);
	printf("%c\n", ret->data);

}
void TestCycleEntry()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, '2');
	LinkListPushBack(&head, '4');
	LinkNode*a = LinkListPushBack(&head, '6');
	LinkListPushBack(&head, '8');
	LinkNode*b = LinkListPushBack(&head, '5');
	b->next = a;
	LinkNode* ret = GetCycleEntry(head);
	printf("%c\n", ret->data);
}
void TestCycleLen()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, '2');
	LinkListPushBack(&head, '4');
	LinkNode*a = LinkListPushBack(&head, '6');
	LinkListPushBack(&head, '8');
	LinkNode*b = LinkListPushBack(&head, '5');
	b->next = a;
	size_t ret = GetCycleLen(head);
	printf("%u\n", ret);
}
void TestHasCycle()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, '2');
	LinkListPushBack(&head, '4');
	LinkNode*a=LinkListPushBack(&head, '6');
	LinkListPushBack(&head, '8');
	LinkNode*b = LinkListPushBack(&head, '5');
	b->next = a;
	int ret=HasCycle(head);
	printf("%d\n", ret);
}
void TestEraseLastKNode()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, '2');
	LinkListPushBack(&head, '4');
	LinkListPushBack(&head, '6');
	LinkListPushBack(&head, '8');
	LinkListPushBack(&head, '5');
	EraseLastKNode(&head, 2);
	Linklistprint(head, "删除倒是第二个节点");

}
void TestFindfastNode()
{

	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, '2');
	LinkListPushBack(&head, '4');
	LinkListPushBack(&head, '6');
	LinkListPushBack(&head, '8');
	LinkListPushBack(&head, '5');
	LinkNode* ret=FindLastKNode(head, 2);
	printf("期望值为8实际为%c\n", ret->data);
}
void TestFindMidNode()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, '2');
	LinkListPushBack(&head, '4');
	LinkListPushBack(&head, '6');
	LinkListPushBack(&head, '8');
	LinkListPushBack(&head, '5');
	LinkNode* ret = FindMidNode(head);
	printf("期望值为6实际为%c\n", ret->data);
}
void TestMerge()
{
	PrintHeader;
	LinkNode* head1;
	LinkListInit(&head1);
	LinkNode* head2;
	LinkListInit(&head2);
	LinkListPushBack(&head1, '2');
	LinkListPushBack(&head1, '4');
	LinkListPushBack(&head1, '6');
	LinkListPushBack(&head1, '8');
	LinkListPushBack(&head2, '5');
	LinkListPushBack(&head2, '9');
	LinkNode* ret=LinkListMerge(head1, head2);
	Linklistprint(ret, "排序合并两个有序链表");

}
void TestInit()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);	
	printf("head=%p,%ld\n",head,head);

}
void TestPushBack()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	Linklistprint(head, "尾插四个元素");
}
void TestLinkListPopBack()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	Linklistprint(head, "尾插四个元素");

	LinkListPopBack(&head);
	LinkListPopBack(&head);
	Linklistprint(head, "尾删两个元素");
}
void TestLinkListPushFront()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushFront(&head, 'a');
	LinkListPushFront(&head, 'b');
	LinkListPushFront(&head, 'c');
	LinkListPushFront(&head, 'd');
	Linklistprint(head, "头插四个元素");
}
void TestLinkListPopFront()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPopFront(&head);
	Linklistprint(head, "对空链表进行头删");

	LinkListPushFront(&head, 'a');
	LinkListPushFront(&head, 'b');
	LinkListPopFront(&head);
	Linklistprint(head, "对链表头删一次");
}

void TestLinkListFind()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkNode* ret = LinkListFind(head, 'X');
	printf("%p\n",ret);

	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkNode* ret2=LinkListFind(head, 'a');
	printf("%p\n",ret2);
	
}
void TestLinkListInsert()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListInsert(&head, head, 'X');
	Linklistprint(head, "在空链表插入X");


	LinkListPushBack(&head, 'a');
	LinkNode* ret=LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListInsert(&head, ret, 'X');
	Linklistprint(head, "在b前插入X");
}
void TestLinkListInsertAfter()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListInsertAfter(&head,head,'X');
	Linklistprint(head, "在head后插入X");

	LinkListPushBack(&head, 'a');
	LinkNode* ret = LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListInsertAfter(&head, ret, 'X');
	Linklistprint(head, "在b后插入X");
}
void TestLinkListErase()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListErase(&head, NULL);

	LinkListPushBack(&head, 'a');
	LinkNode* ret = LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListErase(&head, ret);
	Linklistprint(head, "删除b");
}
void TestLinkListRemove()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListRemove(&head, NULL);
	Linklistprint(head, "对空链表删除");

	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListRemove(&head, 'b');
	Linklistprint(head, "删除b");
}
void TestRemoveAll()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListRemoveAll(&head, NULL);
	Linklistprint(head, "对空链表删除");


	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListPushBack(&head, 'b');
	Linklistprint(head, "插入五个元素");
	LinkListRemoveAll(&head, 'b');
	Linklistprint(head, "删除b");
}
void TestEmpty()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	int ret = LinkListEmpty(head);
	printf("%d\n", ret);

	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	int ret1 = LinkListEmpty(head);
	printf("%d\n", ret1);
}
void TestListSize()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	int ret = LinkListSize(head);
	printf("%d\n", ret);

	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	int ret1 = LinkListSize(head);
	printf("%d\n", ret1);
}
void TestReaverse()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListReversePrint(head);

}
void TestInsertBefore()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkNode* ret = LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	Linklistprint(head, "尾插四个节点");
	LinkListInsertBefore(&head, ret, 'X');
	Linklistprint(head, "非遍历形式在c前插入X");

}
void TestJosephCycle()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListPushBack(&head, 'e');
	LinkListPushBack(&head, 'f');
	LinkListPushBack(&head, 'g');
	LinkNode* link = LinkListPushBack(&head, 'h');
	link->next = head;
	link= JosephCycle(head, 5);
	printf("%c\n", link->data);
}
void TestReversePrint()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'c');
	LinkListPushBack(&head, 'd');
	LinkListReverse2(&head);//LinkListReverse(&head);
	Linklistprint(head, "逆置单链表");
}
void TestBubbleSort()
{
	PrintHeader;
	LinkNode* head;
	LinkListInit(&head);
	LinkListPushBack(&head, 'd');
	LinkListPushBack(&head, 'b');
	LinkListPushBack(&head, 'a');
	LinkListPushBack(&head, 'c');
	LinkListBubbleSort(head);
	Linklistprint(head, "冒泡排序");
}
///main函数调用///

int main()
{
	TestInit();
	TestPushBack();
	TestLinkListPopBack();
	TestLinkListPushFront();
	TestLinkListPopFront();
	TestLinkListFind();
	TestLinkListInsert();
	TestLinkListInsertAfter();
	TestLinkListErase();
	TestLinkListRemove();
	TestRemoveAll();
	TestEmpty();
	TestListSize();
	TestReaverse();//逆序打印
	TestInsertBefore();
	TestJosephCycle();
	TestReversePrint();
	TestBubbleSort();
	TestMerge();
	TestFindMidNode();
	TestFindfastNode();
	TestEraseLastKNode();
	TestHasCycle();
	TestCycleLen();
	TestCycleEntry();
	TestHasCross();
	TestCrossWithCycle();
	TestUnionSet();
	TestComplexCopy();
	system("pause");
	return;
}

给节点pos('c'）开辟新的节点NewNode，把要插入的value放入pos,NewNode的下一个节点为pos的下一个节点，pos的下一个节点指向NewNode

此次传入的要吃掉的数为5（food），以5为例，从一开始一直遍历到5，就把5这个节点吃掉，方法为：把5的下一个节点赋给5，然后释放5的下一个节点，吃到最后只剩一个节点，即cur==cur->next，所以循环条件为cur！=cur->next