数据结构之线性结构的离散存储(单链表)

离散存储 [链表]
定义：
n个节点离散分配(数据域和指针域)
彼此通过指针相连
每个节点只有一个前驱结点，每个节点只有一个后续节点
首结点没有前驱结点，尾结点没有后续节点

专业术语：
首结点：
第一个有效节点
尾结点：
最后一个有效节点
头结点：(1000个字节数据)字节数不一样
头结点的数据类型和首节点类型一样
第一个有效节点之前的那个结点
头结点并不存放有效数据
加头结点的目的主要是为了方便对链表的操作
头指针：
指向头结点的指针变量
头指针和头结点的异同：
头指针
(1)头指针是指链表指向第一个节点的指针，若链表有头结点，则是指向头结点的指针。
(2)头指针具有标识作用，所以常用头指针冠以链表的名字。
(3)无论链表为空，头指针均不为空。头指针是链表的必要元素。
头结点
(1)头结点是为了操作的统一和方便而设立的，放在第一元素的节点之前，其数据域一般无意义。
(2)有了头结点，对在第一元素的节点前插入节点和删除第一节点，其操作与其他节点的操作统一。
(3)头结点不一定是链表的必需元素。
尾指针：
指向尾结点的指针变量

如果希望通过一个函数对链表进行处理，我们至少需要接受链表的哪些参数：
只需要一个参数：头指针
因为我们通过头指针可以推算出链表的其他所有信息

程序：一个结点的生成  di_5

分类：
单链表
双链表：
每一个节点有两个指针域
循环链表：
能通过任何一个结点找到其他所有的结点。
非循环链表

算法：
遍历
查找
清空
销毁
求长度
排序
删除结点
插入节点
算法：
狭义的算法是与数据的存数方式密切相关。
广义的算法是与数据的存储方式无关
泛型：
利用某种技术达到的效果就是：不同的存数方式，执行的操作是一样的

链表的优缺点：

代码如下：

#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 pHead);
bool insert_list(pnode pHead,int,int);
bool delete_list(pnode,int,int *);
void sort_list(pnode);


int main(void)
{
    int val;
pnode pHead = NULL;
pHead = create_list();//create_list()功能：创建一个非循环单链表，并将该链表的头结点的地址赋给pHead
traverse_list(pHead);


    if(delete_list(pHead,3,&val))
{
printf("删除成功，您删除的元素：%d.\n",val);
}
else
{
printf("删除失败！\n");
}
traverse_list(pHead);
// insert_list(pHead,4,44);
// traverse_list(pHead);
// int len = length_list(pHead);
// printf("%d \n",len);

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


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

return 0;
}
pnode create_list(void)
{
int len;//用来存放有效节点的个数
int i;  
int val;//用来临时存放用户输入的节点的值


//分配了一个不存放有效数据的头结点
pnode pHead;  //头指针
pHead = (pnode)malloc(sizeof(node));
if(NULL == pHead)
{
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(NULL == pNew)
{
printf("分配失败，程序终止!\n");
exit(-1);
}
       /*
pNew->data = val;
pHead->pnext = pNew;
pNew->pnext = NULL;*/
pNew->data = val;
pTail->pnext = pNew;
pNew->pnext = NULL;
pTail = pNew;
}
return pHead;
}
//遍历链表的节点
void traverse_list(pnode pHead)
{
pnode p;

p = pHead->pnext;

while(p != NULL)
{
printf("%d ",p->data);
p = p->pnext;
}
printf("\n");
}
bool is_empty(pnode pHead)
{
if(pHead->pnext == NULL)
return true;
else
return false;
}
int length_list(pnode pHead)
{
pnode p;


p = pHead->pnext;
int len = 0;


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


return len;
}


void sort_list(pnode pHead)
{
int i,j,t,len = 0;
len = length_list(pHead);
pnode p,q;


for(i = 0,p = pHead->pnext; i < len; i++,p = p->pnext)
{
for(j = 0,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;
}
//在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))
{
p = p->pnext;
i++;
}


if((i > pos-1) || (NULL == p))
return false;
pnode pNew = (pnode)malloc(sizeof(node));
if(pNew == NULL)
{
printf("分配失败，程序终止!\n");
exit(-1);
}


pNew->data = val;
pnode q;
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;


while((NULL != p->pnext) && (i < pos-1))
{
p = p->pnext;
i++;
}


if((i > pos-1) || (NULL == p->pnext))
return false;

pnode q;


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

return true;
}