线性表的插入和删除操作代码(C语言)

Posted 2023-05-15

新建一个线性表,插入一个元素和删除一个元素.怎样实现

参考技术A 给个实例给你看看吧
#include<stdio.h>
#include<stdlib.h>

struct node

int data;
struct node* pNext;
;

struct node* create()

struct node* pHead = NULL;
struct node* pTail = NULL;
struct node* pNode = NULL;
int x=0;
printf("\n请输入一个整数:");
scanf("%d",&x);
while(x!=0)

pNode = (struct node*)malloc(sizeof(struct node));
pNode->data = x;
pNode->pNext = NULL;
if (pHead==NULL)

pHead = pTail = pNode;

else

pTail->pNext = pNode;
pTail = pNode;

printf("\n请输入一个整数:");
scanf("%d",&x);

return (pHead);


void main(void)

struct node* qNode = NULL;
qNode = create();
printf("The data of link:\n");
while (qNode!=NULL)

printf("%d\t",qNode->data);
qNode = qNode->pNext;

printf("\n");
参考技术B #include<stdio.h>#define MAXSIZE 10#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -1typedef structint elem[MAXSIZE];int length;SeqList;void init_SeqList(SeqList *l)l->length=0;/*顺序表初始化*/int Insert_SeqList(SeqList *l,int i,int x)int j; if(l->length==MAXSIZE-1) printf("表满"); return OVERFLOW; if(i<1||i>l->length+1) printf("位置错"); return ERROR; for(j=l->length;j>=i;j--) l->elem[j+1]=l->elem[j]; l->elem[i]=x; l->length++; return OK;/*顺序表插入*/int Delete_SeqList(SeqList *l,int i)int j; if(i<1||i>l->length) printf("不存在第%d个元素",i); return ERROR; for(j=i;j<=l->length-1;j++) l->elem[j]=l->elem[j+1]; l->length--; return OK;/*删除操作*/int Location_SeqList(SeqList *l,int x)int i=1; while(i<=l->length&&l->elem[i]!=x) i++; if(i>l->length) return -1; else return i;void Create_SeqList(SeqList *l)int i,n,m; printf("输入表的长度:\n"); scanf("%d",&n); l->length=n; printf("请输入数值:\n"); for(i=1;i<=n;i++) scanf("%d",&m); l->elem[i]=m; void Print_SL(SeqList *l) int i; printf("The List is:\n"); for(i=1;i<=l->length;i++) printf("%3d",l->elem[i]); void main()SeqList a; int i,x,ch; init_SeqList(&a); Create_SeqList(&a); printf("请选择:1.插入 2.删除: "); scanf("%d",&ch); switch(ch) case 1:printf("请输入位置和数值:\n"); scanf("%d%d",&i,&x); Insert_SeqList(&a,i,x); break; case 2:printf("请输入要删除的位置\n"); scanf("%d",&i); Delete_SeqList(&a,i); break; default: exit(0); Print_SL(&a);下面是我的百度贴吧，里面有一些数据结构算法用C实现的代码: http://tieba.baidu.com/f?ct=&tn=&rn=&pn=&lm=&kw=%C4%AB%BD%B3&rs2=0&myselectvalue=1&word=%C4%AB%BD%B3&submit=%B0%D9%B6%C8%D2%BB%CF%C2&tb=on 参考技术C 都是课本上的东西！！！ 好好看看C语言和数据结构 参考技术D 顺序表还是链表？

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

线性表的链式存储结构

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

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

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

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

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

当我们引入

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

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

/*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("......头插法......
");
170     InitList(&L1);  //初始化
171     CreateListHead(&L1,5);
172     TraverseList(L1);
173     printf("
");
174 
175     printf("......尾插法......
");
176     InitList(&L2);  //初始化
177     CreateListTail(&L2,5);
178     TraverseList(L2);
179     printf("
");
180 
181     //获取元素的值
182     int getElem= GetElem(L2,3);
183     printf("%d 
",getElem);
184 
185     //获取长度
186     int GetLength=GetLengthList(L2);
187     printf("L1链表的长度：%d",GetLength);
188     printf("
");
189 
190     //删除L1中2号元素
191     printf("删除L1中2号元素:");
192     DeleteElem(L1,2);
193     TraverseList(L1);
194     printf("
");
195 
196     //在第三个位置插入11
197     printf("在第三个位置插入11元素:");
198     InsertElemList(L1,3,11);
199     TraverseList(L1);
200     printf("
");
201 
202     int localFind=LocateElem(L1,11);
203     printf("找到了吗： %d
d",localFind);
204 
205     //判断L1是否为空
206     int lstElempty=ListElmpty(L1);
207     printf("L1为空吗： %d
",lstElempty);
208     //清空L1
209     ClearList(L1);
210     //在判断L1是否为空
211     lstElempty=ListElmpty(L1);
212     printf("L1为空吗： %d
",lstElempty);
213 
214     return 0;
215 }

View Code

 

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

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

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

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