数据结构_P14

/*
*	链表的创建、遍历、判断为空、求链表长度、插入节点、删除节点、排序
*	2016年6月10日15:30:54--2016年6月10日20:48:08
*/
# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>

typedef struct Node
{
int data;	//节点数据域
struct Node* pNext;		//节点指针域
} NODE, *PNODE;

PNODE creat_list();
void traverse_list(PNODE pHead);	//函数声明，这里pHead可写可不写
bool is_empty(PNODE pHead);
int length_list(PNODE);
bool insert_list(PNODE, int pos, int val);		//在pHead所指向链表的第pos个节点的前面插入一个新节点，该节点的值是为val，且pos值从1开始
bool delete_list(PNODE, int, int*);  //int*存放删除的值
void sort_list(PNODE);

int main(void)
{
PNODE pHead = NULL;		//等价于struct Node* pHead = NULL;

pHead = creat_list();	//创建一个非循环单链表，并将该链表的头结点地址赋值给pHead

if( is_empty(pHead) )
printf("链表为空\n");
else
{
traverse_list(pHead);		//遍历输出

printf("链表有效节点长度(个数)是: %d\n", length_list(pHead));

printf("将链表排序后 ");
sort_list(pHead);				//排序并遍历输出
traverse_list(pHead);

insert_list(pHead, 1, 190);		//在第一个有效节点前插入190
traverse_list(pHead);

int val;		//存放删除的值
if( delete_list(pHead, 4, &val) )		//删除第pos个有效节点
printf("删除成功，删除的值是: %d", val);
else
printf("删除失败");

printf("删除后的链表为: ");
traverse_list(pHead);
}

return 0;
}

PNODE creat_list()
{
int len;	//用来存放有效节点的个数
int i;
int temp;	//用来临时存放用户输入节点的值

printf("请输入您需要生成的链表节点个数: len = ");
scanf("%d", &len);

PNODE pHead = (PNODE)malloc(sizeof(NODE));  //分配一个不存放数据的头结点
if(pHead == NULL)	//pHead内存分配失败，终止程序
{
printf("链表内存分配失败");
exit(-1);		//需要用stdlib.h头文件
}

PNODE pTail = pHead;	//定义一个尾指针
pTail->pNext = NULL;	//!注意思考：这步是必需的，如果用户输入链表长度为0，因遍历链表时条件要找NULL，所以这里pTail的pNext必须为NULL

for(i=0; i<len; i++)
{
printf("请输入第%d个节点的值: ", i+1);
scanf("%d", &temp);

PNODE pNew = (PNODE)malloc(sizeof(NODE));  //新建节点，之后赋值
if(pHead == NULL)	//pHead内存分配失败，终止程序
{
printf("链表内存分配失败");
exit(-1);		//需要用stdlib.h头文件
}

pNew->data = temp;		//赋值
pNew->pNext = NULL;		//赋值

pTail->pNext = pNew;	//新节点挂到尾指针上
pTail = pNew;			//新节点挂到尾指针上
}
return pHead;
}

void traverse_list(PNODE pHead)
{
PNODE p = pHead->pNext;
printf("遍历链表值分别是：\n");
while(p != NULL)
{
printf("%d ", p->data);
p = p->pNext;
}
printf("\n");
return;
}

bool is_empty(PNODE pHead)
{
if(pHead->pNext == NULL)
return true;
else
return false;
}

int length_list(PNODE pHead)
{
int len_count = 0;
PNODE p = pHead->pNext;
while(p != NULL)
{
p = p->pNext;
len_count++;
}
return len_count;
}

void sort_list(PNODE pHead)		//与数组冒泡排序思想是一样的
{
int t;
PNODE p, q;

for(p=pHead->pNext; p!=NULL; p=p->pNext)    //这里写p!=NULL可以，写i<len的条件（for循环需要有两个同时变得量，一个p指针，一个i变量）也可以
{
for(q=p->pNext; q!=NULL; q=q->pNext)
{
if(p->data > q->data)
{
t = p->data;
p->data = q->data;
q->data = t;
}
}
}
return;
}

/*	数组冒泡排序程序，这里是链表，都是线性结构，广义上算法逻辑是一样的
*	int i, j, t;

for(i=0; i<len-1; i++)
{
for(j=i+1; j<len; j++)
{
if(a[i] > a[j])
{
t = a[i];
a[i] = a[j];
a[j] = t;
}
}
}
*/

bool insert_list(PNODE pHead, int pos, int val)		//在pos节点前面插入一个节点，值为val，pos从1开始; 假如有效节点个数为5个，pos值范围在1~6
{
int i = 0;
PNODE p = pHead;

while(p!=NULL && i<pos-1)		//从这
{
p = p->pNext;
i++;
}
if(i>pos-1 || p==NULL)			//!到这：好好看这非人类的无bug算法，将p指针移动到了pos个节点的前一个节点
return false;

PNODE pNew = (PNODE)malloc(sizeof(NODE));	//生成插入的节点
if( pNew == NULL)
{
printf("内存分配失败，终止程序！");
exit(-1);
}

pNew->data = val;		//将节点赋值并插入至指定pos个节点前
pNew->pNext = p->pNext;
p->pNext = pNew;
return true;
}

bool delete_list(PNODE pHead, int pos, int* pval)	//删除第pos个有效节点
{
int i = 0;
PNODE p = pHead;

while(p->pNext!=NULL && i<pos-1)		//从这
{
p = p->pNext;
i++;
}
if(i>pos-1 || p->pNext==NULL)			//!到这：好好看这非人类的无bug算法，将p指针移动到了pos个节点的前一个节点
return false;

PNODE r = p->pNext;
*pval = r->data;	//将删除的值存放至pval中
p->pNext = p->pNext->pNext;
free(r);	//是删除r指针指向的节点内存，而不是r指针本身
r = NULL;

return true;
}