数据结构 线性结构中的链表

定义：

n个节点离散分配

彼此通过指针相连

每个节点只有一个前驱节点，每个节点只有一个后续节点

首节点没有前驱节点，尾节点没有后续节点。

专业术语：
首节点：
第一个有效节点
尾节点：
最后一个有效节点
头节点：
头结点的数据类型和首节点的类型一样
没有存放有效数据，最最前面的，是在
首节点之前的，主要是为了方便对链表
的操作。
头指针：（指向头）
指向头节点的指针变量
尾指针：
指向尾节点的指针

分类：

a 单链表

b 双链表：

每一个节点有两个指针域

c 循环链表：

能通过任何一个节点找到其他所有的节点

d 非循环链表

//链表
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

typedef struct Node
{
int data;//数据域
struct Node * pNext;//指针域
}NODE,*PNODE;
//函数声明
PNODE creat_list(void);//创建链表
void traverse_list(PNODE pHead);//遍历输出链表中节点的值
bool is_empty(PNODE pHead);//判断链表是否为空
int length(PNODE pHead);//求链表中节点的个数
void sort_list(PNODE pHead);//排序
bool insert_list(PNODE pHead,int pos,int val);//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值为val；
bool delect_list(PNODE, int, int*);

//主函数入口
int main(void)
{
PNODE pHead = NULL;//创建头指针
int val;

pHead = creat_list();//创建节点
//排序前链表中节点的值
traverse_list(pHead);//遍历节点
if( is_empty(pHead))
{
printf("链表为空！即链表节点的个数为%d\n",length(pHead));

}
else
{
printf("链表不为空！且链表节点的个数为%d\n",length(pHead));
}

//升序排序后的链接中节点的值
printf("升序排序后的链接中节点的值\n");
sort_list(pHead);
traverse_list(pHead);//遍历节点

insert_list(pHead,4,33333);
//插入后的链接中节点的值
printf("插入后的链接中节点的值\n");
traverse_list(pHead);//遍历节点

if( delect_list(pHead,2, &val) )
{
printf("删除成功，您删除的元素是：%d\n",val);
}
else
{
printf("删除不成功");
}

return 0;

}

PNODE creat_list(void)
{
int len;//存放有效节点的个数
int i;
int val;//临时存放输入的节点的值

PNODE pHead = (PNODE)malloc(sizeof(NODE));
if(pHead==NULL)
{
printf("分配失败，程序终止！\n");
exit(-1);
}

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

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

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

PNODE pNew = (PNODE)malloc(sizeof(NODE));
if(pNew==NULL)
{
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(p!=NULL)
{
printf("%d \n",p->data);
p=p->pNext;
}
}

bool is_empty(PNODE pHead)
{
if(NULL==pHead->pNext)
return true;
else
return false;
}
int length(PNODE pHead)
{
int len=0;
PNODE p = pHead->pNext;
while(p!=NULL)
{
++len;
p=p->pNext;
}
return len;

}

void sort_list(PNODE pHead)
{
int i,j,t;
int len;
len = length(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)//a[i]>a[j]
{
t=p->data;// t=a[i];
p->data=q->data;//a[i]=a[j];
q
4000
->data=t;//a[j]=t;
}
}
}
return;
}
//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值为val；
bool insert_list(PNODE pHead,int pos,int val)
{
int i=0;
PNODE p = pHead;
while (NULL!=p && i<pos-1)
{
p= p->pNext;
++i;
}
if(i>pos-1 || NULL==p)
return false;

PNODE pNew = (PNODE) malloc(sizeof(NODE));
if(NULL==pNew)
{
printf("动态分配内存失败！\n");
exit(-1);
}
pNew->data=val;
PNODE q=p->pNext;
p->pNext=pNew;
pNew->pNext=q;

return true;
}
//删除第pos个元素
bool delect_list(PNODE pHead, int pos, int * pval)
{
int i=0;

PNODE p = pHead;
while (NULL!=p->pNext && i<pos-1)
{
p= p->pNext;
++i;
}
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;
}