0
点赞
收藏
分享

微信扫一扫

数据结构之"顺序表"

拾杨梅记 2023-10-03 阅读 41
顺序表SQL数据C/C++后端开发

数据结构之"顺序表"_SQL

前言

🎈个人主页:🎈 :✨✨✨初阶牛✨✨✨ 🐻推荐专栏: 🍔🍟🌯 c语言初阶 🔑个人信条: 🌵知行合一 🍉本篇简介:>:讲解数据结构的入门知识,线性结构之顺序表. 金句分享: ✨人最高级的炫耀,是你这一生拒绝过什么.✨

@TOC

一、线性表

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

二、顺序表

数据结构之"顺序表"_顺序表_02

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

顺序表一般分为;两种:1.静态顺序表 2.动态顺序表

静态顺序表实际作用不大,本篇主要讲解动态顺序表.

2.1 静态顺序表简单介绍:

数据结构之"顺序表"_SQL_03

静态顺表是指顺序表的容量是固定的,如果看过c语言实现通讯录的友友们,对于静态顺序表可以轻松拿捏.

2.2 动态顺序表:

数据结构之"顺序表"_SQL_04

三、顺序表的常见操作(接口)

3.1 顺序表的类型声明:

//动态版
typedef int DataType;
#define  MAX 10
typedef struct SQList
{
	DataType* data;//指向一段连续的内存空间
	int size;//代表当前顺序表的长度
	int capacity;//表示最大容量
}SQL;

3.2 顺序表的初始化

动态顺序表虽然容量没有限制,会自动扩容,但是也要设置初始值,当达到初始值的最大限制时,才会去动态扩容.

SQL SL;//用顺序表类型创建一个SL顺序表
	InitSQL(&SL);

顺序表的初始化是需要修改顺序表中的成员的,所以需要传址调用,否则形参不会影响实参.

void InitSQL(SQL* SL)
{
	assert(SL);//防止传入空指针
	SL->capacity = MAX;
	SL->size = 0;//顺序表初始状态,当前数据量为0
	SL->data = (DataType*)malloc(sizeof(DataType) * MAX);//初始化顺序表大小
	if (SL->data == NULL)
	{
		printf("初始化申请空间失败.\n");
	}
}

3.3 "增容"函数

当顺序表需要增容时,increase函数利用realloc函数对data指针指向的空间,重新分配合适大小.

DataType* increase(SQL* SL)
{
	assert(SL);
	SL->capacity *= 2;//增容扩大为原来的两倍,这里根据情况,可自由选择每次扩容的增量
	DataType* ret=(DataType*)realloc(SL->data,sizeof(DataType) * SL->capacity);//重新申请一段增容后大小的空间.
	assert(ret);//如果增容失败,则报错.
	return ret;
}

3.4 顺序表的"插入"操作:

顺序表的"尾插"

顺序表的尾插很简单,size为当前顺序表的数据个数,将其作为下标,刚好可以指向新的位置(尾部的下一个位置),将新元素插入后,size自增1,可完成顺序表的尾插操作.

数据结构之"顺序表"_SQL_05

尾插:

  1. 插入操作之前都需要先判断顺序表是否已满.
  2. 以size作为下标,将新元素插入进数组.
  3. size++,顺序表长度+1.

注意:

执行插入操作之前,要先判断目前的顺序表是否已经达到最大容量(capacity),如果顺序表已满,则需要调用增容函数(increase),对函数进行增容.

代码:

//顺序表的尾插
void PushBack(SQL* SL, DataType x)
{
	assert(SL);
	if (SL->size == SL->capacity)//
	{
		SL->data = increase(SL);//调用增容函数,进行动态扩容
	}
	SL->data[SL->size] = x;
	SL->size++;
}

顺序表的"头插"

顺序表的头插就显得稍微复杂一些,效率不高,需要移动数据.

数据结构之"顺序表"_数据_06

头插:

  1. 插入操作之前都需要先判断顺序表是否已满.
  2. 将所有的原有数据向后移动一个位置. (这里只能从最后一个位置开始往后移,如果从前面开始移动数据,会将后面的数据覆盖,导致数据出错.)
  3. 将新数据插入进数组首位置.
  4. size+1,表示顺序表长度+1

//顺序表的头插
void PushFront(SQL* SL, DataType x)
{
	assert(SL);
	//同样在进行插入操作之前,要先判断是否.
	if (SL->size == SL->capacity)
	{
		SL->data = increase(SL);
	}
	for (int i = SL->size; i > 0; i--)//将原来数据往后移
	{
		SL->data[i] = SL->data[i - 1];
	}
	//将新的数据插入到数组首位置
	SL->data[0] = x;
	SL->size++;
}

3.5 顺序表的"判空"

size=0时,表示顺序表中没有元素,即顺序表为空.

顺序表如果为空,则返回"真"顺序表不为空,则返回"假".

//判断是否为空顺序表
bool Empty(SQL* SL)
{
	assert(SL);
	if (SL->size == 0)
	{
		return true;
	}
	else 
		return false;
}

3.6 顺序表的删除操作

顺序表的"尾删"

顺序表的尾删也是很舒服的.

尾删:

  1. 判空:进行删除元素的操作之前,我们应当先对顺序表进行"判空"操作,如果顺序表为空,则不能删除
  2. .size--,即长度-1.

顺序表的尾删操作没有必要真的将最后一个数据删除,只需要调整size的值,那样我们就不能访问到已经删除的元素,这也就等于删除了.

代码:

void PopBack(SQL* SL)
{
	assert(SL);
	assert(!Empty(SL));
	SL->size--;
}

顺序表的"头删"

  顺序表的头删效率不高,需要将数据从第二个元素开始,往后的所有元素(包括第二个元素)向前移动一个位置.

数据结构之"顺序表"_数据_07

//顺序表的头删
void PopFront(SQL* SL)
{
	assert(SL);
	assert(!Empty(SL));
	for (int i = 0; i < SL->size-1; i++)//将后面的数据向前覆盖
	{
		SL->data[i] = SL->data[i + 1];
	}
	SL->size--;
}

3.7 顺序表的指定位置"插入"

//函数声明.h

//指定位置插入元素,位置是下标+1
void SLInsert(SQL* SL, int pos, DataType x);

提供给该函数要插入的元素及其要被插入的位置.

步骤:

  1. 判断插入的位置是否合法.
  2. 插入操作之前都需要先判断顺序表是否已满.
  3. 将数据从最后一个元素开始到pos位置结束(包括pos处的元素),向后移动一个元素.
  4. 将数据插入到pos位置处.
  5. size++,顺序表的长度+1

该函数主要注意点有两个:

  1. pos位置的合法判断.

pos的取值范围应该是,[1,size+1].不理解时可以举个例子:

数据结构之"顺序表"_数据_08

  1. 需要移动的元素的下标的确定.

理解完这两点,代码就不难写了.

代码:

//指定位置的插入
void SLInsert(SQL* SL, int pos, DataType x)
{
	assert(SL);
	assert(!(pos < 0 || pos > SL->size+1));//这里可以在最后一个位置的后面插入,例如:size=5时,可以在6号位置插入
	
	//老样子,插入之前先检查顺序表是否已满
	if (SL->size == SL->capacity)
	{
		SL->data = increase(SL);
	}
	int i = 0;
	//移动数据
	for ( i = SL->size; i > pos - 1; i--)
	{
		SL->data[i] = SL->data[i - 1];
	}
	SL->data[pos-1] = x;
	SL->size++;
}

图解:

数据结构之"顺序表"_SQL_09

此时我们不妨可以利用SLInsert函数来简写尾插和头插.

尾插:之所以是size+1,是因为位置是坐标+1

void PushBack(SQL* SL, DataType x)
{
	SLInsert(SL, SL->size+1, x);
}

头插:之所以是0+1,也是因为位置是坐标+1

//顺序表的头插
void PushFront(SQL* SL, DataType x)
{
	SLInsert(SL, 0 + 1, x);
}

3.8 顺序表的指定位置"删除"

看到这里,相信对于pos的位置范围应该不难判断了吧.

/指定位置删除
void SLErase(SQL* SL, int pos)
{
	assert(SL);
	assert(!Empty(SL));
	assert(!(pos<0 || pos>SL->size));//删除只能在[1-size]范围
	for (int i = pos - 1; i < SL->size-1; i++)
	{
		SL->data[i] = SL->data[i + 1];
	}
	SL->size--;
}

修改后的头删:

//顺序表的头删
void PopFront(SQL* SL)
{
	SLErase(SL, 0 + 1);
}

修改后的尾删:

void PopBack(SQL* SL)
{
	SLErase(SL, SL->size);
}

3.9 顺序表的"打印"

void PrintSQL(SQL* SL)//最好是传指针,保证接口的统一性,传指针的时候记得断言
{
	if (SL->size == 0)
	{
		printf("该顺序表为空.\n");
		return;
	}
	for (int i = 0; i < SL->size; i++)
	{
		printf("%d ", SL->data[i]);
	}
	printf("\n");
}

3.10 顺序表的"查找"

要查找顺序表中的某个值,只需要遍历这个顺序表,依次比较即可.(如果数据有重复,该函数只返回第一次遇到的目标值)

//查找函数
//查找成功返回元素的下标.
//查找失败,返回-1.(因为下标不可能为负数).
int Find(SQL SL, DataType x)
{
	for (int i = 0; i < SL.size; i++)
	{
		if (SL.data[i] == x)
		{
			return i;
		}
	}
	//遍历完顺序表都没找到时.
	return -1;
}

3.11 顺序表的"销毁"

顺序表的销毁及其简单.

1.将data指针释放并置空.2.将capacity和size设置为0.

//顺序表的销毁后记得要将顺序表置空,该函数不会置空操作.
void DestorySQL(SQL* SL)
{
	assert(SL);
	free(SL->data);
	SL->data = NULL;
	SL->size = 0;
	SL->capacity = 0;

}

好了,关于顺序表牛牛就讲到这里了.如果文章有帮助的话,记得三连支持一波哦!💗💗💗

如果文章中有部分错误之处,可以私信牛牛,互相讨论哦!!!

数据结构之"顺序表"_数据_10

四.总代码:

函数声明区(SQList.h)

//SQList.h
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
//动态版
typedef int DataType;
#define  MAX 10
typedef struct SQList
{
	DataType* data;//指向一段连续的内存空间
	int size;//代表当前顺序表的长度
	int capacity;//表示最大容量
}SQL;

/*
//静态版
#define  MAX 10
typedef int DataType;
typedef struct SQList
{
	DataType data[MAX];//大小固定的数组
	int size;//代表当前顺序表的长度
}SQL;
*/

void InitSQL(SQL* SL);
//顺序表的尾插
void PushBack(SQL* SL, DataType x);
//顺序表的头插
void PushFront(SQL* SL, DataType x);

//顺序表的尾删
void PopBack(SQL* SL);
//顺序表的头删
void PopFront(SQL* SL);

int Find(SQL SL, DataType x);//顺序表的查找,输入元素,返回下标,找不到返回-1;


//指定位置删除,位置是下标+1
void SLErase(SQL* SL, int pos);

//指定位置插入元素,位置是下标+1
void SLInsert(SQL* SL, int pos, DataType x);

DataType* increase(SQL* SL);//用于增容
//打印顺序表
//void PrintSQL(SQL SL);
void PrintSQL(SQL* SL);

//顺序表的销毁
void DestorySQL(SQL SL);

函数实现区(SQList.c)

#define _CRT_SECURE_NO_WARNINGS 1
#include "SQList.h"
void InitSQL(SQL* SL)
{
	assert(SL);
	SL->capacity = MAX;
	SL->size = 0;
	SL->data = (DataType*)malloc(sizeof(DataType) * SL->capacity);//初始化顺序表大小
	if (SL->data == NULL)
	{
		printf("初始化申请空间失败.\n");
	}
}
//动态扩容函数
DataType* increase(SQL* SL)
{
	assert(SL);
	SL->capacity *= 2;//增容扩大为原来的两倍
	DataType* ret=(DataType*)realloc(SL->data,sizeof(DataType) * SL->capacity);//重新申请一段增容后大小的空间.
	assert(ret);
	return ret;
}
//顺序表的尾插
void PushBack(SQL* SL, DataType x)
{
	/*assert(SL);
	if (SL->size == SL->capacity)
	{
		SL->data = increase(SL);
	}
	SL->data[SL->size] = x;
	SL->size++;*/
	//上面是不调用SLInsert之前
	SLInsert(SL, SL->size+1, x);
}

//顺序表的头插
void PushFront(SQL* SL, DataType x)
{
	//assert(SL);
	//if (SL->size == SL->capacity)
	//{
	//	SL->data = increase(SL);
	//}
	//for (int i = SL->size; i > 0; i--)//将原来数据往后移
	//{
	//	SL->data[i] = SL->data[i - 1];
	//}
	//SL->data[0] = x;
	//SL->size++;
	//上面是不调用SLInsert之前
	SLInsert(SL, 0 + 1, x);
}

//判断是否为空顺序表
bool Empty(SQL* SL)
{
	assert(SL);
	if (SL->size == 0)
	{
		return true;
	}
	else 
		return false;
}

//顺序表的尾删
void PopBack(SQL* SL)
{
	/*assert(SL);
	assert(!Empty(SL));
	SL->size--;*/
	//上面是不调用SLErase函数之前
	SLErase(SL, SL->size);
}


//顺序表的头删
void PopFront(SQL* SL)
{
	//assert(SL);
	//assert(!Empty(SL));
	//for (int i = 0; i < SL->size-1; i++)//将后面的数据向前覆盖
	//{
	//	SL->data[i] = SL->data[i + 1];
	//}
	//SL->size--;
	//上面是不调用SLErase函数之前
	SLErase(SL, 0 + 1);
}

//void PrintSQL(SQL SL)//这是不传指针版本
//{
//	if (SL.size == 0)
//	{
//		printf("该顺序表为空.\n");
//		return;
//	}
//	for (int i = 0; i < SL.size; i++)
//	{
//		printf("%d ", SL.data[i]);
//	}
//	printf("\n");
//}

void PrintSQL(SQL* SL)//最好是传指针,保证接口的统一性,传指针的时候记得断言
{
	if (SL->size == 0)
	{
		printf("该顺序表为空.\n");
		return;
	}
	for (int i = 0; i < SL->size; i++)
	{
		printf("%d ", SL->data[i]);
	}
	printf("\n");
}

//查找函数
int Find(SQL SL, DataType x)
{
	for (int i = 0; i < SL.size; i++)
	{
		if (SL.data[i] == x)
		{
			return i;
		}
	}
	//遍历完顺序表都没找到时.
	return -1;
}

//指定位置删除操作
void SLErase(SQL* SL, int pos)
{
	assert(SL);
	assert(!Empty(SL));
	//这里当时忘了pos的位置检查
	assert(!(pos<0 || pos>SL->size));//删除只能在[1-size]范围
	for (int i = pos - 1; i < SL->size-1; i++)
	{
		SL->data[i] = SL->data[i + 1];
	}
	SL->size--;
}


//指定位置插入操作.
void SLInsert(SQL* SL, int pos, DataType x)
{
	assert(SL);
	assert(!(pos < 0 || pos > SL->size+1));//这里可以在最后一个位置的后面插入,例如:size=5时,可以在6号位置插入
	
	//老样子,插入之前先检查顺序表是否已满
	if (SL->size == SL->capacity)
	{
		SL->data = increase(SL);
	}
	int i = 0;
	for ( i = SL->size; i > pos - 1; i--)
	{
		SL->data[i] = SL->data[i - 1];
	}
	SL->data[pos-1] = x;
	SL->size++;
}


//顺序表的销毁后记得要将顺序表置空,该函数不会对SL指针置空操作.
void DestorySQL(SQL* SL)
{
	assert(SL);
	free(SL->data);
	SL->data = NULL;
	SL->size = 0;
	SL->capacity = 0;

}

主测试区(test.c)

#define _CRT_SECURE_NO_WARNINGS 1
#include"函数声明区.h"
void test1()
{
	SQL SL;
	InitSQL(&SL);
	printf("判断是否为空顺序表的打印.\n");
	PrintSQL(&SL);

	printf("尾插1,2,3,4,5,6,7,8后:\n");
	PushBack(&SL, 1);
	PushBack(&SL, 2);
	PushBack(&SL, 3);
	PushBack(&SL, 4);
	PushBack(&SL, 5);
	PushBack(&SL, 6);
	PushBack(&SL, 7);
	PushBack(&SL, 8);
	PrintSQL(&SL);

	printf("头插-1,-2,-3后:\n");
	PushFront(&SL, -1);
	PushFront(&SL, -2);
	PushFront(&SL, -3);
	PrintSQL(&SL);
	printf("尾删两次后\n");
	PopBack(&SL);
	PopBack(&SL);
	PrintSQL(&SL);

	printf("头删2次后:\n");
	//printf("头删到空\n");
	PopFront(&SL);
	PopFront(&SL);
	//PopFront(&SL);
	//PopFront(&SL);
	//PopFront(&SL);
	//PopFront(&SL);
	//PopFront(&SL);
	//PopFront(&SL);
	//PopFront(&SL);
	//PopFront(&SL);
	PrintSQL(&SL);
int main()
{
	test1();
	return 0;
}

举报

相关推荐

数据结构之顺序表

数据结构java链表

数据结构1之顺序表

数据结构

数据结构[线性表之顺序表]

数据结构线性表数据顺序存储结构Java后端开发

数据结构线性表之顺序表

线性表数据顺序存储结构Java后端开发

数据结构---顺序表

学习spring bootspringbootspringjavalog

数据结构—顺序表

大数据物联网云开发SDKAppweb app

数据结构——顺序表

数据结构c++

数据结构（顺序表）

java-ee数据库java前端

数据结构顺序表

顺序表i++数据Java编程语言

【数据结构】顺序表

线性表数据顺序表C/C++后端开发
0 条评论