带头结点的单链表的八种基本操作

单链表的建立、遍历、判断是否为空、求长、插入、删除、排序、逆置。（不断添加）

已通过编译运行。

#include <iostream>
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>    //exit(-1)
using namespace std;

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

//函数声明 8种函数：    单链表的建立、遍历、判断是否为空、求长、插入、删除、排序、逆置； 
PNODE create_list();
void traverse_list(PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE pHead);
bool insert_list(PNODE pHead,int pos,int val);
bool delete_list(PNODE pHead,int pos,int *pVal);
void sort_list(PNODE);
PNODE reverse_list(PNODE pHead);

int main()
{
	int len;
	PNODE pHead=NULL;
	                       //动态内存才可以：在一个函数中分配，另一个函数也可以用 
	pHead=create_list(); 
	  //创建一个非循环单链表，并将该链表的头结点的地址赋给pHead
/*	len=length_list(pHead);
	cout<<"链表长度len="<<len<<endl;
	
	traverse_list(pHead);
	insert_list(pHead,3,33);
	traverse_list(pHead);
	
	if(is_empty(pHead))
	    cout<<"链表为空"<<endl;
	else
	    cout<<"链表不空"<<endl; 
	    
	sort_list(pHead);
	traverse_list(pHead);*/
	
	traverse_list(pHead);
	
    PNODE pHead1=reverse_list(pHead);
	traverse_list(pHead1);
	
	return 0; 
}

PNODE create_list()
{
	int len;//有效节点的个数 
	int i;
	int val;//用来存放用户输入的结点的值 
	
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		cout<<"分配失败，程序终止！"<<endl;
		exit(-1); 
	}
	
	PNODE pTail=pHead;
	pTail->pNext =NULL;
	
	cout<<"请输入您需要生成的链表节点的个数：len=";
	cin>>len;
	
	for(i=0;i<len;++i)
	{
		cout<<"请输入第"<<i+1<<"个节点的值：";
		cin>>val;
		 
		PNODE pNew=(PNODE)malloc(sizeof(NODE));
	    if(NULL==pNew)
	    {
	    	cout<<"分配失败，程序终止！"<<endl;
	    	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)
	{
		cout<<p->data<<" ";
		p=p->pNext;
	}
	cout<<endl;
	
	return;  //告诉别人函数执行完毕 
}

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

int length_list(PNODE pHead)
{
	int len=0;
	PNODE p=pHead->pNext;
	while(p!=NULL)
	{
		p=p->pNext;
		len++;
	}
	return len;
}
//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值为val，并且pos的 值是从1开始 
bool insert_list(PNODE pHead,int pos,int val) //pos:第pos个位置，从第1个位置开始计 
{
	int i=0;
	PNODE p=pHead;
	
	//不需判断链表是否为空，不需判断pos是否满足链表长度要求等。。此部分用while和if全部搞定 
	while(NULL!=p&&i<pos-1)   //不能写成<=，否则出错 
	{
		i++;
		p=p->pNext;
	}
	if(i>pos-1 || NULL==p)
	    return false;


	PNODE pNew=(PNODE)malloc(sizeof(NODE));
	 if(NULL==pNew)
	    {
	    	cout<<"分配失败，程序终止！"<<endl;
	    	exit(-1); 
	    }
	    
	pNew->data =val;
	PNODE q=p->pNext;
	p->pNext =pNew;
	pNew->pNext =q;
	
	return true;
}

bool delete_list(PNODE pHead,int pos,int *pVal)
{
		int i=0;
	PNODE p=pHead;
	
	//不需判断链表是否为空，不需判断pos是否满足链表长度要求等。。此部分用while和if全部搞定 
	while(NULL!=p->pNext &&i<pos-1)   //不能写成<=，否则出错 
	{
		i++;
		p=p->pNext;
	}
	if(i>pos-1 || NULL==p->pNext )
	    return false;

    PNODE q=p->pNext ;
    *pVal=q->data ;
    
    //删除p后面的节点   
	p->pNext =p->pNext->pNext;
	free(q);
	q=NULL;

	return true;
}

//单链表的排序 
void sort_list(PNODE pHead)
{
	int i,j,t;
	PNODE p=pHead->pNext;
	
	for(i=0;i<length_list(pHead)-1;i++)
	{
	    p=pHead->pNext;
	    for(j=0;j<length_list(pHead)-i-1;j++)
	    {
	    	if(p->data < p->pNext->data)   //冒泡法，将最小的冒泡到最后，降序排列； 
			{
				t=p->data;
				p->data = p->pNext->data ;
				p->pNext->data = t ;
			}
			p=p->pNext;    
		}
	}
}

//逆置：定义三个指针 
PNODE reverse_list(PNODE pHead)                    //输出正确 
{
	int i;
	PNODE p1,p2;
	p1=NULL;
	p2=pHead->pNext; 
	
	while(p2!=NULL)
	{
		PNODE p3=p2->pNext;
		p2->pNext =p1;
		p1=p2;
		p2=p3;
	}
	pHead->pNext =NULL ;
	pHead->pNext=p1;
	return pHead;
}