数据结构——顺序表的初始化、插入、删除、查找、合并

最新推荐文章于 2024-04-23 20:25:12 发布
最新推荐文章于 2024-04-23 20:25:12 发布
阅读量3w 收藏 287
点赞数 59
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TSY_1222/article/details/101301882
版权

     目录

1、顺序表初始化

2、顺序表插入元素

3、顺序表删除元素

4、顺序表查找元素

5、顺序表合并

线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。

顺序存储方式不仅只用于存储线性结构。

特点优点缺点

逻辑上相邻的数据元素物理存储位置也相邻，

并且顺序表的存储空间需要预先分配

1、方法简单，各级高中语言中都有数组，容易实现。

2、存储空间使用紧凑。

3、任一元素均可随机访问。

4、存储密度大。

1、插入和删除元素需要移动大量地元素，效率低。

2、表容量难以扩充。

3、预先分配空间需按最大空间分配，估计过大，

可能会导致顺序表后部大量闲置；估计过小，又会造成溢出。

//-------------------------线性表的动态分配顺序存储结构-------------------------//

#define LIST_INIT_SIZE 100  //线性表存储空间的初始分配量
#define LISTINCREMENT 10  //线性表存储空间的分配增量
typedef  struct{
	ElemType *elem;     //存储空间基址
	int length;       //当前长度 
	int listsize;     //当前分配的存储容量(以sizeof(ElemType)为单位) 
}SqList;

在上述定义中，数组指针elem指示线性表的基地址；length指示线性表的当前长度；listsize指示顺序表当前分配的存储空间的大小，一旦因插入元素而空间不足时，可进行再分配，即为顺序表增加一个大小为存储LISTINCREMENT个数据元素的空间。

1、顺序表初始化

顺序表的初始化操作就是为顺序表分配一个预定义大小的数组空间，并将线性表的当前长度设为“0”。

#include<stdio.h>
#include<malloc.h>
#define LIST_INIT_SIZE 100  //线性表存储空间的初始分配量
#define LISTINCREMENT 10  //线性表存储空间的分配增量
typedef  struct{
	int *elem;     //存储空间基址
	int length;       //当前长度 
	int listsize;     //当前分配的存储容量(以sizeof(ElemType)为单位) 
}SqList;

int InitList_Sq(SqList *L)
{
	L->elem = (int *)malloc(LIST_INIT_SIZE * sizeof(int));  //构造一个空的线性表L
	if(!L->elem)
	{
		return -1;   //存储分配失败(申请失败) 
	}
	L->length = 0;   //空表长度为 0 
	L->listsize = LIST_INIT_SIZE;   //初始存储容量
	return 1; 
}

int main()
{
	SqList L;   //声明一个顺序表
	InitList_Sq(&L);   //初始化
	for(int i=0; i<10; i++)   //将顺序表的前10个单元赋值为0~9, 
	{
		L.elem[i] = i;
		L.length++;
		printf("%d ", L.elem[i]);	
	} 
}


'''
结果：
0 1 2 3 4 5 6 7 8 9
'''

2、顺序表插入元素

在顺序存储结构中，插入和删除元素，需要大量地移动元素，所有效率低。

在顺序表插入和删除元素，最主要的操作时移动元素。

要在第 i (1<=i<=n)个元素之前插入元素，共n-i+1个元素依次向后移一个位置。

插入下标位置 i012···i···n-1n
移动次数nn-1n-1···n-i···10

若长度为n的线性表采用顺序存储结构，在其第 i 个位置插入一个新元素的算法时间复杂度为O(n)

若i = n，算法时间复杂度为O(1)

#include<stdio.h>
#include<malloc.h>
#define LIST_INIT_SIZE 100  //线性表存储空间的初始分配量
#define LISTINCREMENT 10  //线性表存储空间的分配增量
typedef  struct{
	int *elem;     //存储空间基址
	int length;       //当前长度 
	int listsize;     //当前分配的存储容量(以sizeof(ElemType)为单位) 
}SqList;

int InitList_Sq(SqList *L)
{
	L->elem = (int *)malloc(LIST_INIT_SIZE * sizeof(int));  //构造一个空的线性表L
	if(!L->elem)
	{
		return -1;   //存储分配失败(申请失败) 
	}
	L->length = 0;   //空表长度为 0 
	L->listsize = LIST_INIT_SIZE;   //初始存储容量
	return 1; 
}

int ListInsert_Sq(SqList *L, int i, int e)  //在顺序表的第i个位置插入元素e 
{
	//i的范围区间[1, ListLength_Sq(L)+1] 
	if(i<1 || i>L->length+1)
	{
		return -1;	 //i的值不合法 
	}
	if(L->length >= L->listsize)  //存储空间=分配空间,空间已满，增加分配 
	{
		int *newbase = (int *)realloc(L->elem, (L->listsize+LISTINCREMENT) * sizeof(int));
		if(!newbase)
		{
			return -1;    //存储分配失败	
		} 
		L->elem = newbase;   //新基址
		L->listsize += LISTINCREMENT;  //增加存储容量 
	}
	int *q = &(L->elem[i-1]);  //q为插入的位置
	for (int *p=&(L->elem[L->length-1]); p>=q; --p)  //p为最后一个位置，用来移动元素 
	{
		*(p+1) = *p;	  //插入位置及之后的元素右移 
	} 
	*q = e;   //插入元素e
	++L->length;   //表长增1
	return 1;
}

int main()
{
	SqList L;   //声明一个顺序表
	InitList_Sq(&L);  //初始化
	for(int i=1; i<=10; i++)  //空表中，逐个插入1~10
	{
		ListInsert_Sq(&L, i, i);
	} 
	for(int i=0; i<10; i++)   //遍历、打印 
	{
		printf("%d ", L.elem[i]);
	}
}

'''
结果：
1 2 3 4 5 6 7 8 9 10
'''

3、顺序表删除元素

删除下标位置 i012···i···n-2n-1
移动次数n-1n-2n-3···n-i+1···10

若长度为n的线性表采用顺序存储结构，在其第 i 个位置删除一个元素的算法时间复杂度为O(n)

若i = n-1，算法时间复杂度为O(1)

#include<stdio.h>
#include<malloc.h>
#define LIST_INIT_SIZE 100  //线性表存储空间的初始分配量
#define LISTINCREMENT 10  //线性表存储空间的分配增量
typedef  struct{
	int *elem;     //存储空间基址
	int length;       //当前长度 
	int listsize;     //当前分配的存储容量(以sizeof(ElemType)为单位) 
}SqList;

int InitList_Sq(SqList *L)
{
	L->elem = (int *)malloc(LIST_INIT_SIZE * sizeof(int));  //构造一个空的线性表L
	if(!L->elem)
	{
		return -1;   //存储分配失败(申请失败) 
	}
	L->length = 0;   //空表长度为 0 
	L->listsize = LIST_INIT_SIZE;   //初始存储容量
	return 1; 
}

int ListDelete_Sq(SqList *L, int i, int *e)  //在顺序表L中删除第i个元素，用e返回其值
{
	//i的范围区间[1, ListLength_Sq(L)+1]
	if(i<1 || i>L->length)
	{
		return -1;	 //i值不合法 
	} 
	int *p = &(L->elem[i-1]);  //指针p指向被删除元素的位置 
	*e = *p;   //被删除的元素赋值给e
	int *q = &(L->elem[L->length-1]);   //指针p指向表尾元素的位置 
	for(++p; p<=q; ++p) 
	{
		*(p-1) = *p;   //被删除元素之后的元素左移 
	}
	--L->length;   //表长减1 
	return 1;
}

int main()
{
	SqList L;    //声明一个顺序表
	InitList_Sq(&L);    //初始化
	for(int i=0; i<10; i++)
	{
		L.elem[i] = i;  //空表中，逐个赋值0~9
		printf("%d ", L.elem[i]);
		L.length++;
	}
	printf("\n");
	int e = 0;
	ListDelete_Sq(&L, 6, &e);
	printf("被删除的元素是：%d\n", e);
	printf("删除后的顺序表：");
	for(int i=0; i<9; i++)
	{
		printf("%d ", L.elem[i]);	
	} 
}

结果：

4、顺序表查找元素

（查找线性表中给定值key的位序）

#include<stdio.h>
#include<malloc.h>
#define LIST_INIT_SIZE 100  //线性表存储空间的初始分配量
#define LISTINCREMENT 10  //线性表存储空间的分配增量
typedef  struct{
	int *elem;     //存储空间基址
	int length;       //当前长度 
	int listsize;     //当前分配的存储容量(以sizeof(ElemType)为单位) 
}SqList;

int InitList_Sq(SqList *L)
{
	L->elem = (int *)malloc(LIST_INIT_SIZE * sizeof(int));  //构造一个空的线性表L
	if(!L->elem)
	{
		return -1;   //存储分配失败(申请失败) 
	}
	L->length = 0;   //空表长度为 0 
	L->listsize = LIST_INIT_SIZE;   //初始存储容量
	return 1; 
}

int LocateElem_Sq(SqList *L, int key)   //在顺序表L中查找key的位序 
{
	int i=1;
	int *p = &(L->elem[0]);   //指针p指向表头的位置
	while(i<=L->length && (*p!=key)) 
	{
		p++;
		i++; 
	}
	if(i < L->length)
		return i;   //返回key的位序  
	else
		return 0;   //未找到 
}

int main()
{
	SqList L;    //声明一个顺序表
	InitList_Sq(&L);    //初始化
	for(int i=0; i<10; i++)
	{
		L.elem[i] = i;  //空表中，逐个赋值0~9
		printf("%d ", L.elem[i]);
		L.length++;
	}
	printf("\n"); 
	int key = 5;
	printf("被查找的元素是：%d\n", key);
	printf("被查找元素的位序是：%d\n", LocateElem_Sq(&L, key));
}

结果：

 

5、顺序表合并

#include<stdio.h>
#include<malloc.h>
#define LIST_INIT_SIZE 100  //线性表存储空间的初始分配量
#define LISTINCREMENT 10  //线性表存储空间的分配增量
typedef  struct{
	int *elem;     //存储空间基址
	int length;       //当前长度 
	int listsize;     //当前分配的存储容量(以sizeof(ElemType)为单位) 
}SqList;

int InitList_Sq(SqList *L)
{
	L->elem = (int *)malloc(LIST_INIT_SIZE * sizeof(int));  //构造一个空的线性表L
	if(!L->elem)
	{
		return -1;   //存储分配失败(申请失败) 
	}
	L->length = 0;   //空表长度为 0 
	L->listsize = LIST_INIT_SIZE;   //初始存储容量
	return 1; 
}

//线性表La、Lb中元素按值非递减排列，La、Lb合并为新线性表Lc，Lc中元素也是按值非递减排列。 
int MergeList_Sq(SqList *La, SqList *Lb, SqList *Lc)
{
	int *pa = &(La->elem[0]);   //指针pa指向La表头的位置 
	int *pb = &(Lb->elem[0]);   //指针pb指向Lb表头的位置 
	Lc->listsize = Lc->length = La->length+Lb->length;  //初始化Lc 
	int *pc = Lc->elem = (int *)malloc(Lc->listsize*sizeof(int));  //给Lc分配空间
	if(!Lc->elem)
	{
		return -1;   //存储分配失败(申请失败) 
	}
	int *pa_last = &(La->elem[La->length-1]);    //指针pa_last指向La表尾的位置 
	int *pb_last = &(Lb->elem[Lb->length-1]);    //指针pb_last指向Lb表尾的位置
	while(pa<=pa_last && pb<=pb_last)   //归并 
	{
		if(*pa <= *pb)
		{
			*pc = *pa;
			pc++;
			pa++;
		}
		else
		{
			*pc = *pb;
			pc++;
			pb++;
		}
	}
	while(pa <= pa_last)   //插入La的剩余元素 
	{
		*pc = *pa;
		pc++;
		pa++;
	}
	while(pb <= pb_last)   //插入Lb的剩余元素 
	{
		*pc = *pb;
		pc++;
		pb++;
	}
	return 0; 
} 

int main()
{
	SqList La, Lb, Lc;   //声明3个线性表
	InitList_Sq(&La);    //初始化线性表La 
	InitList_Sq(&Lb);    //初始化线性表Lb
	La.elem[0]=2; La.elem[1]=5; La.elem[2]=5;
	La.elem[3]=7; La.elem[4]=8; La.elem[5]=9;
	La.length = 6;
	Lb.elem[0]=1; Lb.elem[1]=2; Lb.elem[2]=4;
	Lb.elem[3]=6; Lb.elem[4]=6; Lb.elem[5]=9;
	Lb.length = 6;
	MergeList_Sq(&La, &Lb, &Lc);
	printf("线性表La的元素：");
	for(int i=0; i<6; i++)
	{
		printf("%d ", La.elem[i]);
	}
	printf("\n");
	printf("线性表Lb的元素："); 
	for(int i=0; i<6; i++)
	{
		printf("%d ", Lb.elem[i]);
	}
	printf("\n");
	printf("合并后线性表Lc的元素:"); 
	for(int i=0; i<12; i++)
	{
		printf("%d ", Lc.elem[i]);
	}
}

结果：

TSY@小田
关注
  • 59
    点赞
  • 踩
  • 287
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
西南交通大学数据结构第一次实验报告
10-17
数据结构实验报告主要探讨了如何使用两种不同的存储结构——顺序表和链表——来实现线性表，并计算它们的交集。线性表是数据结构中最基础的数据组织形式，它包含一系列按照特定顺序排列的元素。 实验的具体任务是：...
基础数据结构（简单的数据结构，主要有链表、栈、队列以及常见的排序算法）.pdf
11-18
为了方便操作顺序表，还需要实现一系列方法，如初始化、插入元素、删除元素、查找元素以及销毁顺序表等。这些方法的实现应考虑到代码的健壮性和效率，确保在处理各种情况时都能正确无误地工作。 总的来说，理解和...
【数据结构与算法】(3)：顺序表增删改查的完整实现
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
04-19 397
顺序表是如何进行随机访问的？顺序表元素的增删改查操作？顺序表的完整操作
线性表——(2)线性表的顺序存储及其运算的实现
一个正在学习C/C++的博主
11-29 1942
线性表——(2)线性表的顺序存储及其运算的实现 顺序表基本运算的实现： 💦顺序表的初始化： 💦插入运算 ： ☘️顺序表的数据元素的插入算法： 💦删除运算： ☘️顺序表的数据元素的删除算法： 💦按值查找 : ☘️顺序表的数据元素查找算法: 三、顺序表的其他运算举例： 💦例1： ☘️顺序表的划分算法： 💦例2： ☘️顺序表的合并算法： 💦例3： ☘️两个顺序表的比较算法：
(C数据结构)顺序表的初始化、插入、删除、查找
最新发布
xwwhale的博客
04-23 242
【代码】(C数据结构)顺序表的初始化、插入、删除、查找。
数据结构线性表——顺序表代码
m0_47887988的博客
03-29 1266
1.1 静态分配 #include<stdio.h> #define MaxSize 10 //定义最大长度 typeof struct{ int data[MaxSize]; //用静态的“数组”存放数据元素 int length; //顺序表的当前长度 } SqList; //顺序表的类型定义（静态分配方式） //基本操作——初始化一个顺序表 void InitList(SqList &L){ L.length=0; //顺序表初始长度
顺序表的插入、删除、合并
m0_75000742的博客
07-11 63
【代码】顺序表的插入、删除、合并。
C语言实现单链表创建、删除、查找、插入
qq_36806987的博客
04-08 3万+
本文将详细的介绍C语言单链表的创建、删除、查找、插入以及输出功能一、创建#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef int ElemType; /*结构体部分*/ typedef struct Node { ElemType data; //数值域 struct Node *next; //指针域 }Li...
顺序表的初始化、取值、查找、插入、删除
m0_68002095的博客
03-13 1828
然后保存被删除的元素的值，将第。函数删除第3个元素，并输出被删除的元素的值和顺序表中的元素。个位置及其后面的元素前移一位，最后将顺序表的长度减1。的元素，则返回其位序。函数在第3个位置插入元素10，并输出顺序表中的元素。函数中，使用循环遍历顺序表中的元素，如果找到了值为。函数来取出顺序表中第3个元素的值，并输出结果。函数来查找值为3的元素的位序，并输出结果。数组用来存储顺序表中的元素，数组用来存储顺序表中的元素，数组用来存储顺序表中的元素，数组用来存储顺序表中的元素，数组用来存储顺序表中的元素，
【数据结构（C语言）】顺序表的定义，实现初始化、创建、插入、增、删、改、查等基本操作（详细）
DuFengYa的博客
05-21 1万+
顺序表是在计算机内内存中以数组的形式保存的线性表， 线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、 使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中， 即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系， 采用顺式存储结构的线性表通常称为顺序表。 相对于链式存储结构而言，顺式存储结构显得更为简单。 顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 顺序表的基本运算有： 初始化 查找 插入 删除 输.
数据结构课程设计——最小生成树的实现
08-28
- **创建空表**：初始化一个空的广义表。 - **插入元素**：在广义表的特定位置插入一个元素或子表。 - **删除元素**：根据指定条件删除广义表中的元素或子表。 - **遍历**：按照某种顺序访问广义表的所有元素。 - **...
数据结构 顺序表 里面有顺序表的建立 插入 删除 查找
12-31
自己编的顺序表，各位高手指导一下，里面有顺序表的建立 插入 删除 查找 （分位置 和分值）
顺序表的基本操作，如查找，删除，插入，排序
12-30
学习数据结构的基本操作要求，查找，删除，插入，排序，显示等，VC++开发环境
Java算法实例-双向链表操作
08-22
本实例聚焦于Java中的一个重要数据结构——双向链表，它在很多场景下都有着广泛的应用。双向链表与单链表相比，其独特之处在于每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针，这使得在链表中的...
数据结构演示软件
06-02
1． 顺序表和链表的插入、删除和链表的生成 算法演示屏由显示顺序表或链表的图示、算法文本及变量等三个窗口组成。在演示算法之前，需先在弹出的小窗口中输入线性表的数据元素及算法参数 i（插入或删除的位置）和 ...
c语言用顺序表实现学生信息的添加、插入、删除、查找功能
qq_54467680的博客
10-31 8727
#include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX 20 typedef struct{ int no; //8位学号 char name[20]; //姓名 float score; //成绩 }Student; typedef struct{ Student *elem; ...
顺序表及其初始化、头插、头删、尾插、尾删、在指定位置插入和删除元素、查找、扩容等操作
weixin_46153828的博客
02-24 1202
首先记录一下线性表的概念： 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串。 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 1. 静态顺
线性表（顺序表）的初始化，取值，查找，插入及删除（c++）
m0_74472474的博客
09-11 6808
顺序表中的基本操作以及描述（基本操作包括对线性表进行初始化，取值，查找元素，插入元素以及删除元素)
单链表——单链表的定义及基本操作（初始化、头插法尾插法建表、查找、插入、删除、判空等）
热门推荐
薛定谔的猫的博客
04-17 9万+
文章目录单链表的定义单链表上的操作初始化建立单链表头插法建立单链表尾插法建立单链表遍历单链表求单链表的长度查找操作按值查找按位查找插入操作删除操作完整代码及实例 单链表的定义   由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。   单链表的特点： 单链表不要求逻辑上相邻的两个元素在物理位置上也相邻，因此不需要连续的存储
用c写一个顺序表 实现初始化 插入 删除 查找
03-28
#include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 typedef struct { int data[MAXSIZE]; int length; } SqList; // 初始化顺序表 void InitList(SqList *L) { L->length = 0; } // 插入元素 int ListInsert(SqList *L, int i, int e) { if (i < 1 || i > L->length + 1 || L->length == MAXSIZE) { return 0; } for (int j = L->length; j >= i; j--) { L->data[j] = L->data[j - 1]; } L->data[i - 1] = e; L->length++; return 1; } // 删除元素 int ListDelete(SqList *L, int i) { if (i < 1 || i > L->length) { return 0; } for (int j = i; j < L->length; j++) { L->data[j - 1] = L->data[j]; } L->length--; return 1; } // 查找元素 int LocateElem(SqList *L, int e) { for (int i = 0; i < L->length; i++) { if (L->data[i] == e) { return i + 1; } } return 0; } int main() { SqList L; InitList(&L); ListInsert(&L, 1, 10); ListInsert(&L, 2, 20); ListInsert(&L, 3, 30); for (int i = 0; i < L.length; i++) { printf("%d ", L.data[i]); } printf("\n"); ListDelete(&L, 2); for (int i = 0; i < L.length; i++) { printf("%d ", L.data[i]); } printf("\n"); int pos = LocateElem(&L, 30); if (pos) { printf("元素30的位置是：%d\n", pos); } else { printf("元素30不存在\n"); } return 0; }

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值