数据结构之单链表(参考并整理严蔚蓝数据结构)

#include<iostream>
using namespace std;
typedef int ElemType;
typedef struct node
{
	ElemType data;
	struct node *pNext;
}Node, *pNode;
void InitList(pNode &pHead)
{
	pHead = new Node;
	pHead->pNext = NULL;
	return;
}
void CreateAList(pNode &pHead, int count)
{
	pNode pTail = pHead;
	for (int i = 1; i <= count; i++)
	{
		pNode pNew = new Node;
		cin >> pNew->data;
		pNew->pNext = NULL;
		pTail->pNext = pNew;
		pTail = pNew;
		pNew = NULL;
	}
	return;
}
void CreateDList(pNode &pHead, int count)
{
	for (int i = 1; i <= count; i++)
	{
		pNode pNew = new Node;
		cin >> pNew->data;
		pNew->pNext = pHead->pNext;
		pHead->pNext = pNew;
	}
	return;
}
void DestroyList(pNode &pHead)//包括头节点也被删除，即达到pHead==NULL
{
	pNode pTem = NULL;
	while (pHead)
	{
		pTem = pHead;
		pHead = pHead->pNext;
		delete pTem;
	}
	return;
}
void ClearList(pNode &pHead)//只剩头节点
{
	pNode pTem = NULL;
	while (pHead->pNext)
	{
		pTem = pHead->pNext;
		pHead->pNext = pHead->pNext->pNext;
		delete pTem;
	}
	return;
}
pNode Locate(pNode pHead, ElemType e)//返回元素在链表中的指针
{
	pNode pTem = pHead->pNext;
	while (pTem&&pTem->data != e)
		pTem = pTem->pNext;
	return pTem;
}
bool GetElem(pNode pHead, int pos, ElemType &e)
{
	pNode pTem = pHead->pNext; int i = 1;
	while (pTem&&i<pos)
	{
		pTem = pTem->pNext; i++;
	}
	if (!pTem || i > pos)
		return false;
	else
	{
		e = pTem->data;
		return true;
	}
}
pNode PriorElem(pNode pHead, pNode pCur)//返回当前元素的上一个元素的针
{//未解决第一个元素的前驱的元素问题
	pNode pTem = pHead;
	if (pHead->pNext == pCur)//检测第一个结点
		return NULL;
	while (pTem->pNext&&pTem->pNext != pCur)
		pTem = pTem->pNext;
	if (pTem->pNext == pCur)
		return  pTem;
	else
		return NULL;

}
pNode NextElem(pNode pHead, pNode pCur)
{//未解决最后一个元素的后继问题
	pNode pTem = pHead->pNext;
	while (pTem&&pTem != pCur)
		pTem = pTem->pNext;
	if (pTem) pTem = pTem->pNext;
	return pTem;
}
bool ListInsert(pNode &pHead, int pos, ElemType e)
{
	pNode pTem = pHead; int i = 0;
	while (pTem&&i < pos - 1)
	{
		pTem = pTem->pNext; i++;
	}
	if (!pTem&&i > pos - 1)
		return false;
	else
	{
		pNode pNew = new Node;
		pNew->data = e;
		pNew->pNext = pTem->pNext;
		pTem->pNext = pNew;
		pTem = pNew = NULL;
		return true;
	}
}
bool ListDelete(pNode &pHead, int pos, ElemType &e)
{
	pNode pTem = pHead; int i = 0;
	while (pTem->pNext&&i < pos - 1)
	{
		pTem = pTem->pNext; i++;
	}
	if (!(pTem->pNext) && i > pos - 1)
		return false;
	else
	{
		pNode p = pTem->pNext;
		e = p->data;
		pTem->pNext = p->pNext;
		delete p;
		p = NULL;
		return true;
	}
}
void DeleteBetween(pNode &pHead, int min, int max)//delete bewteen min and max
{//有序递增链表
	pNode pRe = pHead;
	pNode pTem = pHead->pNext;
	pNode pStar = NULL;//开始要删除元素的针
	pNode pCur = NULL;//当前待删元素的针
	while (pTem&&pTem->data <min)
	{
		pRe = pTem; pTem = pTem->pNext;
	}
	if (pTem)//pRe固定
	{
		while (pTem&&pTem->data <= max)
			pTem = pTem->pNext;//pTem为最后要删除元素的指针域存放的指针值
		pStar = pRe->pNext;
		pRe->pNext = pTem;//将剩余元素链接起来
		while (pStar != pTem)
		{
			pCur = pStar; pStar = pStar->pNext; delete pCur;
		}
	}
	return;

}
void DeleteEqual(pNode &pHead)//元素递增排列
{
	pNode p = pHead->pNext;//
	pNode q = p->pNext;
	while (q)
	{
		if (p->data != q->data)
		{
			p = q; q = q->pNext;
		}
		else
		{
			q = q->pNext;
			delete p->pNext;
			p->pNext = q;
		}
	}
	return;
}
int ListLength(pNode pHead)
{
	int len = 0; pNode pTem = pHead->pNext;
	while (pTem)
	{
		pTem = pTem->pNext; ++len;
	}
	return len;
}
void ListConcat(pNode pHeadA, pNode pHeadB, pNode &pHeadC)
{
	pNode pTem = pHeadA;
	pHeadC = pHeadA;
	while (pTem->pNext)
		pTem = pTem->pNext;
	pTem->pNext = pHeadB->pNext;
	return;
}
void ListUnion(pNode &pHeadA, pNode pHeadB)//将所有在线性表B中但不再A中的数据元素插入到A中
{
	int lena=ListLength(pHeadA);//A的长度
	int lenb=ListLength(pHeadB);//B的长度
	ElemType e;
	for (int i = 1; i <= lenb; i++)
	{
		GetElem(pHeadB, i, e);//取B中第i个数据元素赋值给e
		if (!Locate(pHeadA, e))//如果e在A中不存在
			ListInsert(pHeadA, ++lena, e);//插入A的尾部
	}
}
void ListMerge(pNode pHeadA, pNode pHeadB, pNode &pHeadC)
{//归并两个值非递减的单链表为一个值非递减的新表
	int Lena = ListLength(pHeadA);
	int Lenb = ListLength(pHeadB);
	ElemType a,b;
	int i = 1, j = 1, k = 0;
	InitList(pHeadC);
	while ((i <= Lena) && j <= Lenb)
	{
		GetElem(pHeadA, i, a);
		GetElem(pHeadB, j, b);
		if (a <= b)
		{
			ListInsert(pHeadC, ++k, a);
			++i;
		}
		else
		{
			ListInsert(pHeadC, ++k, b);
			j++;
		}
	}
	while (i <= Lena)//如果i<=Lena,则B已经插入完毕
	{
		GetElem(pHeadA, i++, a);
		ListInsert(pHeadC, ++k, a);
	}
	while (j <= Lenb)//如果j<=Lenb,则A已经插入完毕
	{
		GetElem(pHeadB, j++, b);
		ListInsert(pHeadC, ++k, b);
	}
	return;
}
void MergeList(pNode &pHeadA, pNode &pHeadB, pNode &pHeadC)//同上
{//原先的A,B皆被破坏
	pNode pA, pB, pC;
	pHeadC = pHeadA;
	pA = pHeadA->pNext;
	pB = pHeadB->pNext;
	pC = pHeadA;
	while (pA&&pB)
	{
		if (pA->data <= pB->data)
		{
			pC->pNext = pA; pC = pA; pA = pA->pNext;
		}
		else
		{
			pC->pNext = pB; pC = pB; pB = pB->pNext;
		}
	}
	if (pA)
		pC->pNext = pA;
	else
		pC->pNext = pB;
	delete(pHeadB);
	return;
}
void ListCrossMerge(pNode &pHeadA, pNode &pHeadB, pNode &pHeadC)//在A，B的基础上形成C.A,B中的元素间隔排列.A,B不再存在
{
	pNode pA = pHeadA->pNext;
	pNode pB = pHeadB->pNext;
	pHeadC = pHeadA;
	pNode pTemA = NULL, pTemB = NULL;
	while (pA&&pB)
	{
		pTemA = pA->pNext; pA->pNext = pB;//将B元素插入
		if (pTemA)
		{
			pTemB = pB->pNext; pB->pNext = pTemA;//将A元素插入
		}
		pA = pTemA; pB = pTemB;
	}
	return;
}
void ReverseMerge(pNode &pHeadA, pNode &pHeadB, pNode &pHeadC) // 把元素递增排列的链表A和B合并为C,
//且C中元素递减排列, 使用原空间
{
	pNode pA = pHeadA->pNext;
	pNode pB = pHeadB->pNext;
	pNode pC = NULL;
	pNode pRe = NULL;
	pNode pTem = NULL;
	while (pA&&pB)
	{
		if (pA->data < pB->data || !pB)
		{
			pC = pA; pTem = pA->pNext; pA->pNext = pRe; pA = pTem;
		}
		else
		{
			pC = pB; pTem = pB->pNext; pB->pNext = pRe; pB = pTem;
		}
		pRe = pC;
	}
	pHeadC = pHeadA; pHeadA->pNext = pC;
	return;
}
void ListTraverse(pNode pHead)
{
	pNode pTem = pHead->pNext;
	while (pTem)
	{
		cout << pTem->data << " ";
		pTem = pTem->pNext;
	}
	cout << endl;
	return;
}
int main(void)
{

	pNode pHeadA,pHeadB,pHeadC;
	InitList(pHeadA);
	InitList(pHeadB);
	CreateAList(pHeadA, 4);
	CreateAList(pHeadB, 5);
	ListTraverse(pHeadA);
	ListTraverse(pHeadB);
	MergeList(pHeadA, pHeadB, pHeadC);
	ListTraverse(pHeadA);
	ListTraverse(pHeadC);
/*
    ListMerge(pHeadA, pHeadB, pHeadC);
	ListTraverse(pHeadA);
	ListTraverse(pHeadB);
	ListTraverse(pHeadC);
*/
/*
	ListUnion(pHeadA, pHeadB);
	ListTraverse(pHeadA);
*/
	/*	pNode pTem = Locate(pHead, 3);
	pTem = NextElem(pHead, pTem);
	cout << pTem->data << endl;
	*/
/*	pNode pTem = Locate(pHead, 2);
	pTem = PriorElem(pHead, pTem);
	cout << pTem->data << endl;	
*/
	/*
	ClearList(pHead);
	if (!pHead->pNext)
	cout << "Indeed Clear!" << endl;
	else
	cout << "Not Clear!" << endl;
	*/
	/*
	DestroyList(pHead);
	if (pHead)
	cout << "Not Destroy!" << endl;
	else
	cout << "Indeed Destroy!" << endl;
	*/
	/*
	pNode pHeadA = NULL;
	pNode pHeadB = NULL;
	pNode pHeadC = NULL;
	InitList(pHeadA);
	InitList(pHeadB);
	CreateAList(pHeadA,3);
	CreateAList(pHeadB,3);
	ListCrossMerge(pHeadA, pHeadB, pHeadC);
	ListTraverse(pHeadC);
	*/
	/*
	pNode pHeadA = NULL, pHeadB = NULL, pHeadC = NULL;
	InitList(pHeadA);
	InitList(pHeadB);
	CreateAList(pHeadA,4);
	CreateAList(pHeadB,5);
	ListTraverse(pHeadA);
	ListTraverse(pHeadB);
	ListConcat(pHeadA, pHeadB, pHeadC);
	ListTraverse(pHeadC);
	*/

	/*	pNode pHead = NULL;
	ElemType e = 0;
	InitList(pHead);
	CreateAList(pHead, 6);//CreateDList(pHead,6);
	ListTraverse(pHead);
	DeleteEqual(pHead);
	ListTraverse(pHead);
	*//*
	DeleteBetween(pHead, 2, 5);
	ListTraverse(pHead);
	*/
	/*
	cout << "The Length of The List is " << ListLength(pHead) << endl;
	ListTraverse(pHead);
	GetElem(pHead, 2, e);
	cout << e << endl;
	ListInsert(pHead, 7, 7);
	cout << "The Length of The List is " << ListLength(pHead) << endl;
	ListTraverse(pHead);
	ListDelete(pHead, 7, e);
	cout << e << endl;
	cout << "The Length of The List is " << ListLength(pHead) << endl;
	ListTraverse(pHead);
	*/
	return(0);

}