顺序表(C语言版)

最新推荐文章于 2024-07-13 08:21:27 发布
最新推荐文章于 2024-07-13 08:21:27 发布
阅读量1.2k 收藏 20
点赞数 38
分类专栏： 数据结构笔记(C语言版) 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A2885A/article/details/139478306
版权

前言

今天开始进入数据结构的学习，要学习的第一种数据结构就是顺序表。
在介绍顺序表之前先介绍一下数据结构，数据结构是数据在内存中的存储，组织的方式。数据结构是指相互之间存在一种或多种特定关系的数据的集合。接下来介绍顺序表。

一. 顺序表

1. 顺序表的概念

顺序表是一种底层是数组的线性表，它和数组一样通过下标访问元素，但是和数组不同的地方在于它可以不是定长的，动态顺序表的大小是可以通过动态内存申请得来。（线性表是在逻辑结构上一定连续，物理结构上不一定连续的具有相同特性数据的序列）。顺序表在物理结构和逻辑结构上都是连续的，因为其底层是数组。

2. 顺序表的分类

  • 静态顺序表：内存大小是确定的
  • 动态顺序表：内存大小是可以改变

对于静态顺序表，内存小了可能会导致数据的丢失，而内存大了又会导致内存空间的浪费；而动态顺序表可以扩容，不会导致数据的丢失，内存的浪费也没有像静态顺序表那么大。因此我们常用动态顺序表而不常用静态顺序表。

3.动态顺序表的功能

对于动态顺序表我们要实现以下功能：

  • 顺序表的初始化和销毁
  • 数据的插入:头插和尾插
  • 数据的删除：头删和尾删
  • 在指定位置删除/插入数据
  • 数据的查找

二. 动态顺序表的代码实现

对于顺序表的实现我们分多个文件来写，首先创建一个头文件 (SeqList.h)来声明顺序表结构和实现顺序表的方法，在源文件(SeqList.c)文件中实现顺序表，另建一个.c文件用于测试。
以下是头文件

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLDataType;//将int类型重命名为SLDataType便于以后类型的更换

typedef struct SeqList
{
	SLDataType* arr;
	int size;//元素个数
	int capacity;//内存大小
}SL;//将结构体类型冲定义为SL后续使用更方便
//顺序表的初始化
void SLInit(SL* ps);

//顺序表的销毁
void SLDestory(SL* ps);

//尾插
void SLPushBack(SL* ps, SLDataType x);

//头插
void SLPushFront(SL* ps, SLDataType x);

//尾删
void SLPopBack(SL* ps);

//头删
void SLPopFront(SL* ps);

//在指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x);

//删除指定位置的数据
void SLErase(SL* ps, int pos);

//查找数据
int SLFind(SL* ps, SLDataType x);

下面我们对这些函数一一进行实现。

1. 顺序表初始化和销毁

1.1 顺序表初始化

SeqList.c

#include"SeqList.h"
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

SLInit函数接收一个结构体指针，然后对结构体解引用找到arr并将其置为NULL，找到size和capacity把它们初始化为0。

#include"SeqList.h"
void Test()
{
	SL sl;
	SLInit(&sl);
}
int main()
{
	Test();
	return 0;
}

测试一下
在这里插入图片描述
没有问题，接着往下实现。

1.2 顺序表的销毁

有句话说得好：“有借有还，再借不难”。动态顺序表开辟的空间是动态内存申请来的，在不使用之后这些内存要还给操作系统，下面我们来实现顺序表的销毁。

void SLDestory(SL* ps)
{
	if (ps->arr)
	{
		ps->arr = NULL;
	}
	ps->capacity = 0;
	ps->size = 0;
}

同样，SLDestory函数也是接收一个结构体指针，进入函数后，执行if语句，如果arr不为空，那就将其置空那个，再把size和capacity置为0。这样就完成了顺序表的销毁。

2. 顺序表的头插和尾插

2.1 顺序表的尾插

尾插 顾名思义就是在顺序表的末尾插入数据
在这里插入图片描述
但是在这里我们要考虑一下内存够不够用，上图中，size=5，capacity也等于5，当我们通过size下标访问时就会超出arr申请的空间也就是越界访问，因此我们在这种情况下要进行扩容。扩容一般按照原空间的2倍和进行扩容。

在插入数据后，对应的size大小也要进行+1！！！
下面是代码实现：

void SLPushBack(SL* ps, SLDataType x)
{
	if (ps->size == ps->capacity)//判断内存够不够
	{
		int newcapacity = (ps->capacity == 0) ? 4 : 2 * ps->capacity;//先判断一下capacity是否为0
		//若为0返回4；非零就返回原来的2倍
		//扩容
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)//如果开辟失败就打印错误信息，然后直接退出程序
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = tmp;//扩容成功后才可以将tmp赋给arr，如果不成功会返回NULL,
		//那arr就成空了，之前的数据也会丢失。
		ps->capacity = newcapacity;
	}
	ps->arr[ps->size] = x;
	ps->size++;
}

这里realloc函数第2个参数是扩容后的空间大小，单位是字节，因此一定要乘上数据类型的大小。
测试一下：
在这里插入图片描述
传过空指针报错了，为了增加代码的健壮性我们可以在这个函数中加上assert断言，这样就不会发生这种现象了。

2.2 顺序表的头插

在插入数据之前还是要看一下内存够不够，然后在顺序表最前面插入数据，后面的数据要依次往后挪动1位，那应该怎们挪动呢？
在这里插入图片描述
像上面如果从前往后挪动的话就会把后面的数据覆盖，因此要从后往前挪动
在这里插入图片描述

最后是arr[1]=arr[0]。
代码实现：

 void SLPushFront(SL * ps, SLDataType x)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		int newcapacity = (ps->capacity == 0) ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

为了更方便的看出结果，我又定义了一个打印顺序表的函数，代码如下：

void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

在这里插入图片描述
没有问题。但是大家发现了，在头插和尾插这两个函数中都有检查内存够不够的功能，使代码看着很冗余，于是我将它封装成了函数,整个头插和尾插的优化后代码如下：

void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = (ps->capacity == 0) ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
}
//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->arr[ps->size] = x;
	ps->size++;
}
//头插
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

3. 顺序表的头删和尾删

3.1 顺序表的尾删

尾删就是将顺序表的最后一个元素删除(元素个数不能为0)，实际上就是将顺序表的大小-1即可，最后一个元素并不会影响后续的增删改查。
代码实现：

void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;
}

3.2 顺序表的头删

将顺序表的第一个元素删除，后面的元素依次往前移动，分析一下，应该是从前往后依次往前移。
在这里插入图片描述

代码如下：

void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

4. 顺序表在指定位置删除添加数据

4.1 在指定位置前插入数据

要在pos=2的位置插入6
在这里插入图片描述代码如下：

void SLInsert(SL* ps,int pos,SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);//保证顺序表的下标合法
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

4.2 在指定下标删除数据

把上面添加的6删除掉
在这里插入图片描述
pos后的元素依次往前挪。

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

这里要注意在第2个assert进行判断的时候，pos的右边界不能取到size，因为size下标对应没有元素，访问就会越界。

5. 顺序表元素的查找

这里我们让SLFind函数的返回值是整型，如果找到该元素就返回该元素所对应的下标，如果没有找到就返回-1。用一个简单的for循环实现，代码如下：

int SLFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

三. 其他方法实现

以上我们就实现好了顺序表，但是对于头插，头删，在指定位置删除和插入数据我们还可以不用循环实现，借助库函数memmove也可以实现这几项功能。

1. memmove实现头插

在这里插入图片描述
我们把整体往后挪动了1位

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	memmove(ps->arr + 1, ps->arr, ps->size * sizeof(SLDataType));
	ps->arr[0] = x;
	ps->size++;
}

也就是把arr[0]以后的整体元素移动到arr[1]上

2.memmove实现头删

在这里插入图片描述
将arr[1]及其后面的size-1个元素移动到arr[0]的位置上

void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	memmove(ps->arr, ps->arr + 1, sizeof(SLDataType) * ps->size - 1);
	ps->size--;
}

3. memmove实现指定位置前插入数据

对于下面的顺序表我要在pos=2的元素之前插入6
在这里插入图片描述
代码如下：

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	memmove(ps->arr + pos + 1, ps->arr + pos, sizeof(SLDataType) * (ps->size - pos));
	ps->arr[pos] = x;
	ps->size++;
}

4. memmove实现指定位置删除数据

对于这个顺序表要删除pos = 2位置的元素
在这里插入图片描述
代码如下：

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	memmove(ps->arr + pos, ps->arr + pos + 1, sizeof(SLDataType) * (ps->size - pos - 1));
	ps->size--;
}

四. 整体代码呈现

1. SeqList.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* arr;
	int size;//元素个数
	int capacity;//内存大小
}SL;
//顺序表的初始化
void SLInit(SL* ps);

//顺序表的销毁
void SLDestory(SL* ps);

//尾插
void SLPushBack(SL* ps, SLDataType x);

//头插
void SLPushFront(SL* ps, SLDataType x);

//尾删
void SLPopBack(SL* ps);

//头删
void SLPopFront(SL* ps);

//在指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x);

//删除指定位置的数据
void SLErase(SL* ps, int pos);

//查找数据
int SLFind(SL* ps, SLDataType x);
//顺序表打印
void SLPrint(SL* ps);

2. SeqList.c

#include"SeqList.h"

//顺序表的初始化
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

//顺序表的销毁
void SLDestory(SL* ps)
{
	if (ps->arr)
	{
		ps->arr = NULL;
	}
	ps->capacity = 0;
	ps->size = 0;
}

//检查内存是否够用
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = (ps->capacity == 0) ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
}

//顺序表的尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->arr[ps->size] = x;
	ps->size++;
}
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

//顺序表的头插
//void SLPushFront(SL* ps, SLDataType x)
//{
//	assert(ps);
//	SLCheckCapacity(ps);
//	for (int i = ps->size; i > 0; i--)
//	{
//		ps->arr[i] = ps->arr[i - 1];
//	}
//	ps->arr[0] = x;
//	ps->size++;
//}

//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;
}

//头删
//void SLPopFront(SL* ps)
//{
//	assert(ps);
//	assert(ps->size);
//	for (int i = 0; i < ps->size - 1; i++)
//	{
//		ps->arr[i] = ps->arr[i + 1];
//	}
//	ps->size--;
//}

//在指定位置前插入数据
//void SLInsert(SL* ps,int pos,SLDataType x)
//{
//	assert(ps);
//	assert(pos >= 0 && pos <= ps->size);//保证顺序表的下标合法
//	for (int i = ps->size; i > pos; i--)
//	{
//		ps->arr[i] = ps->arr[i - 1];
//	}
//	ps->arr[pos] = x;
//	ps->size++;
//}
//在指定位置删除数据
//void SLErase(SL* ps, int pos)
//{
//	assert(ps);
//	assert(pos >= 0 && pos < ps->size);
//	for (int i = pos; i < ps->size - 1; i++)
//	{
//		ps->arr[i] = ps->arr[i + 1];
//	}
//	ps->size--;
//}

//数据查找
int SLFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

//memmove实现头插
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	memmove(ps->arr + 1, ps->arr, ps->size * sizeof(SLDataType));
	ps->arr[0] = x;
	ps->size++;
}
//memmove实现头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	memmove(ps->arr, ps->arr + 1, sizeof(SLDataType) * ps->size - 1);
	ps->size--;
}
//memmove实现指定位置前插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);//保证顺序表的下标合法
	memmove(ps->arr + pos + 1, ps->arr + pos, sizeof(SLDataType) * (ps->size - pos));
	ps->arr[pos] = x;
	ps->size++;
}
//memmove实现指定位置数据的删除
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	memmove(ps->arr + pos, ps->arr + pos + 1, sizeof(SLDataType) * (ps->size - pos - 1));
	ps->size--;
}

3.test.c(测试文件)

#include"SeqList.h"
//void Test()
//{
//	SL sl;
//	SLInit(&sl);
//	SLPushBack(&sl, 1);
//	SLPushBack(&sl, 2);
//	SLPushBack(&sl, 3);
//	SLPushBack(&sl, 4);
//	SLPushBack(&sl, 5);
//	//SLPushBack(NULL, 1);
//	//SLPushFront(&sl, 6);
//	//SLPopBack(&sl);
//	//SLPopFront(&sl);
//	/*SLInsert(&sl, 0, 6);
//	SLInsert(&sl, 5, 6);
//	SLInsert(&sl, 2, 8);*/
//	//SLErase(&sl, 2);
//	//SLPrint(&sl);
//	/*int ret = SLFind(&sl, 6);
//	if (ret < 0)
//	{
//		printf("没找到\n");
//	}
//	else
//	{
//		printf("找到了下标为%d\n",ret);
//	}*/
//}
void Test2()
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	//SLPushFront(&sl, 8);
	//SLPopFront(&sl);
	//SLInsert(&sl, 2, 6);
	SLErase(&sl, 2);
	SLPrint(&sl);
}
int main()
{
	//Test1();
	Test2();
	return 0;
}

以上就讲完了顺序表的全部内容，希望对大家有帮助，也欢迎大家批评指正。

跃渊Yuey
关注
  • 38
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
数据结构顺序表 C语言代码实现以及realloc的使用
07-09
本文将深入探讨如何使用C语言实现顺序表，并重点讲解`realloc`函数在扩展内存时的作用。 首先，我们需要理解顺序表的基本操作，包括创建、插入、删除和查找。在C语言中，我们可以使用结构体来表示顺序表，例如定义...
顺序表C语言版
iwkxi的博客
03-18 3478
文章目录1.线性表2.顺序表2.1概念及结构2.2接口实现2.2.1 SeqList.h2.2.2 SeqList.c2.2.2.1 初始化顺序表 1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2.顺序表 2.1概念及结构 顺序表是用一
顺序表（C语言版）
m0_64520498的博客
10-13 1632
静态顺序表：以定长数组储存元素 ；动态顺序表：使用动态开辟的数组储存
C语言实现顺序表
辰多代码的博客
07-26 1978
1.2 SeqList.c 1.3 test.c 二、顺序表的实现 2.1 顺序表 创建一个顺序表结构体，成员包含顺序表地址、长度、大小，用于创建顺序表变量。 将顺序表变量的地址传参，通过指针接收对顺序表的顺序表数组初始化为空，长度为0，大小为0。 同样传地址，要先断言指针是否为空，不然会出异常。然后判断顺序表大小是否为0，为0则代表顺序表中没有有效元素，打印提示，并返回函数，如果大于0，则有元素，从下标0开始，打印size个顺序表元素，并用空格相隔。 当我们结束程序
顺序表C语言实现详解
hurryddd
04-03 3022
1、线性表 线性表。全名为线性存储结构，可以理解为即“把所有数据用一根线儿串起来，再存储到物理空间中”。线性表并不是一种具体的存储结构，它包含 顺序存储结构 和 链式存储结构，是顺序表和链表的统称。除了数组，链表、队列、栈等也是线性表结构。 顺序存储结构：将数据依次存储在连续的整块物理空间中 链式存储结构：数据分散的存储在物理空间中，通过一根线保存着它们之间的逻辑关系 非线性表。在非线性表中，数据之间并不是简单的前后关系。比如树、图 2、顺序表 它用一组连续的内存空间，来存储一组具有
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
C语言顺序表的实现代码
08-29
同时，我们还定义了一些基本操作，例如初始化顺序表、在顺序表的末尾插入元素、在顺序表的头部插入元素、显示顺序表中的元素、删除顺序表最后一个元素、删除顺序表第一个元素、在顺序表的选定位置上插入数据、在顺序...
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
C语言实现顺序表基本操作汇总
09-04
【C语言实现顺序表基本操作汇总】 顺序表是一种在计算机科学中常见的数据结构，它将一组元素存储在一块连续的内存区域中。这种结构允许快速访问元素，因为可以通过索引来直接定位元素。本文将深入讨论如何使用C语言...
通讯录-C/C++
2302_77527700的博客
07-11 648
设计一个通讯录管理程序，要求程序采用模块化设计方法，程序应采用由主控程序调用各模块实现各个功能的方式。插入记录删除记录等。数据存储采用存储形式，存放于外存的数据应进行处理。
【2024第一期CANN训练营】全面掌握Ascend C算子
Tensorrrrrr的博客
07-12 355
【2024第一期CANN训练营】全面掌握Ascend C算子
算法复杂度＜数据结构 C版＞
最新发布
hukang的博客
07-13 1649
简单来说算法复杂度是用来衡量一个算法的优劣的，一个程序在运行时，对运行时间和运行空间有要求，即时间复杂度和空间复杂度。
数据结构—链式二叉树-C语言
h_number_1的博客
07-11 920
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
数据结构（Java）：队列&Queue集合&力扣面试OJ题
2401_83595513的博客
07-12 2473
队列、Queue、Deque、循环队列、队列OJ题
数据结构之单链表在不带标准头的情况下C，C#，C++分别怎么实现？
qq_35320456的博客
07-12 452
数据结构是计算机科学中非常重要的一部分，它帮助我们理解和操作数据。单链表是数据结构中的一种基本类型，它由一系列节点组成，每个节点包含数据域和指向列表中下一个节点的指针。在本文中，我们将详细讨论单链表的概念、操作和如何在几种常见的编程语言中实现它。
数据结构——顺序表
2301_80373479的博客
07-11 556
是的的。...逻辑上线性结构，也就说是连续的⼀条直线。但是在， 线性表在物理上存储时，通常以的形式存储。顺序表还会封装对数据元素的将顺序表里的不是覆盖原先数据，插入数据的结果造成部分数据后移返回下标。
数据结构第23节 线性搜索
hummhumm的专栏
07-12 365
线性搜索（Linear Search），也称为顺序搜索，是最基本的搜索算法之一。它的工作原理是通过遍历数组或列表中的每一个元素，直到找到目标值为止，或者遍历完所有元素后确定目标值不存在于列表中。线性搜索的时间复杂度为O(n)，其中n是列表中元素的数量。这是因为最坏情况下，你可能需要检查列表中的每一个元素才能找到目标值或确定它不在列表中。
数据结构(C语言版）-第二章线性表
qq_43071699的博客
07-12 1256
ADT List操作结果：构造一个空的线性表L初始条件：线性表L已存在。操作结果，销毁线性表L。初始条件：线性表L巳存在。操作结果：将L重置为空表。初始条件：线性表L已存在。操作结果：若L为空表，则返回 TRUE, 否则返回 FALSE。初始条件：线性表L已存在。操作结果：返回L中数据元素个数。初始条件：线性表 已存在， 1i操作结果：用e返回L中第i个数据元素的值。初始条件：线性表L已存在， compare() 是数据元素判定函数。
有序表合并顺序表c语言
02-10
在C语言中，可以使用数组来表示有序表，并通过遍历和比较元素的方式进行合并。 以下是一个简单的示例代码，演示了如何合并两个有序表： ```c #include // 合并有序表的函数 void merge(int arr1[], int size1, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值