单链表的实现

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

//创建链表
PNODE create_list(){
int len;//用来存放节点的个数
int i;
int  val;//用来临时存放用户输入的节点的值

//头结点
PNODE pHead=(PNODE)malloc(sizeof(NODE));
//如果为NULL，则分配失败
if(NULL==pHead){
printf("分配失败，程序终止");
exit(-1);
}

//空链表时，使头节点和尾节点都相等，且尾节点的指针域为NULL
PNODE pTail=pHead;
pTail->pNext=NULL;

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

if(len<0){
printf("你输入链表长度不合法！请重新输入：");
scanf("%d",&len);
}

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

//分配新内存，生成新节点
PNODE pNew=(PNODE)malloc(sizeof(NODE));
if(NULL==pNew){
printf("分配失败，程序终止");
exit(-1);
}
//将数值赋值个pNew的数据域
pNew->data=val;
//让尾节点的指针域指向pNew
pTail->pNext=pNew;
//将pNew变成尾节点
pNew->pNext=NULL;
pTail=pNew;
}
return pHead;
}

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

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

int length_list(PNODE pHead){

int len=0;
PNODE p=pHead->pNext;

while(NULL!=p){
len++;
p=p->pNext;
}
return len;
}

void sort_list(PNODE pHead){

PNODE p,q;
int temp;
//遍历链表，比较大小，直到p中的指针域为NULL就停止遍历
for(p=pHead->pNext;p!=NULL;p=p->pNext){
for(q=p->pNext;q!=NULL;q=q->pNext){
//如果p数据域的值大于q数据域的值
if(p->data > q->data){
//交换q，p数据域的值
temp=p->data;
p->data=q->data;
q->data=temp;
}
}
}
}

// 在pHead所指向的链表中第index节点之前插入一个新的节点，该节点的值为val。
bool insert_list(PNODE pHead,int index,int val){

int i=0;
//保存头指针
PNODE p=pHead;

//分配新内存，新节点。
PNODE pNew=(PNODE)malloc(sizeof(Node));
if(NULL==pNew){
printf("动态分配内存失败");
exit(-1);
}

//通过循环，使p指向index位置的节点
while(NULL!=p&&i<index-1){
p=p->pNext;
i++;
}

if(i>index-1||NULL==p){
printf("已经超出插入范围") ;
return false;
}

//保存插入的val
pNew->data=val;

/*pNew头部先插入 的方式
PNODE  temp=p->pNext;
p->pNext=pNew;
pNew->pNext=temp;
*/

//pNew尾部先插入
pNew->pNext=p->pNext;
p->pNext=pNew;
return true;
}

bool detele_list(PNODE pHead,int index,int *pVal){
int i=0;
PNODE p=pHead;

//通过遍历，使ｐ指向ｉｎｄｅｘ前面的节点
//如果 p->pNext==null，后面就没有节点了
while(NULL!=p->pNext&&i<index-1){
p=p->pNext;
i++;
}

if(i>index-1||NULL==p->pNext)
return false;

//临时保存要删除节点的内存
PNODE q=p->pNext;
//将删除的节点中的数据保存起来
*pVal=q->data;
//将要删除节点前面的节点的指针域，指向要删除节点的下一个节点
p->pNext=p->pNext->pNext;
//释放要删除节点的内存
free(q);
q=NULL;

return true;
}

int getElem(PNODE pHead,int index){

//保存找到的数据
int  temp;
//计数器
int j=1;

PNODE p=pHead->pNext;
//判断数据表是否为空
if(is_empty_list(pHead)){
printf("链表为空！");
exit(-1);
}
//如果查询的位置大于链表的长度
//length_list(p)测试链表的长度
if(index>length_list(p)){
printf("所找的位置不存在！");
exit(-1);
}

//循环遍历，直到找到第index位置的数据的指针
while(j<index){

p=p->pNext;
j++;
}

temp=p->data;

return temp;

}

bool clearList(PNODE pHead){

//判断链表是否为空
if(is_empty_list(pHead)){
printf("链表为空！\n");
return false;
}

PNODE p,q;

p=pHead;

while(p){
q=p->pNext;
free(p);
p=q;
}

pHead->pNext=NULL;
}

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

//函数声明
PNODE create_list(void);
void traverse_list(PNODE pHead);
bool is_empty_list(PNODE pHead);
int length_list(PNODE pHead);
void sort_list(PNODE pHead);
bool insert_list(PNODE pHead,int index,int val);
bool detele_list(PNODE pHead,int index,int *pVal);
int getElem(PNODE pHead,int index);
bool clearList(PNODE pHead);

int main()
{
//保存删除的数据
int pVal;

//创建链表
PNODE p=create_list();
//遍历链表
printf("链表遍历！\n");
traverse_list(p);

//输入链表长度
//printf("链表长度len=%d\n",length_list(p));

//冒泡排序
sort_list(p);
printf("冒泡排序后的链表遍历！\n");
traverse_list(p);

//插入999到第四个位置
insert_list(p,4,999);
printf("插入后的链表遍历！\n");
traverse_list(p);

//删除数据
if(detele_list(p,1,&pVal)){
printf("\n删除的数据是pval=%d\n",pVal);
}else{
printf("你删除的值不存在\n");
}
printf("删除后的链表遍历！\n");
traverse_list(p);

//找到第三位置的数
printf("第三位置的数的数是%d\n",getElem(p,3));

//清空链表
clearList(p);
traverse_list(p);
return 0;
}