【数据结构】 链表的19种基本操作（完整版）

/*
=======================================================================================================
以下是关于线性表链接存储（单链表）操作的19种算法
By~fanxingzju			2014-04-03
1.初始化线性表，即置单链表的表头指针为空
2.创建线性表，此函数输入负数终止读取数据
3.打印链表，链表的遍历
4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表
5.返回单链表的长度
6.检查单链表是否为空，若为空则返回１，否则返回０
7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行
8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL
9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０
10.向单链表的表头插入一个元素
11.向单链表的末尾添加一个元素
12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０
13.向有序单链表中插入元素x结点，使得插入后仍然有序
14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行
15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行
16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行
17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0
18.交换2个元素的位置
19.将线性表进行快速排序
=========================================================================================================
*/
//基本操作参考了: http://www.cnblogs.com/lifuqing/archive/2011/08/20/List.html //链表的快速排序参考了: http://blog.csdn.net/pinkrobin/article/details/5456094 
#include <stdlib.h>
#include <stdio.h>

typedef int ElemType;

typedef struct Node
{
ElemType elem;
Node *next;
}Node;

//1.初始化线性表，即置单链表的表头指针为空
void InitList(Node **pNode)
{
*pNode = NULL;
printf("InitList函数执行，初始化成功\n");
}

//2.创建线性表，此函数输入负数终止读取数据
Node *CreastList(Node *pHead)
{
Node *p1;
Node *p2;
p1 = p2 = new Node;
if (NULL == p1 || NULL == p2)
{
printf("内存分配失败，程序终止\n");
system("pause");
exit(0);
}
//memset(p1,0,sizeof(Node));
scanf("%d",&p1->elem);
p1->next = NULL;
while (p1->elem > 0)
{
if (pHead == NULL)
{
pHead = p1;
}
else
{
p2->next = p1;
}
p2 = p1;
p1 = new Node;
if (NULL == p1 || NULL == p2)
{
printf("内存分配失败，程序终止\n");
system("pause");
exit(0);
}
//memset(p1,0,sizeof(Node));
scanf("%d",&p1->elem);
p1->next = NULL;
}
printf("CreatList函数执行，列表创建成功\n");
return pHead;
}

//3.打印链表，链表的遍历
void PrintList(Node *pHead)
{
if (NULL == pHead)
{
printf("PrintList函数执行，链表为空\n");
}
else
{
while (NULL != pHead)
{
printf("%d ",pHead->elem);
pHead = pHead->next;
}
printf("\n");
}
}

//4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表
void ClearList(Node *pHead)
{
Node *pNext;
if (NULL == pHead)
{
printf("ClearList函数执行，链表为空\n");
}
else
{
while (pHead->next != NULL)
{
pNext = pHead->next;
delete pHead;
pHead = pNext;
}
printf("ClearList函数执行，链表已经清除\n");
}
}

//5.返回单链表的长度
int SizeList(Node *pHead)
{
int size = 0;
while (pHead != NULL)
{
++size;
pHead = pHead->next;
}
printf("SizeList函数执行，链表长度 %d \n",size);
return size;
}

//6.检查单链表是否为空，若为空则返回１，否则返回０
int IsEmptyList(Node *pHead)
{
if (NULL == pHead)
{
printf("IsEmptyList函数执行，链表为空\n");
return 1;
}
else
{
printf("IsEmptyList函数执行，链表非空\n");
return 0;
}
}

//7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行
ElemType GetElement(Node *pHead, int pos)
{
int i = 0;
if (pos < 1)
{
printf("GetElement函数执行，pos值 %d 非法\n", pos);
return 0;
}
if (NULL == pHead)
{
printf("GetElement函数执行，链表为空\n");
return 0;
}

while(pHead != NULL)
{
++i;
if (i == pos)
{
break;
}
pHead = pHead->next;
}
if (i < pos)
{
printf("GetElement函数执行，pos值 %d 超出链表长度\n", pos);
return 0;
}

return pHead->elem;
}

// 8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL
ElemType *GetElemAddr(Node *pHead, ElemType x)
{
if (NULL == pHead)
{
printf("GetElemAddr函数执行，链表为空\n");
return NULL;
}
if (x < 0)
{
printf("GetElemAddr函数执行，给定值 %d 不合法\n", x);
return NULL;
}
while((pHead->elem != x)&&(NULL != pHead->next))
{
pHead = pHead->next;
}
if ((pHead->elem != x)&&(pHead != NULL))
{
printf("GetElemAddr函数执行，在链表中未找到 %d 的值\n", x);
return NULL;
}
if (pHead->elem == x)
{
printf("GetElemAddr函数执行，值为 %d 元素的地址为 0x%x\n", x, &(pHead->elem));
}
return &(pHead->elem);
}

//9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０
int ModifyElem(Node *pNode, int pos, ElemType x)
{
Node *pHead;
pHead = pNode;
int i = 0;

if (NULL == pHead)
{
printf("ModifyElem函数执行，链表为空\n");
}
if (pos < 1)
{
printf("ModifyElem函数执行，第 %d 个节点位置非法\n", pos);
}
while(NULL != pHead)
{
++i;
if (i == pos)
{
break;
}
pHead = pHead->next;
}
if (i < pos)
{
printf("ModifyElem函数执行，第 %d 个节点位置超出链表长度\n", pos);
return 0;
}
pNode = pHead;			//why
pNode->elem = x;
printf("ModifyElem函数执行，第 %d 个节点的值修改为 %d 成功\n", pos, x);
return 1;
}

//10.向单链表的表头插入一个元素
int InsertHeadList(Node **pNode, ElemType insertElem)
{
Node *pInsert;
pInsert = new Node;
//memset(pInsert,0,sizeof(Node));
pInsert->elem = insertElem;
pInsert->next = *pNode;
*pNode = pInsert;
printf("InsertHeadList函数执行，向表头插入元素成功\n");
return 1;
}

//11.向单链表的末尾添加一个元素
int InsertLastList(Node **pNode, ElemType insertElem)
{
Node *pInsert;
Node *pHead;
Node *pTemp;
pHead = *pNode;
pTemp = pHead;
pInsert = new Node;
//memset(pInsert,0,sizeof(Node));			//保证最后一个元素的next指向NULL
pInsert->elem = insertElem;
pInsert->next = NULL;

while(pHead->next != NULL)
{
pHead = pHead->next;
}
pHead->next = pInsert;
*pNode = pTemp;
printf("InsertLastList函数执行，向表尾插入元素成功\n");
return 1;
}

//12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０
int InsertPosList(Node **pNode, int pos, ElemType insertElem)
{
if (pos < 1)
{
printf("InsertPosElem函数执行，pos值 %d 非法\n", pos);
return 0;
}
Node *pInsert;
Node *pHead;
int i = 1;			//to be modified

pHead = *pNode;
pInsert = new Node;
pInsert->elem = insertElem;

while (pHead != NULL)
{
++i;
if (i == pos)
{
break;
}
pHead = pHead->next;
}
if (pos > i)
{
printf("InsertPosElem函数执行，pos值 %d 超出链表长度\n", pos);
return 0;
}
pInsert->next = pHead->next;
pHead->next = pInsert;
printf("InsertPosElem函数执行，向第 %d 个节点位置插入元素成功\n", pos);
return 1;
}

//13.向有序单链表中插入元素x结点，使得插入后仍然有序
void InsertOrder(Node **pNode, ElemType x)
{
Node *pFir = *pNode;
Node *pInsert = new Node;
pInsert->elem = x;
pInsert->next = NULL;
if (NULL == pFir)
{
*pNode = pInsert;
}
else
{
if (pFir->elem > x)
{
pInsert->next = pFir;
*pNode = pInsert;
}
else
{
Node *pSec;
while(NULL != pFir)
{
pSec = pFir->next;
if ((NULL == pSec)||(pSec->elem >= x))			// 短路，不能颠倒条件顺序
{
pFir->next = pInsert;
pInsert->next = pSec;
break;
}
pFir = pSec;
}
}
}
printf("InsertOrder函数执行，向有序链表插入成功\n");
}

//14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行
ElemType DeleteHeadList(Node **pNode)
{
if (NULL == *pNode)
{
printf("DeleteHeadList函数执行，链表为空，头结点删除失败\n");
system("pause");
exit(0);
}
Node *pTemp = *pNode;
ElemType elemvalue = pTemp->elem;
*pNode = pTemp->next;
delete pTemp;

printf("DeleteHeadList函数执行，头结点删除成功\n");
return elemvalue;
}

//15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行
ElemType DeleteLastList(Node **pNode)
{
Node *pHead;
Node *pTemp;
ElemType elemvalue;
pHead = *pNode;
if (NULL == pHead)
{
printf("DeleteHeadList函数执行，链表为空，表尾结点删除失败\n");
system("pause");
exit(0);
}
pTemp = pHead;
while(pHead->next != NULL)
{
pTemp = pHead;
pHead = pHead->next;
}

elemvalue = pTemp->elem;
pTemp->next = NULL;
delete pHead;
printf("DeleteLastList函数执行，表尾结点删除成功\n");

return elemvalue;
}

//16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行
ElemType DeletePosList(Node **pNode, int pos)
{
Node *pHead = *pNode;
ElemType elemvalue;
if (NULL == pHead)
{
printf("DeletePosList函数执行，链表为空，删除失败\n");
system("pause");
exit(0);
}
if (1 == pos)
{
elemvalue = pHead->elem;
*pNode = pHead->next;
delete pHead;
printf("DeletePosList函数执行，删除第 %d 个节点成功\n", pos);
return elemvalue;
}
Node *pTemp = pHead;
int i = 1;
while(pHead->next != NULL)
{
pTemp = pHead;
pHead = pHead->next;
++i;
if (i == pos)
{
break;
}
}
if (pos != i)
{
printf("DeletePosList函数执行，找不到第 %d 个节点位置，删除失败\n", pos);
system("pause");
exit(0);
}

elemvalue = pHead->elem;
pTemp->next = pHead->next;
delete pHead;

printf("DeletePosList函数执行，删除第 %d 个节点成功\n", pos);

return elemvalue;
}

//17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0
int DeleteValuexList(Node **pNode, ElemType x)
{
Node *pHead = *pNode;

if (NULL == pHead)
{
printf("DeleteValuexList函数执行，链表为空，删除失败\n");
return 0;
}

Node *pTemp = pHead;

while((NULL != pHead->next)&&(pHead->elem != x))
{
pTemp = pHead;
pHead = pHead->next;
}
if (pHead->elem != x)
{
printf("DeleteValuexList函数执行，未找到相应节点，删除失败\n");
return 0;
}

if (pTemp->elem != pHead->elem)
{
pTemp->next = pHead->next;
delete pHead;
}
else
{
//二者依然相等，说明第一个节点即为删除的目标位置
*pNode = pHead->next;
delete pHead;
}

printf("DeleteValuexList函数执行，链表中第一个值为 %d 的节点删除成功\n", x);
return 1;
}

//18.交换2个元素的位置
void SwapList(Node **pNode, ElemType elem1, ElemType elem2)
{
Node *pHead = *pNode;
Node *pTemp1 = NULL;
Node *pTemp2 = NULL;
while(NULL != pHead)
{
if (pHead->elem == elem1)
{
pTemp1 = pHead;
}
if (pHead->elem == elem2)
{
pTemp2 = pHead;
}
pHead = pHead->next;
}
if ((pTemp1 != NULL)&&(pTemp2 != NULL))
{
ElemType Temp = pTemp1->elem;
pTemp1->elem = pTemp2->elem;
pTemp2->elem = Temp;
printf("SwapList函数执行，交换元素（%d 和 %d）的位置成功\n", elem1, elem2);
}
else
{
printf("SwapList函数执行，在链表中找不到相应的部分或全部元素（%d 和 %d）\n", elem1, elem2);
}
}

//19.将线性表进行快速排序
void QuickSortList(Node **pHead, Node *pEnd)
{
Node *pRight;
Node **pLeft_walk, **pRight_walk;
Node *pPivot, *pOld;
if (*pHead == pEnd)			//pEnd可以是NULL，但不一定是NULL，此处pEnd不可用NULL代替
{
return ;
}
pPivot = *pHead;
pLeft_walk = pHead;
pRight_walk = &pRight;
//取第一个节点作为比较的基准，小于基准的在左边的子链表中，大于基准的在右边的子链表中
for(pOld = (*pHead)->next; pOld != pEnd; pOld = pOld->next)
{
if (pOld->elem < pPivot->elem)
{
*pLeft_walk = pOld;
pLeft_walk = &(pOld->next);
}
else
{
*pRight_walk = pOld;
pRight_walk = &(pOld->next);
}
}
//合并链表
*pRight_walk = pEnd;
*pLeft_walk = pPivot;
pPivot->next = pRight;
//分治、递归
QuickSortList(&(pPivot->next), pEnd);
QuickSortList(pHead, pPivot);

//下面这段代码纯粹是为了保证函数风格，与排序无关
static bool flag = true;
if (flag)
{
printf("QuickSortList函数执行，链表排序成功\n");
flag = false;
}
}
int main()
{
Node *pList = NULL;

// 1.初始化线性表，即置单链表的表头指针为空
InitList(&pList);
PrintList(pList);

// 2.创建线性表，此函数输入负数终止读取数据
pList = CreastList(pList);
PrintList(pList);

// 5.返回单链表的长度
int length = SizeList(pList);
PrintList(pList);

// 6.检查单链表是否为空，若为空则返回１，否则返回０
IsEmptyList(pList);

// 7.返回单链表中第pos个结点中的元素，若pos超出范围，则停止程序运行
ElemType posElem;
posElem = GetElement(pList, 3);
printf("GetElement函数执行，位置3中的元素为%d\n",posElem);
PrintList(pList);

// 8.从单链表中查找具有给定值x的第一个元素，若查找成功则返回该结点data域的存储地址，否则返回NULL
GetElemAddr(pList, 5);

// 9.把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０
ModifyElem(pList, 4, 10);
PrintList(pList);

// 10.向单链表的表头插入一个元素
InsertHeadList(&pList, 5);
PrintList(pList);

// 11.向单链表的末尾添加一个元素
InsertLastList(&pList, 10);
PrintList(pList);

// 12.向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０
InsertPosList(&pList, 3, 18);
PrintList(pList);

// 14.从单链表中删除表头结点，并把该结点的值返回，若删除失败则停止程序运行
DeleteHeadList(&pList);
PrintList(pList);

// 15.从单链表中删除表尾结点并返回它的值，若删除失败则停止程序运行
DeleteLastList(&pList);
PrintList(pList);

// 16.从单链表中删除第pos个结点并返回它的值，若删除失败则停止程序运行
DeletePosList(&pList, 6);
PrintList(pList);

// 17.从单链表中删除值为x的第一个结点，若删除成功则返回1,否则返回0
DeleteValuexList(&pList, 3);
PrintList(pList);

// 18.交换2个元素的位置
SwapList(&pList, 2, 7);
PrintList(pList);

// 19.将线性表进行快速排序
QuickSortList(&pList, NULL);
PrintList(pList);

// 13.向有序单链表中插入元素x结点，使得插入后仍然有序
InsertOrder(&pList, 5);
PrintList(pList);

// 4.清除线性表L中的所有元素，即释放单链表L中所有的结点，使之成为一个空表
ClearList(pList);
system("pause");
return 0;
}