数据结构的list代码

code：
# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>

//结构体节点
typedef struct Node
{
	int data;     //数据域
	struct Node *pNext;     //指针域
}NODE, *PNODE;     //NODE等价于struct Node    PNODE等价于struct Node *

				   //函数声明
PNODE create_list();    //创建链表
void traverse_list(PNODE pHead);    //遍历链表
bool is_empty(PNODE);     //判断链表是否为空
int length_list(PNODE);   //求链表长度
void sort_list(PNODE pHead);     //对链表进行排序
bool insert_list(PNODE, int, int);     //在pHead所指向链表的第pos个节点的前面插入一个新的结点，该节点的值是val， 并且pos的值是从1开始
bool delete_list(PNODE pHead, int pos, int*val);     //删除链表第pos个节点，并将删除的结点的值存入pVal所指向的变量中,  并且pos的值是从1开始

													 //主函数
int main(void)
{
	PNODE pHead = NULL;
	int val;  //delete_list保存删除的元素的变量

	pHead = create_list();     //create_list()功能：创建一个非循环单链表，并将该链表的头结点的地址付给pHead
	traverse_list(pHead);

	int len;
	len = length_list(pHead);
	printf("链表的长度为%d\n", len);

	/*
	if(is_empty(pHead))
	printf("链表为空\n");
	else
	printf("链表不空\n");
	*/

	/*
	sort_list(pHead);
	traverse_list(pHead);
	*/

	/*
	insert_list(pHead, 3, 66);
	traverse_list(pHead);
	*/

	if (delete_list(pHead, 3, &val))
	{
		printf("删除成功,您删除的元素是:%d\n", val);
	}
	else
	{
		printf("删除失败,您删除的元素不存在\n");
	}
	traverse_list(pHead);


	printf("\n");
	system("pause");
	return 0;
}

//创建非循环单链表
PNODE create_list()
{
	int len, i, val;   //len用来存放有效节点的个数, val用来临时存放用户输入的结点的值
	PNODE pHead = (PNODE)malloc(sizeof(NODE));   //分配了一个不存放有效数据的头结点
	if (NULL == pHead)
	{
		printf("分配内存失败，程序终止\n");
		exit(-1);
	}

	PNODE pTail = pHead;
	pTail->pNext = NULL;

	printf("输入节点个数：");
	scanf_s("%d", &len);
	for (i = 0; i<len; ++i)
	{
		printf("请输入第%d个节点的值：", i + 1);
		scanf_s("%d", &val);
		PNODE pNew = (PNODE)malloc(sizeof(NODE));
		if (NULL == pNew)
		{
			printf("分配内存失败，程序终止\n");
			exit(-1);
		}
		pNew->data = val;
		pTail->pNext = pNew;
		pNew->pNext = NULL;
		pTail = pNew;
	}
	return pHead;
}

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

//判断是否为空
bool is_empty(PNODE pHead)
{
	if (NULL == pHead->pNext)
		return true;
	else
		return false;
}

//计算链表长度
int length_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	int len = 0;
	while (NULL != p)
	{
		len++;
		p = p->pNext;
	}
	return len;
}

//链表排序
void sort_list(PNODE pHead)
{
	int i, j, t;
	int len = length_list(pHead);
	PNODE p, q;
	for (i = 0, p = pHead->pNext; i < len - 1; ++i, p = p->pNext)
	{
		for (j = i + 1, q = p->pNext; j < len; ++j, 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;
}
}
}
*/


/*
//插入节点//pHead所指向的链表的第pos个节点的前面插入一个新的节点，该节点的值是val,pos的值从1开始
bool insert_list(PNODE pHead, int pos, int val)
{
int i = 0;
PNODE p = pHead;
while (NULL != p && i < pos - 1)      //pos从1开始,i从0开始,pos-1使i和pos的值同步， 保证pos-1节点不为空
{
p = p->pNext;
++i;
}
if (i > pos - 1 || NULL == p)
return false;

//如果程序能执行到这一行说明p已经指向了第pos-1  (i) 个结点,但第pos-1个节点是否存在无所谓
PNODE pNew = (PNODE)malloc(sizeof(NODE));   //分配新的结点
if (NULL == pNew)
{
printf("动态分配内存失败\n");
exit(-1);
}

//将新的结点存入p节点的后面
pNew->data = val;
PNODE q = p->pNext;   //临时静态分配一个内存,PNODE类型的指针变量q,储存p->pNext,使得q指向pos节点
p->pNext = pNew;      //p (pos-1)的指针域 指向 新节点
pNew->pNext = q;      //q指针的值赋给新节点的指针域,使得新节点的指针域 指向 pos
return true;
}
*/


//删除节点，删除第pos个节点，pos的值从1开始
bool delete_list(PNODE pHead, int pos, int * pVal)
{
	int i = 0;
	PNODE p = pHead;

	while (NULL != p->pNext && i < pos - 1)    //pos从1开始,i从0开始,pos-1使i和pos的值同步， 保证pos节点不为空
	{
		p = p->pNext;
		++i;
	}
	if (i > pos - 1 || NULL == p->pNext)
		return false;

	//如果程序能执行到这一行说明p已经指向了第pos-1个结点，并且第pos个节点是存在的
	PNODE q = p->pNext;  //q指向待删除的pos结点
	*pVal = q->data;     //删除的数据存放在pVal
	p->pNext = p->pNext->pNext;    //删除p节点后面的pos结点

	free(q);     //释放q所指向的节点所占的内存
	q = NULL;
	return true;
}
数据结构的list代码

猜你喜欢
