单链表

单链表

1. 建立一个单链表
2. 遍历链表
3. 计算链表的长度
4. 插入一个节点
5. 删除节点
6. 对链表进行排序

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

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

PNODE create_list(void);					//建立一个链表
void traverse_list(PNODE pHead);			//遍历一遍链表
bool is_empty(PNODE pHead);					//判断链表是否为空
int length_list(PNODE);						//判断链表的长度
bool insert_list(PNODE pHead , int pos , int val);	//在pos节点前增加一个节点
bool delete_list(PNODE , int , int *);				//删除pos节点
void sort_list(PNODE);								

int main(void) //对链表进行一些使用，可以不看
{
PNODE pHead;
int val ;

pHead = create_list();
traverse_list(pHead);

insert_list(pHead , 5, 9);
traverse_list(pHead);

if(delete_list(pHead ,6, &val))
{
	printf("delete the number success of %d \n", val);
}
else 
{
	printf("delete the number false\n");
}

sort_list(pHead);
traverse_list(pHead);

return 0;

}

1. 建立一个单链表

PNODE create_list(void)
{
	int len;
	int i;
	int val;

	PNODE pHead = (PNODE)malloc(sizeof(NODE));
	if(pHead == NULL)
	{
		exit(-1);		//判断有没有内存创建一个头结点
	}
	
	PNODE pTail = pHead;//尾节点
	pTail->pNext = NULL;

	scanf("%d", &len);  //输入有多少个节点

	for(i = 0 ; i<len ; i++)
	{
		printf("please input %d number ", i+1);		//输入第n个节点的数据
		
		scanf("%d", &val);							//并存放到变量val中

		PNODE pNew = (PNODE)malloc(sizeof(NODE));   //建立一个新的节点
		if(pNew == NULL)
		{
			exit(-1);								//判断有没有内存创建一个结点
		}

		pNew->data = val;							//将数据放到有效节点中
		pTail->pNext = pNew;						//尾节点指向最后一个有效节点,尾节点也等于上一个最后的结点,即上一个最后的节点指向这回最后的节点
		pNew->pNext = NULL;							//最后的节点没有指向
		pTail = pNew;								//让尾节点挂在最后一个节点上
	}
	return pHead;

}

2. 遍历链表

void traverse_list(PNODE pHead)
{


	PNODE pCha = pHead->pNext;			//用头结点来遍历

	while(pCha != NULL)					//判断是否存在节点
	{
		printf("%d ", pCha->data);		//输出节点的数据

		pCha = pCha->pNext;				//指向下一个节点

	}
	printf("\n");
}


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

3. 计算链表的长度

int length_list(PNODE pHead)
{
	int i = 0;
	PNODE p = pHead;

	while(p != NULL)					//判断是否存在节点
	{
		i++;							
		p = p->pNext;					//计算节点个数
	}

	return i;
}

4. 插入一个节点

//在pHead所指向链表的第pos个节点的前面插入一个新的结点，该节点的值是val， 并且pos的值是从1开始
bool insert_list(PNODE pHead , int pos , int val)
{
	int i = 0;
	PNODE p = pHead ;					//指向头结点


	while(p !=NULL && i < pos-1)		//
	{
		p = p->pNext;					//先让p指向第pos-1个节点,即pos前面的节点
		++i;
	}

	if(p ==NULL || i < pos-1)			//判断节点是否存在，判断是不是超了
	{
		printf("overtake number\n");	
		return false;
	}

	PNODE pNew = (PNODE)malloc(sizeof(NODE));	//建立新的节点
	if(pNew == NULL)							//判断内存
	{
		exit(-1);
	}

	pNew ->data = val ;							//给新节点赋值
	PNODE q = p->pNext;							//建立一个局部变量，挂在pos节点上
	p->pNext = pNew ;							//pos前面的节点指向新节点
	pNew->pNext = q;							//新节点指向pos节点

}

5. 删除节点

//删除第pos个节点
bool delete_list(PNODE pHead, int pos , int * val)
{
	int i = 0;
	PNODE p = pHead ;							//指向头结点

	while(p->pNext != NULL && i<pos-1)		
	{
		p = p->pNext;							//先让p指向第pos-1个节点,即pos前面的节点	
		i++;
	}

	if(p->pNext == NULL || i>pos-1)				//判断节点是否存在
	{
		return false ;
	}

	PNODE q = p->pNext ;						//建立一个局部变量，挂在pos节点上
	* val = p->pNext->data;						//建立一个局部变量，指向pos节点的数据的地址
	p->pNext = p->pNext->pNext ;				//p是pos-1，让其指针区指向pos+1
	free(q);									//释放q所挂的节点pos
	q = NULL;									//q指向空值

	return true;
}

6. 对链表进行排序

void sort_list(PNODE pHead)
{
	//int i, j, k ;
	//int len = length_list(pHead);
	int k ;
	PNODE p = pHead ;
	PNODE q ;

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

	//以下程序类似于上面的程序,对节点的大小进行排列
	for (p->pNext ; p != NULL ; p = p->pNext)
	{
		for(q = p->pNext ; q != NULL ; q = q->pNext)
		{
			if(p->data > q->data)
			{
				k = p->data ;
				p->data = q->data ;
				q->data = k ;

			}
		}
	}


}

郝斌数据结构