码迷,mamicode.com
首页 > 其他好文 > 详细

线性表的链式存储(C代码实现)

时间:2019-01-21 19:13:47      阅读:199      评论:0      收藏:0      [点我收藏+]

标签:let   tle   create   std   修改   onclick   init   初始   def   

线性表的链式存储结构

线性表的实现分顺序存储结构链式存储结构。

上一节我们学学习了线性表的实现分顺序存储结构,并实现解顺序存储的基本操作。

这一节我们来学习线性表链式存储结构,那我们再想象一下我为什么我们要引入链式存储结构,万物存在必有其道理

主要还是因为线性存储结构存在着这样一个问题:当我们需要插入和删除元素时,就必须挪动大量与之无关的元素,因为线性存储结构结点与节点之间的关系是相邻关系,一个节点挨着一个节点

如为了插入或者删除一个元素移动大量的元素,这样就降低了程序运行效率。

当我们引入

顾名思义链式存储结构,数据与数据之间是以链式关系来产生连接的的,我们可以脑部一下锁链的样子,不扯淡了,进入正题--

我们如何定义一个链式存储结构的节点呢?

/*Node表示一个节点*/
typedef struct Node{
    int data;   //数据域
    struct Node* next;   //存放下一个节点的指针
}Node;
typedef struct Node* LinkList; /*取了一个别名,定义LinkList = Node*,用于存放节点的指针*/

一个节点包括一个数据域和指针域

技术分享图片

我们将这种只带有一个指针域的线性表称为单链表

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

单链表的第一个结点前附设一个结点,称为头结点

注意可以没有头节点,但是要是链表,就一定存在头指针。

 那么问题来了,我们如何区分头节点和头指针呢?

头指针:是指向链表的指针,如果不存在头节点,那么头指针就会指向链表的第一个节点。

头节点:实际上是不存在的,只不过是为了链表的一些操作方便而设置的,头节点与第一个节点以链式关系相连,并且头节点的数据域没有意义,指针域存放第一个节点的地址。

 技术分享图片

单链表的插入

技术分享图片

s->next =p->next;
p->next=s;    //注意前后顺序不能调

单链表的删除

技术分享图片

q= p->next;
p->next = q->next;
free(q);

单链表的建表(头插法)

技术分享图片

顾名思义直接插在第一位,就是头节点的后面。

 1 void CreateListHead(LinkList *L,int n){
 2 
 3     LinkList p;
 4     *L = (Node*)malloc(sizeof(Node));  //生成的新节点节点要初始化
 5     (*L)->next=NULL;    //并指向空
 6 
 7     for(int i=0;i<n;i++){
 8         p =(Node*)malloc(sizeof(Node)); //新生成的节点节点要初始化
 9         p->data=i;
10         p->next=(*L)->next;  //这里不能指向NULL
11         (*L)->next =p;   //两级指针
12     }
13 }

单链表的建表(尾插法)

 1 void CreateListTail(LinkList *L ,int n){
 2 
 3     LinkList p,r;   //生成节点p,存放Node地址
 4     *L = (Node*)malloc(sizeof(Node));  //生成的头节点节点要初始化
 5     (*L)->next=NULL;
 6     r = *L;  //用于遍历
 7 
 8     for(int i=0;i<n;i++){
 9         p =(Node*)malloc(sizeof(Node)); //新生成的节点节点要初始化
10         p->data=i;
11         r->next=p;
12         r=p;  //r指针移动到p上r ,以便
13     }
14     r->next=NULL; //最后一个指向空
15 }

单链表的遍历

1 void TraverseList(LinkList L){
2     LinkList p;
3     p = L->next;
4     while(p){
5         printf("%d ",p->data);
6          p=p->next;
7     }
8 }

清空单链表

 1 /*清空链表*/
 2 void ClearList(LinkList L){
 3     LinkList p ,q;
 4     p = L->next;     //指向第一个元素
 5     while(p){
 6         q=p->next;  //q指向了p的下一个
 7         free(p);   //释放内存
 8         p =q;
 9     }
10     L->next =NULL;     //头节点指向空
11 }

其它的一下操作见下面代码吧

技术分享图片
  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "time.h"
  4 
  5 /*Node表示一个节点*/
  6 typedef struct Node{
  7     int data;
  8     struct Node* next;
  9 }Node;
 10 typedef struct Node* LinkList; /*定义LinkList*/
 11 
 12 /*初始化链表*/
 13 int InitList(LinkList *L){    
 14     *L=(LinkList)malloc(sizeof(Node));  //这里的*L就是Node节点的指针对象
 15     if(!(*L))   //申请内存失败
 16         return 0;
 17     (*L)->next=NULL;
 18     return 1;
 19 }
 20 
 21 //头插法,n表示插入的个数
 22 void CreateListHead(LinkList *L,int n){
 23 
 24     LinkList p;
 25     *L = (Node*)malloc(sizeof(Node));  //生成的新节点节点要初始化
 26     (*L)->next=NULL;    //并指向空
 27 
 28     for(int i=0;i<n;i++){
 29         p =(Node*)malloc(sizeof(Node)); //新生成的节点节点要初始化
 30         p->data=i;
 31         p->next=(*L)->next;  //这里不能指向NULL
 32         (*L)->next =p;   //两级指针
 33     }
 34 }
 35 //尾插法,n表示插入的个数
 36 void CreateListTail(LinkList *L ,int n){
 37 
 38     LinkList p,r;   //生成节点p,存放Node地址
 39     *L = (Node*)malloc(sizeof(Node));  //生成的头节点节点要初始化
 40     (*L)->next=NULL;
 41     r = *L;  //用于遍历
 42 
 43     for(int i=0;i<n;i++){
 44         p =(Node*)malloc(sizeof(Node)); //新生成的节点节点要初始化
 45         p->data=i;
 46         r->next=p;
 47         r=p;  //r指针移动到p上r ,以便
 48     }
 49     r->next=NULL; //最后一个指向空
 50 }
 51 
 52 /*遍历链表*/
 53 void TraverseList(LinkList L){
 54     LinkList p;
 55     p = L->next;
 56     while(p){
 57         printf("%d ",p->data);
 58          p=p->next;
 59     }
 60 }
 61 
 62 /*清空链表*/
 63 void ClearList(LinkList L){
 64     LinkList p ,q;
 65     p = L->next;     //指向第一个元素
 66     while(p){
 67         q=p->next;  //q指向了p的下一个
 68         free(p);   //释放内存
 69         p =q;
 70     }
 71     L->next =NULL;     //头节点指向空
 72 }
 73 
 74 /*获取链表长度*/
 75 int GetLengthList(LinkList L){
 76     LinkList p;
 77     p=L->next;
 78     int count=0;   //计数器
 79     while(p){
 80         count++;
 81         p= p ->next;    
 82     }
 83     return count;
 84 
 85 }
 86 
 87 /*删除元素*/
 88 void DeleteElem(LinkList L,int n){
 89     int count=0;
 90     LinkList p ,q;
 91     p =L;   //注意这里的p不在指向第一个节点了
 92     count =1; 
 93     while(p->next && count<n){  //
 94         p =p->next;
 95         ++count;
 96     }
 97     if(!(p->next) || count>n)
 98         printf("没有找到可删除的元素");
 99     q= p->next;
100     p->next = q->next;
101      free(q);
102 }
103 
104 /*插入元素 n是位置,c是数*/
105 void InsertElemList(LinkList L,int n,int c){
106 
107     int count=0;
108     LinkList p,s;
109     p =L;   //注意这里的p不在指向第一个节点了
110     count =1; 
111     while(p->next && count<n){  //
112         p =p->next;
113         ++count;
114     }
115     s =(Node*)malloc(sizeof(Node));
116     s->data=c;
117     s->next =p->next;
118     p->next=s;
119 
120 }
121 
122 /* 初始条件:顺序线性表L已存在 */
123 /* 操作结果:返回L中第1个与e满足关系的数据元素的位序。 */
124 /* 若这样的数据元素不存在,则返回值为0 */
125 int LocateElem(LinkList L,int e){
126 
127     LinkList p;
128     p =L->next;
129     while(p){
130         if(p->data == e)
131             return 1;
132         p =p->next;
133     }
134     return 0;
135 }
136 
137 /*获取元素,n表示第几个,并返回查到的值*/
138 int GetElem(LinkList L,int n){
139 
140     LinkList p;   //生成节点p,存放Node地址
141     p = L->next;   //p指向第一个元素
142     int count=1;   //计数器
143 
144     while(p && count<n){ //查找
145         p = p->next;
146         count++;
147     }
148     if(!p || count>n){ //没找到
149         return 0;
150     }    
151     int ret = p->data;    //找到
152     return ret;
153 }
154 
155 /*判断链表是否为空*/
156 int ListElmpty(LinkList L){
157 
158     if(L->next){
159         return 0;
160     }else{
161         return 1;
162     }
163 }
164 
165 int main(){
166     LinkList L1;   //创建一个节点,用于头插法
167     LinkList L2;   //创建一个节点,用于尾插法
168 
169     printf("......头插法......\n");
170     InitList(&L1);  //初始化
171     CreateListHead(&L1,5);
172     TraverseList(L1);
173     printf("\n");
174 
175     printf("......尾插法......\n");
176     InitList(&L2);  //初始化
177     CreateListTail(&L2,5);
178     TraverseList(L2);
179     printf("\n");
180 
181     //获取元素的值
182     int getElem= GetElem(L2,3);
183     printf("%d \n",getElem);
184 
185     //获取长度
186     int GetLength=GetLengthList(L2);
187     printf("L1链表的长度:%d",GetLength);
188     printf("\n");
189 
190     //删除L1中2号元素
191     printf("删除L1中2号元素:");
192     DeleteElem(L1,2);
193     TraverseList(L1);
194     printf("\n");
195 
196     //在第三个位置插入11
197     printf("在第三个位置插入11元素:");
198     InsertElemList(L1,3,11);
199     TraverseList(L1);
200     printf("\n");
201 
202     int localFind=LocateElem(L1,11);
203     printf("找到了吗: %d\nd",localFind);
204 
205     //判断L1是否为空
206     int lstElempty=ListElmpty(L1);
207     printf("L1为空吗: %d\n",lstElempty);
208     //清空L1
209     ClearList(L1);
210     //在判断L1是否为空
211     lstElempty=ListElmpty(L1);
212     printf("L1为空吗: %d\n",lstElempty);
213 
214     return 0;
215 }
View Code

技术分享图片

 

写完插入和删除操作,我们便可以看出,链式存储结构对于插入和删除的优势是明显的,不需要进行大量的元素的移动。

当然单链表这么个优秀,也是存在缺点的

缺点就是其不便于进行查找和修改,每查找或者修改一个元素就要开始从头开始遍历  - -这么坑爹的吗 ?没错 就是这么坑爹 - -

所以当我们应用的场合不同 ,就用不同的存储结构。

线性表的链式存储(C代码实现)

标签:let   tle   create   std   修改   onclick   init   初始   def   

原文地址:https://www.cnblogs.com/liuzeyu12a/p/10300110.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!