数据结构1——顺序表（C语言版）

已于 2024-05-12 01:48:54 修改
阅读量499 收藏 12
点赞数 24
分类专栏： 数据结构（C语言版） 文章标签： 数据结构
于 2024-05-08 21:57:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73629886/article/details/138584139
版权

1. 什么是顺序表

在学习顺序表之前我们首先要了解线性表：

1.1 线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。

adfbc18dbf844459854a2fabbb194ac8.png

cc8179d662f44535bd8cef0541910222.png

1.2 顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存 储。在数组上完成数据的增删查改。

顺序表一般可以分为静态顺序表和动态顺序表。

1.2.1 静态顺序表

静态顺序表采用定长数组存储元素。

也就是说顺序表能够存储的数据一开始就固定好了，即存储元素的最大个数为固定值。

下面为用结构体定义一个静态顺序表的代码：

//静态顺序表

#define N 1000;                //N表示顺序表（数组）的长度，用define定义N，便于修改数据；

typedef int SLDataType;       //由于顺序表存储的数据并不一定是整型，所以用typedef定义SLDataType，便于修改数据类型；
struct SeqList
{
	SLDataType a[N];          //顺序表的长度；
	int size;                 //一个顺序表不一定会放满，用size表示顺序表已存放数据的个数；
};

f0390d154d244b889a5047c77cbd2f24.png

1.2.2 动态顺序表

动态顺序表使用动态开辟的数组存储。

看一下上面的静态顺序表不难看出，有时开辟的数组过大，会存不满，导致了空间浪费；也有时开辟的数组过小，会不够存。为避免这种情况，我们可以采用动态开辟的方法定义顺序表。

代码如下：

//动态顺序表     静态顺序表会出现空间不够或空间浪费的情况，所以用动态顺序表方便扩容    

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;         //指向动态开辟的数组
	int size;              //已存储的数据个数
	int capacity;          //数组容量大小，当size≥capacity时就动态开辟空间
}SL;

知道了这些概念我们再继续本篇博客的重头戏。

顺序表的功能无非就是增删查改，再加上上面的动态顺序表如何开辟和销毁

所以实现这些功能，无非就是实现一个个函数的过程。

2. 顺序表的实现

2.1 初始化函数（SLInit）的实现

void SLInit(SL* ps)
{
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc failed");//如果扩容失败，说明原因
		exit(-1);
	}
	ps->size = 0;//当size≥capacity时就动态开辟空间
	ps->capacity = 4;//初始化数组容量为4
}

2.2 销毁函数（SLDestroy）的实现

void SLDestroy(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

2.3 打印函数（SLPrint）的实现

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

2.4 扩容函数(SLCheckCapacity)的实现

void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		SLDataType* tmp = realloc(ps->a, ps->capacity * 2 * (sizeof(SLDataType)));
		if (tmp == NULL)
		{
			perror("realloc failed");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
}

2.5 插入函数

2.5.1 尾插函数(SLPushBack)的实现

void SLPushBack(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);     //先检查扩容
	ps->a[ps->size] = x;
	ps->size++;
}

2.5.2 头插函数(SLPushFront)的实现

void SLPushFront(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}

2.5.3 在pos位置插入数值x函数(SLInsert)的定义

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}

2.6 删除函数

2.6.1 尾删函数(SLPopBack)的实现

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

2.6.2 头删函数(SLPopFront)的实现

void SLPopFront(SL* ps)
{
	assert(ps->size > 0);
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;
}

2.6.3 删除pos位置数值函数（SLErase）的实现

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

2.7 查找函数

2.7.1 查找函数1（SLFind1）的实现

int SLFind1(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			printf("数值%d的下标为%d\n", x, i);
			return 0;
		}
	}
	printf("发生错误\n");
	return -1;
}

2.7.2 查找函数2（SLFind2）的实现

int SLFind2(SL* ps, int x)
{
	assert(ps);
	for (int i = 0; i <= ps->size; i++)
	{
		if (ps->a[i] == ps->a[x])
		{
			printf("下标%d的值为%d\n", x, ps->a[i]);
			return 0;
		}
	}
	printf("发生错误\n");
	return -1;
}

2.8 修改函数

修改函数（SLMofidy）的实现

void SLModify(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	ps->a[pos] = x;
}

3. 函数验证（使用）

3.1 尾插4 5 6

int main()
{
	SL sl;
	SLInit(&sl);
	//尾插4 5 6
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPrint(&sl);
	return 0;
}

6b5626c89afe4957ac9489f5a0bf870a.png

3.2 头插3 2 1

int main()
{
	SL sl;
	SLInit(&sl);
	//尾插4 5 6 
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPrint(&sl);
	//头插3 2 1
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 1);
	SLPrint(&sl);
	return 0;
}

d664379ad44f4241a2ca3e036e831a2c.png

3.3 在下标2位置插入22

int main()
{
	SL sl;
	SLInit(&sl);
	//尾插4 5 6 
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPrint(&sl);
	//头插3 2 1
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 1);
	SLPrint(&sl);
    //下标2位置插入22
	SLInsert(&sl,2,22);
	SLPrint(&sl);
	return 0;
}

132069c3717e469f993a7e1c3d61a901.png

3.4 删除末尾数字

int main()
{
	SL sl;
	SLInit(&sl);
	//尾插4 5 6 
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPrint(&sl);
	//头插3 2 1
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 1);
	SLPrint(&sl);
	//下标2位置插入22
	SLInsert(&sl,2,22);
	SLPrint(&sl);
	//删除末尾数字
	SLPopBack(&sl);
	SLPrint(&sl);
	return 0;
}

fc4c31df7a5e4b69916638c3ecf616bd.png

3.5 删除开头数字

int main()
{
	SL sl;
	SLInit(&sl);
	//尾插4 5 6 
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPrint(&sl);
	//头插3 2 1
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 1);
	SLPrint(&sl);
	//下标2位置插入22
	SLInsert(&sl,2,22);
	SLPrint(&sl);
	//删除末尾数字
	SLPopBack(&sl);
	SLPrint(&sl);
    //删除开头数字
	SLPopFront(&sl);
	SLPrint(&sl);
	return 0;
}

1b1a15d65bd84be4a37963751063b55e.png

3.6 删除下标2位置数字

int main()
{
	SL sl;
	SLInit(&sl);
	//尾插4 5 6 
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPrint(&sl);
	//头插3 2 1
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 1);
	SLPrint(&sl);
	//下标2位置插入22
	SLInsert(&sl,2,22);
	SLPrint(&sl);
	//删除末尾数字
	SLPopBack(&sl);
	SLPrint(&sl);
	//删除开头数字
	SLPopFront(&sl);
	SLPrint(&sl);
	//删除下标2位置数字
	SLErase(&sl,2);
	SLPrint(&sl);
	return 0;
}

48153d56ff04493f84d6c2c82f5f6f08.png

3.7 查找数值4的下标

int main()
{
	SL sl;
	SLInit(&sl);
	//尾插4 5 6 
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPrint(&sl);
	//头插3 2 1
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 1);
	SLPrint(&sl);
	//下标2位置插入22
	SLInsert(&sl,2,22);
	SLPrint(&sl);
	//删除末尾数字
	SLPopBack(&sl);
	SLPrint(&sl);
	//删除开头数字
	SLPopFront(&sl);
	SLPrint(&sl);
	//删除下标2位置数字
	SLErase(&sl,2);
	SLPrint(&sl);
	//查找数值4的下标
	SLFind1(&sl, 4);
	SLPrint(&sl);
	return 0;
}

3850299d7b4c4e01968bbb99a8b14f95.png

3.8 查找下标2的数值

int main()
{
	SL sl;
	SLInit(&sl);
	//尾插4 5 6 
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPrint(&sl);
	//头插3 2 1
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 1);
	SLPrint(&sl);
	//下标2位置插入22
	SLInsert(&sl,2,22);
	SLPrint(&sl);
	//删除末尾数字
	SLPopBack(&sl);
	SLPrint(&sl);
	//删除开头数字
	SLPopFront(&sl);
	SLPrint(&sl);
	//删除下标2位置数字
	SLErase(&sl,2);
	SLPrint(&sl);
	//查找数值4的下标
	SLFind1(&sl, 4);
	SLPrint(&sl);
	//查找下标2的数值
	SLFind2(&sl, 2);
	SLPrint(&sl);
	return 0;
}

3.9 修改下标1的数值为33

int main()
{
	SL sl;
	SLInit(&sl);
	//尾插4 5 6 
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPrint(&sl);
	//头插3 2 1
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 1);
	SLPrint(&sl);
	//下标2位置插入22
	SLInsert(&sl,2,22);
	SLPrint(&sl);
	//删除末尾数字
	SLPopBack(&sl);
	SLPrint(&sl);
	//删除开头数字
	SLPopFront(&sl);
	SLPrint(&sl);
	//删除下标2位置数字
	SLErase(&sl,2);
	SLPrint(&sl);
	//查找数值4的下标
	SLFind1(&sl, 4);
	SLPrint(&sl);
	//查找下标2的数值
	SLFind2(&sl, 2);
	SLPrint(&sl);
	//修改下标1的数值为33
	SLModify(&sl, 1, 33);
	SLPrint(&sl);
	return 0;
}

dc10ecf99b0447a38d47e19c33b038a3.png

4.源代码

4.1 SeqList.h源代码

#pragma once

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


//用结构体定义一个顺序表

静态顺序表
//
//#define N 1000;                //N表示顺序表（数组）的长度，用define定义N，便于修改数据；
//
//typedef int SLDataType;       //由于顺序表存储的数据并不一定是整型，所以用typedef定义SLDataType，便于修改数据类型；
//struct SeqList
//{
//	SLDataType a[N];          //顺序表的长度；
//	int size;                 //一个顺序表不一定会放满，用size表示顺序表已存放数据的个数；
//};

//动态顺序表     静态顺序表会出现空间不够或空间浪费的情况，所以用动态顺序表方便扩容    

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* a;         //指向动态开辟的数组
	int size;              //已存储的数据个数
	int capacity;          //数组容量大小，当size≥capacity时就动态开辟空间
}SL;

void SLInit(SL* ps);      //初始化函数的声明

void SLDestroy(SL* ps);   //销毁函数的声明

void SLPrint(SL* ps);     //打印函数的声明

void SLCheckCapacity(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);    //在pos位置插入数值x函数的声明

void SLErase(SL* ps, int pos);     //删除pos位置的数值函数的声明

int SLFind1(SL* ps, SLDataType x);        //查找函数1的声明（知数值找下标）

int SLFind2(SL* ps, int x);      //查找函数2的声明（知下标找数值）

void SLModify(SL* ps, int pos, SLDataType x);   //修改函数的声明

4.2 SeqList.c源代码

#include "SeqList.h"

//初始化函数（SLInit）的实现
void SLInit(SL* ps)
{
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc failed");//如果扩容失败，说明原因
		exit(-1);
	}
	ps->size = 0;//当size≥capacity时就动态开辟空间
	ps->capacity = 4;//初始化数组容量为4
}

//销毁函数（SLDestroy）的实现
void SLDestroy(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

//打印函数（SLPrint）的实现
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

//扩容函数(SLCheckCapacity)的实现
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		SLDataType* tmp = realloc(ps->a, ps->capacity * 2 * (sizeof(SLDataType)));
		if (tmp == NULL)
		{
			perror("realloc failed");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
}

//尾插函数(SLPushBack)的实现
void SLPushBack(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);     //先检查扩容
	ps->a[ps->size] = x;
	ps->size++;
}

//头插函数(SLPushFront)的实现
void SLPushFront(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[0] = x;
	ps->size++;
}

//尾删函数(SLPopBack)的实现
void SLPopBack(SL* ps)
{
	assert(ps->size > 0);
	ps->size--;
}

//头删函数(SLPopFront)的实现
void SLPopFront(SL* ps)
{
	assert(ps->size > 0);
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;
}

//在pos位置插入数值x函数(SLInsert)的定义
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}

//删除pos位置数值函数（SLErase）的定义
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;
}

//查找函数1（SLFind1）的定义
int SLFind1(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			printf("数值%d的下标为%d\n", x, i);
			return 0;
		}
	}
	printf("发生错误\n");
	return -1;
}

//查找函数2（SLFind2）的定义
int SLFind2(SL* ps, int x)
{
	assert(ps);
	for (int i = 0; i <= ps->size; i++)
	{
		if (ps->a[i] == ps->a[x])
		{
			printf("下标%d的值为%d\n", x, ps->a[i]);
			return 0;
		}
	}
	printf("发生错误\n");
	return -1;
}

//修改函数（SLMofidy）的定义
void SLModify(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	ps->a[pos] = x;
}

4.3 test.c源代码

#include "SeqList.h"

int main()
{
	SL sl;
	SLInit(&sl);
	//尾插4 5 6 
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushBack(&sl, 6);
	SLPrint(&sl);
	//头插3 2 1
	SLPushFront(&sl, 3);
	SLPushFront(&sl, 2);
	SLPushFront(&sl, 1);
	SLPrint(&sl);
	//下标2位置插入22
	SLInsert(&sl,2,22);
	SLPrint(&sl);
	//删除末尾数字
	SLPopBack(&sl);
	SLPrint(&sl);
	//删除开头数字
	SLPopFront(&sl);
	SLPrint(&sl);
	//删除下标2位置数字
	SLErase(&sl,2);
	SLPrint(&sl);
	//查找数值4的下标
	SLFind1(&sl, 4);
	SLPrint(&sl);
	//查找下标2的数值
	SLFind2(&sl, 2);
	SLPrint(&sl);
	//修改下标1的数值为33
	SLModify(&sl, 1, 33);
	SLPrint(&sl);
	return 0;
}

 

徐霞客320
关注
  • 24
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C语言数据结构-顺序表版学生管理系统
09-26
在本项目" C语言数据结构-顺序表版学生管理系统 "中，我们将聚焦于一种基础的数据结构——顺序表，以及如何利用C语言实现一个学生管理系统的具体应用。 顺序表是一种线性数据结构，它的特点是元素在内存中按顺序...
数据结构——用现有链表转换为顺序表
06-26
用链表创建顺序表，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 6517
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
数据结构 ——顺序表【c语言版】
clear-ninghongkang的博客
11-19 5995
线性表：具有相同特性的数据元素（既同类型数据）的一个有限序列. 注：同一线性表中的元素必定具有相同特性 线性表的特性：1.有穷性 2.一致性 3.序列性 线性表的最本质特征：有唯一的前驱和后继 线性表的顺序存储结构———顺序表 顺序存储结构——逻辑上相邻的元素，在物理上也相邻 在c语言中，顺序表通常用数组来存储，这与python中的列表不同，数组是给定长度的，数组中元素的地址也是相邻的，且数组中的元素类型一定要相同,而列表list是的长度理论上是可以无限添加的，(因为pyt...
数据结构——顺序表（C语言编写）
新手小白
09-17 7867
数据结构，顺序表应用 插入、删除、合并...
C语言之 数据结构入门——顺序表的构造
tq02的博客
12-27 3198
顺序表的删、插、增、查、扩等详解，且结尾附带完整代码
数据结构C语言——顺序表
zsjsdsg666的博客
05-14 1432
数据结构C语言——顺序表 一、实验目的 1．掌握线性表的存储结构及相关的操作； 2．熟悉对顺序表的一些基本操作，如初始化、插入、删除等； 3．用C语言编制程序，程序中写出详细注释； 4．给出测试结果，验证程序的正确性。 二、实验内容 1．建立一个长度为N的顺序表。 2．输出该顺序表的各个元素以及相应的下标。 3．在顺序表的第i个位置里插入元素x，并且输出插入元素后顺序表中各个元素以及相应的下标。 4．删除顺序标中第i个位置的元素，并且输出删除元素后顺序表中各个元素以及相应的下标。 5．在顺序表中找到x元素，
数据结构——顺序表（C语言）
m0_72165281的博客
07-24 1637
数据结构——顺序表
数据结构——顺序队列【c语言版】
clear-ninghongkang的博客
11-21 4386
队列（quque）简称队，只允许在表的一端输入，在表的另一端删除(操作受限制的线性表)， 把进行插入的一段叫做队尾（表尾），把进入删除的一端叫做队首或队头（表头）。 队列最主要的特点：先进先出，FIFO（first in first out） 队列有其实有三种：顺序队列、循环队列、链式队列 下面是采用采用顺序存储结构来实现的顺序队 假设栈的元素个数最大不超过正整数MaxSize，所以元素具有同一数据类型（ElemType），用下来方式来声明顺序栈的类型SqQueu...
数据结构——顺序表的C语言实现
Winters_coming的博客
10-27 3892
郫县电子专科学院的在读大二，再次保存代码供参考及批评指正 ex1_1——基本题： 1）首先创建一个顺序表：从键盘读入一组整数（长度小于等于20），按输入顺序放入顺序表，输入以－1结束（注意－1不放到顺序表内）；将创建好的顺序表元素依次输出到屏幕上。 2）在已创建好的顺序表中插入一个元素：从键盘读入需插入的元素值和插入位置，调用插入函数完成插入操作；然后将顺序表元素依次输出到屏幕上。 3）在...
数据结构——顺序表的C语言代码实现
AZ10000000的博客
04-01 6657
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、基础知识1.顺序表的概念（Sepential List）2.常用的接口函数3.realloc（）函数使用细节4.assert( )函数二、代码实现1.SepList.h（1）引用函数库（2）定义动态顺序表（3）接口函数声明2.SepList.c（1）引用头文件（2）初始顺序表（3）检测顺序表容量是否足够（4）顺序表的尾插法（5）顺序表的尾删法<1>使用if判断的温和法<2>使用assert（）断言的.
数据结构c语言版 顺序表部分代码
03-06
在本资源中，我们关注的是数据结构的一种基础形式——顺序表，它是用C语言实现的。顺序表是将元素在内存中连续存放的数据结构，其操作简单直观，但对内存空间的需求较高。 `main.cpp` 是主程序文件，它包含了调用...
严蔚敏《数据结构》源码 顺序表——二叉树
06-08
目前写在了图，之后的内容会在github上持续更新，数据结构系列更新完之后，可能会更新算法的教程（参考屈婉玲版《算法设计与分析》）希望可以帮到各位！！ InitList.cpp------顺序表 LinkList.cpp------链表 ...
数据结构——基于C语言实现单链表的应用.rar
08-11
在这个主题中，我们专注于一个特定的数据结构——单链表，并讨论其在C语言中的实现。单链表是一种线性数据结构，其中每个元素（称为节点）包含两个部分：数据域，用于存储实际信息，以及指针域，指向链表中的下一个...
数据结构之B树
zgy_boke的博客
06-26 342
插入操作：如果插入后节点中的关键字数量超过阶数规定的上限，需要进行节点分裂，将中间的关键字提升到父节点，并将节点分裂为两个。B 树的查找操作类似于二叉查找树，但由于是多路查找，需要在节点内部根据关键字进行比较和判断，然后选择合适的子节点继续查找。B 树（B-Tree）是一种平衡的多路查找树，常用于数据库和文件系统中，以实现对大量数据的高效存储和检索。删除操作：如果删除后节点中的关键字数量过少，可能需要进行节点合并或从兄弟节点借关键字。
【408考点之数据结构】二叉树的遍历及线索二叉树
gygkhd的博客
06-26 791
二叉树的遍历是指按照一定的顺序访问二叉树中所有节点。常见的遍历方法有前序遍历（Preorder Traversal）、中序遍历（Inorder Traversal）、后序遍历（Postorder Traversal）和层次遍历（Level Order Traversal）。前序遍历（Preorder Traversal）： 中序遍历（Inorder Traversal）： 后序遍历（Postorder Traversal）： 层次遍历（Level Order Traversal）： 二、线索
顺序表--数据结构第一关
最新发布
Mr_Xuhhh的博客
06-27 640
主要是以C语言的基础上实现顺序表
数据结构——跳表Skip List
qq_50604294的博客
06-26 751
1.定义跳表（Skip List）：是一种概率性数据结构，由William Pugh在1990年提出，主要用于在有序的元素集合上进行快速的搜索、插入和删除操作。跳表的效率与平衡树相当，但实现起来更简单，它通过维护多层链表来提高查找效率。2. 实现原理在原有的有序链表上面增加了多级索引，通过索引进行二分查找从而实现高效率查找，其每种操作(搜索、插入、删除)的平均复杂性均为O(logn)。3.特点特点描述结构多层链表，每层是下层的子集。查找效率。
数据结构实验指导书C语言版
05-11
"数据结构实验指导书C语言版主要涵盖了线性表的顺序存储结构——顺序表的操作，包括建立、插入、删除和查找等基本操作。实验旨在通过C语言编程实现，让学生掌握顺序表的表示和实现方法，熟悉相关算法，并进行实际...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值