这篇文章主要讲解了“c语言线性表的链式存储结构是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“c语言线性表的链式存储结构是什么”吧！

10年积累的成都网站建设、网站制作经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站设计后付款的网站建设流程，更有莆田免费网站建设让你可以放心的选择与我们合作。

头指针：链表中第一个节点的存储位置叫头指针。

头结点：第一个结点前放的一个不存储任何数据的结点。

头结点与头指针的区别：

    1、头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针；

    2、头指针具有标识作用，所以常用头指针冠以链表的名字；

    3、无论链表是否为空，头指针均不为空。头指针是链表的必要元素。

    4、头结点是为了操作的统一和方便而设立的，放在第一元素的借点之前，其数据域一般无意义（也可存储链表的长度）；

    5、有了头结点，对在第一个元素节点点之前插入结点和删除第一个结点，其他操作与其他结点的操作统一了；

    6、头结点不一定是链表的必要元素

文字描述还是很抽象，让我们来看图，这样更直观：

---

---

理清了这几个概念，接下来我们开始用c语言实现单链表的基本操作（这里会把带头结点与不带头结点分别实现并区别两者的异同）：

---

---

准备工作：定义节点类型，一些声明：

#pragma once

#define ElemType int

#define TRUE    1

#define FALSE   0

#define OK      1

#define ERROR   0

typedef int Status;

typedef int DataType;

//定义结点类型

typedef  struct Node

{

ElemType data;

struct Node  *next;

}SeqNode;

typedef  struct Node *LinkList;            //定义指针类型

---

---

初始化：

---

---

//带头结点的初始化，建立一个只有头结点的空链表,头结点的数据域记录表长，并且头结点不计入长度。

//初始化成功返回OK,失败返回ERROR

Status Init_Head_SeqNode(LinkList *Head)                

{

*Head = (LinkList)malloc(sizeof(SeqNode));

if((*Head) == NULL)

{

printf("out  of  memory\n");

return ERROR;

}

(*Head)->next = NULL;

(*Head)->data = 0;

return OK; 

}

//不带头结点的初始化，建立一个只有头结点的空链表

Status  Init_SeqNode(LinkList *Head)

{

*Head = NULL;

return TRUE; 

}

---

---

头插：下边分别是带头结点与不带头结点的头插方式，直接上代码，可能有些抽象，我自己画了一些图，来帮助理解，希望可以也可以帮助大家理解:

---

带头结点的头插：

不带头结点的头插：

---

头插代码：

---

//带头结点头插,插入成功返回TRUE，失败返回ERROR

Status Insert_Head_Fr(LinkList Head,ElemType x)

{

    LinkList new_node;                           //保存新申请的结点

    new_node = (LinkList)malloc(sizeof(Node));

if(NULL == new_node)

{

    printf("out of memory\n");

    return FALSE;

}

    new_node->data = x;                    //把要插入的值赋值给新申请的结点的数据域

    new_node->next = Head->next;        //第一步：把头结点的下一元素即就是首元结点地地址赋给新的结点

    Head->next = new_node;                 //第二步：把新申请的结点赋值給头结点  

    (Head->data)++;                  //带头结点的头节点的数据域用来保存链表的个数，每添加一个元素加1

    return TRUE;

}

//不带头结点的头插，插入成功返回TRUE,失败返回FALSE

Status Isert_No_Head_Node(LinkList *Head,ElemType x)

{

LinkList new_node;   //保存新申请的结点

new_node = (LinkList)malloc(sizeof(Node));

if(NULL == new_node)

{

printf("out of memory\n");

return FALSE;

}

new_node->data = x;  

new_node->next = (*Head);           

//第一步：先让新申请的结点指向首元结点，因为不带头结点的链表头指针保存首元结点的地址，那么就需要这样赋值

(*Head) = new_node;              //第二步：让头指针指向新申请的结点。

           return TRUE;

}

---

---

尾插：同样我也给出一些我自己绘的图：

---

---

带头结点的尾插：

不带头结点的尾插：

---

尾插代码：

---

/*不带头结点的与带头结点的进行尾插的时候，有人会认为两者是没有区别的，

**我想你可能忽略了当链表中没有元素时两着的插入还是有区别的。

*/

//带头结点尾插,插入成功返回TRUE，失败返回ERROR

Status Insert_Head_Ba(LinkList Head,ElemType  x)

{

LinkList new_node;                            //保存新申请的结点

LinkList temp = Head;                         //找到尾结点

new_node = (LinkList)malloc(sizeof(Node));

if(NULL == new_node )

{

printf("out of memory\n");

return FALSE;

}

//利用临时变量遍历所有链表，找到尾结点，因为temp本身是指向当前节点的next的，所以当temp等于NULL时就到了链表的最后一个结点

while(NULL != temp->next)                 

{

temp = temp->next;

}

new_node->data = x;

new_node->next = NULL;

temp->next = new_node;

Head->data++;               //带头结点的头节点的数据域用来保存链表的个数，每添加一个元素加1

return TRUE;

}

//不带头结点尾插,插入成功返回TRUE，失败返回ERROR

Status Insert_No_Head_Ba(LinkList *Head,ElemType x)

{

LinkList new_node;

LinkList temp = (*Head);                        //保护头指针

new_node = (LinkList)malloc(sizeof(Node));      //为新申请的结点分配空间

if(NULL == new_node)

{

printf("out of menory\n");

return FALSE;

}

if(NULL == (*Head))                    //空链表

{

new_node->next = NULL;

new_node->data = x;

(*Head) = new_node;

return TRUE;

}

else

{

//利用临时变量遍历所有链表，找到尾结点，因为temp本身是指向当前节点的next的，所以当temp等于NULL时就到了链表的最后一个结点了

while(NULL != temp->next)             

{

temp = temp->next;

}

new_node->data = x;

new_node->next = NULL;

temp->next = new_node;

return TRUE;

}

}

---

---

按照位置插入：同样先看图：

---

带头结点的按位置插入：

不带头结点按照位置插入：

---

//带头结点的按照位置插入如元素，头节点不计入位置，插入时分为空链表和非空链表，由于带头结点所以所有操作是一样的

//插入成功返回TRUE，并且头结点的数据元素加1,插入失败返回FALSE。

Status Insert_Head_Pos_SeqNode(LinkList Head, ElemType x, int pos)

{

LinkList temp = Head;                        //保护头指针

LinkList temp_pre = Head;                      //保存定位的pos位置地址

LinkList new_node;

new_node = (LinkList)malloc(sizeof(Node));      //为新申请的结点分配空间

if(NULL == new_node)

{

printf("out of memory\n");

return FALSE;

}

if(pos > Head->data)         

{

printf("插入位置出错，%d不能插入\n",x);

return FALSE;

}

//通过遍历找到要放数据位置的结点，但是由于单链表的当前结点只能找到下一个结点，

//而插入数据时，需要知道当前结点的位置，所以就需要定义一个变量来保存当前前结点的前一个结点

for(int i = 0; i < pos;i++)                                

{

temp = temp->next;

temp_pre = temp_pre->next;

}

new_node->data = x;               //为新申请的节点的数据域赋值

new_node->next = temp;          

//第一步：首先让新结点指向要插入的位置，也就是当前结点的前一个结点保存的位置

temp_pre->next = new_node;                 //第二步：让当前结点的前一个结点指向指向新结点

Head->data++;                             //插入成功，链表个数加1

return TRUE;

}

//不带头结点的按位置插入，分为两种情况，如果是空链表，就要修改头指针的指向，那么修改指针的指向，就要用二级指针接收

//如果不是空链表，只需要遍历链表，找到位置，这两种情况都要考虑插入位置是否正确

//插入成功返回TRUE，插入失败返回FALSE。

Status Inser_No_Head_Pos_SeqNode(LinkList *Head, int pos, ElemType x)

{

int Num = 0;                                 //计算链表一共多少个结点

LinkList temp = (*Head);                    //保护头指针

        LinkList temp_pre = (*Head);                //保存pos 位置的地址

LinkList new_node;

new_node = (LinkList)malloc(sizeof(Node));      //为新申请的结点分配空间

if(NULL == new_node )         //防止开辟内存失败

{

printf("out of memory\n");

return FALSE;

}

//处理空链表的情况

if(NULL == (*Head) )

{

if(pos > 0)

{

printf("插入位置出错，%d不能插入\n",x);

return FALSE;

}

else

{

new_node->data = x;                  //为开辟的新结点赋值

new_node->next = NULL;  //第一步：先让新申请的节点指向要插入 的结点的下一个结点

(*Head) = new_node;                  //让头指针指向新结点

return TRUE;

}

}

//处理非空链表的情况

else

{

//通过遍历找到要放数据位置的结点，但是由于单链表的当前结点只能找到下一个结点，

//而插入数据时，需要知道当前结点的位置，所以就需要定义一个变量来保存当前前结点的前一个结点

while(NULL != temp)

{

Num++;

temp = temp->next;

}

if(pos+1 > Num)                                //如果插入位置出错直接跳出

{

printf("插入位置出错，%d不能插入\n",x);

return FALSE;

}

else if(0 == pos)

{

new_node->data = x;                  //为开辟的新结点赋值

new_node->next = (*Head);

(*Head) = new_node;

}

else

{

//当遍历确定pos位置正确后，此时几个指针的指向已经发生改变，需要重新指向头指针，遍历找到需要插入的结点

temp = *Head;   

for(int i = 0; i < pos - 1; i++)                //定位到要删除的结点的前一个结点

{

temp = temp->next;

}

new_node->data = x;                            //给新结点的数据域赋值

new_node->next = temp->next;     

                   //第一步：首先让新结点指向要插入的位置，也就是当前结点的前一个结点保存的位置

temp->next = new_node;        //  第二步：让当前结点的前一个结点指向指向新结点

}

}

return TRUE;

}

---

---

头删：对与删除操作，与插入操作类比，不在画图，两者是类同的。

---

//不带头结点的头删，需要考虑链表是否为空链表，或者或一个元素的时候，当只有一个元素的时候，头删除就需要，修改头指针的指向，其他地方的删除，顺序都一样，用x放回删除的数据

//删除成功返回TRUE，失败返回FALSE

Status Delite_No_Head_SeqNode(LinkList *Head,ElemType *x)

{

LinkList temp_node = (*Head);            //防止头指针被修改

if(NULL == temp_node)

{

printf("链表已空，已经没有元素可以删除了\n");

return FALSE;

}

if(NULL == temp_node->next)

{

*x = temp_node->data;            //把要删除的结点的值保存的x中去

(*Head) = NULL;

free(temp_node);                //释放删除的结点，防止内存泄露

            temp_node = NULL; 

                return TRUE;

}

else                                  //处理链表中有一个以上的结点的删除

{

*x = temp_node->data;               //把要删除的结点的值保存的x中去

*Head = temp_node->next;             //修该头指针的指向

free(temp_node);               //释放删除的结点，防止内存泄露

temp_node = NULL;  

                return TRUE;

}

}

//带头结点的头删，不论是有一个元素还是多和元素，删除操作都不需要修该头指针指向，因而也就不需要修该头指针指向，用x放回删除的数据

//删除成功返回TRUE，失败返回FALSE；

Status Delite_Head_Fr_SeqList(LinkList Head,ElemType *x)

{

LinkList temp = Head->next;        //定义临时变量防止头指针被修改

if(NULL == temp->next)

{

printf("链表已空，已经没有元素删除\n");

return FALSE;

}

*x = temp->next->data;            //把要删除的结点的值保存的x中去

temp = temp->next;                //第一步：让临时结点指向要删除的结点的下一个结点

free(Head->next);               //第二步：释放首元结点的内存，防止内存泄露

Head->next = temp;              //第三步：修改头指针的指向

return TRUE;

}

---

---

尾删：同样也不在给出示意图：对比尾插的图。

---

---

//带头结点的尾删，因为有头结点所有操作都一样

Status Delite_Head_Br_SeqNode(LinkList Head,ElemType *x)

{

//定义临时变量防止头指针被修改  ,首先让指向首元结点,尾删用它来定位最后一个结点，

//由于单链表，只知道当前节点的下一个结点的位置，那么，就需要定义一个变量保存当前结点的地址 

LinkList temp = Head->next;          //定位最后一个指针    

LinkList temp_node_pre = Head;        //保存最后一个结点的地址

if(NULL == temp)

{

printf("链表已空，已经没有元素删除\n");

return FALSE;

}

while(NULL != temp->next)

{

temp = temp->next;

temp_node_pre = temp_node_pre->next;

}

*x = temp->data;                      //保存最后一个结点的数据域的值

temp_node_pre->next = NULL;                 //修改原来结点的倒数第二个结点的指向

free(temp);           //此时temp_node指向最后一个结点，防止内存泄露，释放最后一个结点的内存

temp =NULL;

return TRUE;

}

//不带头结点的尾删，由于当链表只有一个元素时，删除最后一个结点就要修改指针指向，因而就要用二级指针接收头指针，用x放回删除的数据

//删除成功返回TRUE，失败返回FALSE；

Status Delite_No_Head_Br_SeqNode(LinkList *Head,ElemType *x)

{

//定义临时变量防止头指针被修改  ,首先让指向首元结点,尾删用它来定位最后一个结点，

//由于单链表，只知道当前节点的下一个结点的位置，那么，就需要定义一个变量保存当前结点的地址 

LinkList temp_node = (*Head)->next;

LinkList  temp_node_pre = (*Head);

if(NULL == (*Head))

{

printf("链表已空，已无元素可以删除\n");

return FALSE;

}

while(NULL != temp_node->next)

{

temp_node = temp_node->next;

temp_node_pre = temp_node_pre->next;

}

*x = temp_node->data;                        //保存最后一个结点的数据域的值

temp_node_pre->next = NULL;                 //修改原来结点的倒数第二个结点的指向

free(temp_node);      //此时temp_node指向最后一个结点，防止内存泄露，释放最后一个结点的内存

return TRUE;

}

//带头结点的按照位置删除，首先要考虑删除的位置是否存在，然后由于带头结点，所以无论是一个元素，还是多个元素删除操作都一样

Status Delite_Head_Pos_SeqNode(LinkList Head,int pos, ElemType *x)

{

//定义临时变量防止头指针被修改  ,首先让指向首元结点,尾删用它来定位最后一个结点，

//由于单链表，只知道当前节点的下一个结点的位置，那么，就需要定义一个变量保存当前结点的地址 

LinkList temp = Head->next;     //定位最后一个指针需要删除的结点的前一个结点    

LinkList temp_node_pre = Head;        //保存即将删除的结点的地址

if(NULL == temp)

{

printf("链表已空，已经没有元素删除\n");

return FALSE;

}

if(pos > temp_node_pre->data )                  //判断删除的位置是否存在

{

printf("删除位置出错\n");

return FALSE;

}

for(int i = 0; i < pos-1;i++)                  //遍历链表找到链表要删除的结点的前一个结点

{

temp = temp->next;                      //定位要删除的位置

}

*x = temp->next->data;                          //用x返回需要删除结点的值

temp_node_pre = temp->next;

temp->next = temp->next->next;                   //让删除的前一个结点指向要删除的下一个结点

free(temp_node_pre);                     //此时temp_node指向删除的结点，防止空间泄露，释放内存

temp_node_pre = NULL;

Head->data--;                                    //头结点保存着链表的长度，删除以后减去一个

return TRUE;

}

---

---

按照位置删除：同样也不在给出示意图：对比按照位置删除的图。

---

---

//不带头结点按照位置删除，由于当只有一个结点的删除需要修改头指针指向需要特别处理

Status Delite_No_Head_Pos_SeqNode(LinkList *Head, int pos, ElemType *x)

{

int NUM = 0;                //统计一共链表一共多少个结点

//定义临时变量防止头指针被修改  ,首先让指向首元结点,尾删用它来定位最后一个结点，

//由于单链表，只知道当前节点的下一个结点的位置，那么，就需要定义一个变量保存当前结点的地址 

LinkList temp = (*Head);

if(NULL == temp)

{

printf("链表已空，已无元素可以删除\n");

return FALSE;

}

else if(NULL == temp->next)        //处理只有一个结点的情况

{

*x = temp->data;          //用x返回需要删除结点的值

(*Head) = NULL;                    //头结点置空

free(temp);                 //释放第一个结点的空间，防止内存泄露

temp = NULL;                   //防止指向非法空间

return TRUE;

}

else

{

while(NULL != temp)

{

NUM++;

temp = temp->next;

}

if(pos > NUM)

{

printf("删除位置出错");

return FALSE;

}

if(0 == pos)

{

temp = *Head;  

*x = temp->data;

*Head = temp->next;

free(temp);

temp = NULL;

}

else

{

//当遍历确定pos位置正确后，此时几个指针的指向已经发生改变，需要重新指向头指针，遍历找到需要插入的结点

temp = *Head;   

for(int i = 0; i < pos-1; i++)

{

temp = temp->next;

}

*x = temp->next->data;                     //用x返回需要删除结点的值

LinkList free_node = temp->next;           //free_node用与保存即将删除的结点

temp->next = temp->next->next; 

free(free_node);                       //释放第一个结点的空间，防止内存泄露

free_node = NULL;

}

}

return TRUE;

}

---

---

打印输出所有数据：

---

---

//带头结点打印输出所有数据

Status Show_Node(LinkList Head)

{

LinkList temp = Head->next;

while(NULL != temp)

{

printf("%d  ",temp->data);

temp = temp->next;

}

printf("\n");

return TRUE;

}

//不带头结点打印输出所有数据

Status Show_Node_No_Head(LinkList Head)

{

LinkList temp = Head;

while(NULL != temp)

{

printf("%d  ",temp->data);

temp = temp->next;

}

printf("\n");

return TRUE;

}

---

---

清空链表：释放所有有效结点，对于带头结点链表，要把头结点的 数据域置0

---

---

//不带头结点的清空链表，释放所有的结点

Status Clean_No_Head_SeqNode(LinkList *Head )

{

LinkList temp_node = *Head;

LinkList temp_node_pre = *Head;

*Head = NULL;

while(NULL != temp_node)

{

temp_node = temp_node->next;        //因为头结点不空，让临时指针指向下一个结点

free(temp_node_pre);               //释放第一结点的空间

temp_node_pre = temp_node;         //指向下一个空间

}

return TRUE;

}

//带头结点的清空链表，释放除头结点以外的空间

Status Clean_Head_SeqNode(LinkList Head)

{

LinkList temp_node = Head->next;

LinkList temp_node_pre = Head->next;

Head->next = NULL;

Head->data = 0;

while(NULL != temp_node->next)

{

temp_node = temp_node->next;

free(temp_node_pre);

temp_node_pre = temp_node;

}

return TRUE;

}

---

---

排序：对于排序，首先可以采用各种排序方法，然后就是排序过程中，我提一点就是只需要把值交换并不需要交换结点。这里采用冒泡排序。

---

---

//排序，由于只需要交换两个链表中的值就好了，不用修改指针指向所以带与不带头结点操作差不多,只是有细微的差别

Status Sort_No_Head_SeqNode(LinkList Head)

{

LinkList temp_node_i = Head;

LinkList temp_node_j = Head;

LinkList temp_node_pre = Head;

ElemType temp;                        //用与交换值

if(NULL == temp_node_i)

{

printf("链表为空，无法排序\n");

return FALSE;

}

for(temp_node_i = temp_node_i->next; NULL != temp_node_i; temp_node_i = temp_node_i->next)

{

for( temp_node_j = temp_node_j; NULL != temp_node_j;  temp_node_j = temp_node_j->next)

{

if(temp_node_j->data > temp_node_pre->data)

{

temp = temp_node_j->data;

temp_node_j->data = temp_node_pre->data;

temp_node_pre->data = temp;

temp_node_pre = temp_node_pre->next;

}

temp_node_pre = temp_node_pre->next;

}

}

return TRUE;

}

//排序带头结点

Status Sort_Head_SeqNode(LinkList Head)

{

LinkList temp_node_i = Head->next;

LinkList temp_node_j = Head->next;

LinkList temp_node_pre = Head->next;

ElemType temp;                                              //用与交换值

if(NULL == temp_node_i)

{

printf("链表为空，无法排序\n");

return FALSE;

}

for(temp_node_i = temp_node_i; NULL != temp_node_i->next; temp_node_i = temp_node_i->next)

{

for(temp_node_j = Head; NULL != temp_node_j->next; temp_node_j = temp_node_j->next)

{

if(temp_node_j->data > temp_node_j->next->data)

{

temp = temp_node_j->next->data;

temp_node_j->next->data = temp_node_j->data;

temp_node_j->data = temp;

}

}

}

return TRUE;

}

---

---

    以上对单链表带头结点与不带头结点的头插、尾插、按照位置插、头删、尾删、按照位置删除、清空链表、排序、打印输出做了尽可能详尽的注释，都做了测试，但是没有给出主函数，数据结构中，这里不是重点，并且限于篇幅，因而没有给出主函数。当然以上代码只是我的理解，大家可以如果发现那块有错误，希望指正。

---

    最后，细心的大家会发现这里边有好多重发的代码：比如生成新结点，定位要插入删除的位置，有好多重复的代码，那么就可以把它写成一个函数，简化代码，更有，这种结构的结构体，操作起来有些不方便，如果采用下边这种结构，更会简化，并且便于理解。

---

typedef struct node  //节点类型

{

type value;

struct node *next;

}Node;

typedef struct list

{

Node *phead;

Node *ptail;

}List;

感谢各位的阅读，以上就是“c语言线性表的链式存储结构是什么”的内容了，经过本文的学习后，相信大家对c语言线性表的链式存储结构是什么这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是创新互联，小编将为大家推送更多相关知识点的文章，欢迎关注！

本文名称：c语言线性表的链式存储结构是什么
路径分享：http://myzitong.com/article/ijdidh.html