数据结构_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;
}