链表-题

#pragma once
#include <assert.h>
#include <malloc.h>
typedef int DataType;
typedef struct SListNode
{
	DataType data;
	struct SListNode* next;
}SListNode;

void PushBack(SListNode* & pHead, DataType x);
void PopBack(SListNode* & pHead);
void PushFront(SListNode* & pHead, DataType x);
void PopFront(SListNode* & pHead);
SListNode* Find(SListNode* pHead, DataType x);
void Insert(SListNode* pos, DataType x);
void Erase(SListNode* pos);
void DestoryList(SListNode*& pHead);

void DestoryList(SListNode*& pHead)
{
	SListNode* cur=pHead;
	while(cur)
	{
		SListNode* tmp=cur;
		cur=cur->next;
		free(tmp);
	}
	pHead=NULL;
}
SListNode* _BuyNode(DataType x)
{
	SListNode* tmp=(SListNode*)malloc(sizeof(SListNode));
	tmp->data=x;
	tmp->next=NULL;
	return tmp;
}
void PrintSlist(SListNode* pHead)
{
	SListNode* cur=pHead;
	while(cur)
	{
		printf("%d->",cur->data);
		cur=cur->next;
	}
	printf("NULL\n");
}

void PushBack(SListNode* &pHead,DataType x)
{
	//两种情况，1.空；2.不为空
	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)
{
	//1.空；2.一个结点；3.多个结点；
	if(pHead==NULL)
	{
		return;
	}
	else if(pHead->next==NULL)
	{
		free(pHead);
		pHead=NULL;
	}
	else
	{
		SListNode* tail=pHead;
		SListNode* prev=NULL;
		while(tail->next)
		{
			prev=tail;
			tail=tail->next;
		}
		free(tail);
		prev->next=NULL;
	}
}
void PushFront(SListNode* &pHead,DataType x)
{
	//1.空2.不空
	if(pHead==NULL)
	{
		pHead=_BuyNode(x);
	}
	else
	{
		SListNode* tmp=_BuyNode(x);
		tmp->next=pHead;
		pHead=tmp;
	}
}
void PopFront(SListNode* &pHead)
{
	//1.空；2.一个结点；3.多个结点；
	if(pHead==NULL)
	{
		return;
	}
	else if(pHead->next==NULL)
	{
		free(pHead);
		pHead=NULL;
	}
	else
	{
		SListNode* tmp=pHead;
		pHead=pHead->next;
		free(tmp);
	}
}
SListNode* Find(SListNode* pHead,DataType x)
{
	SListNode* cur=pHead;
	while(cur)
	{
		if(cur->data==x)
		{
			return cur;
		}
		cur=cur->next;
	}
	return NULL;
}
void Insert(SListNode* pos,DataType x)
{
	assert(pos);
	SListNode* tmp=_BuyNode(x);
	tmp->next=pos->next;
	pos->next=tmp;
}
void Erase(SListNode* &pHead,SListNode* pos)
{
	assert(pos);
	assert(pHead);
	if(pHead==pos)
	{
		pHead=pHead->next;
		free(pos);
		return;
	}
	SListNode* prev=pHead;
	while(prev)
	{
		if(prev->next==pos)
		{
			prev->next=pos->next;
			free(pos);
			break;
		}
		prev=prev->next;
	}
}

//求一个单链表中结点个数
int size(SListNode* &pHead)
{
	int count=0;
	if(pHead==NULL)
	{
		return 0;
	}
	else
	{
		SListNode *cur=pHead;
		while(cur)
		{
			count++;
			cur=cur->next;
		}
		return count;
	}
}
//删除一个无头单链表的非尾结点
void DelNonTailNode(SListNode* pos)
{
	assert(pos);
	assert(pos->next);
	SListNode* del=pos->next;
	SListNode* next=del->next;
	pos->data=del->data;
	pos->next=next;
	free(del);
}
//在无头单链表的一个非头结点前插入一个结点
void InsertFrontNode(SListNode* pos,DataType x)
{
	assert(pos);
	SListNode* tmp=_BuyNode(pos->data);
	tmp->next=pos->next;
	pos->next=tmp;
	pos->data=x;
}
//逆置单链表
SListNode* Reserve(SListNode* pHead)
{
	SListNode* cur=pHead;
	SListNode* newHead=NULL;
	while(cur)
	{
		SListNode* tmp=cur;
		cur=cur->next;
		tmp->next=newHead;
		newHead=tmp;
	}
	return newHead;
}
//单链表排序
void BubbleSort(SListNode* pHead)
{
	assert(pHead);
	SListNode* begin=pHead;
	SListNode* end=NULL;
	while(pHead->next!=end)
	{
		while(begin->next!=end)
		{
			if(begin->data<begin->next->data)
			{
				int tmp=begin->data;
				begin->data=begin->next->data;
				begin->next->data=tmp;
			}
			begin=begin->next;
		}
		end=begin;
		begin=pHead;
	}
}
void SelectSort(SListNode* pHead)
{
	assert(pHead);
	SListNode* begin=pHead;
	SListNode* end=pHead;
	while(begin->next!=NULL)
	{
		SListNode* tmp=begin;
		end=begin->next;
		while(end)
		{
			if(tmp->data>end->data)
			{
				tmp=end;
			}
			end=end->next;
		}
		if(tmp!=begin)
		{
			int x=tmp->data;
			tmp->data=begin->data;
			begin->data=x;
		}
		begin=begin->next;
	}
}
//合并两个有序链表，合并后仍然有序
SListNode* MergeList(SListNode* p1,SListNode* p2)
{
	SListNode* newHead=NULL;//新链表的头结点
	SListNode* end=newHead;//新链表的当前结点
	if(!p1)
	{
		return p2;
	}
	if(!p2)
	{
		return p1;
	}
	if(p1->data<p2->data)
	{
		newHead=p1;
		p1=p1->next;
	}
	else
	{
		newHead=p2;
		p2=p2->next;
	}
	end=newHead;
	while(p1&&p2)
	{
		if(p1->data>p2->data)
		{
			end->next=p2;
			end=p2;
			p2=p2->next;
		}
		else
		{
			end->next=p1;
			end=p1;
			p1=p1->next;
		}
	}
	if(!p1)
	{
		end->next=p2;
	}
	if(!p2)
	{
		end->next=p1;
	}
	return newHead;
}
//查找单链表的中间结点，要求只能遍历一次链表
SListNode* FindMidNode(SListNode* pHead)
{
	SListNode* fast=pHead;
	SListNode* slow=pHead;
	while(fast&&fast->next)
	{
		slow=slow->next;
		fast=fast->next->next;
	}
	return slow;
}
//查找单链表的倒数第k个结点
SListNode* FindKNode(SListNode* pHead,int k)
{
	SListNode* fast=pHead;
	SListNode* slow=pHead;
	while(fast && k--)
	{
		fast=fast->next;
	}
	if(k>0)
	{
		return NULL;
	}
	while(fast)
	{
		slow=slow->next;
		fast=fast->next;
	}
	return slow;
}
SListNode* JosephCycle(SListNode* pHead,int m)
{
	SListNode* cur=pHead;
	if(cur==NULL)
	{
		return NULL;
	}
	while(1)
	{
		//只剩一个结点
		if(cur==cur->next)
		{
			return cur;
		}
		int x=m;
		while(--x)
		{
			cur=cur->next;
		}
		SListNode* del=cur->next;
		cur->data=del->data;
		cur->next=del->next;
		free(del);
	}
}
//判断单链表是否带环
int IsCycle(SListNode* pHead)
{
	assert(pHead);
	SListNode *fast=pHead;
	SListNode *slow=pHead;
	while(fast&&fast->next)
	{
		fast=fast->next->next;
		slow=slow->next;
		if(fast==slow)
		{
			return 1;
		}
	}
	return 0;
}
//找带环单链表的环入口
SListNode* FindEntry(SListNode* pHead)
{
	assert(pHead);
	SListNode* fast=pHead;
	SListNode* slow=pHead;
	while(fast&&fast->next)
	{
		fast=fast->next;
		slow=slow->next;
		if(fast==slow)
		{
			break;
		}
	}
	fast=pHead;
	while(fast!=slow)
	{
		fast=fast->next;
		slow=slow->next;
	}
	return fast;
}
//求带环单链表的环长
int LengthCycle(SListNode* pHead)
{
	assert(pHead);
	SListNode* fast=pHead;
	SListNode* slow=pHead;
	while(fast&&fast->next)
	{
		fast=fast->next->next;
		slow=slow->next;
		if(fast==slow)
		{
			break;
		}
	}
	int count=0;
	do
	{
		slow=slow->next;
		count++;
	}while(fast!=slow);
	return count;
}