数据结构——顺序表

最新推荐文章于 2023-10-31 17:00:14 发布
最新推荐文章于 2023-10-31 17:00:14 发布
阅读量711 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65635427/article/details/127302282
版权

顺序表的原理

顺序表是简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以
快速定位第几个元素，中间不允许有空值，插入、删除时需要移动大量元素。
顺序表 的三个要素：
用 elems 记录存储位置的基地址
分配一段连续的存储空间 size
用 length 记录实际的元素个数，即顺序表的长度

 

结构体定义

#define     MAX_SIZE 100 struct _SqList{

                 ElemType    *elems;            // 顺序表的基地址

                 int length; // 顺序表的长度

                 int size; // 顺序表总的空间大小

}

顺序表的算法实现（顺序表的初始化）

#define MAX_SIZE 100

typedef struct{

int *elems; // 顺序表的基地址 int length; // 顺序表的长度 int size;  // 顺序表的空间

}SqList;

bool initList(SqList &L) //构造一个空的顺序表L

{

L.elems=new int[MAX_SIZE];        //为顺序表分配Maxsize个空间

if(!L.elems) return false; //存储分配失败

L.length=0;                     //空表长度为0

L.size = MAX_SIZE; return true;

}

 

顺序表增加元素

bool listAppend(SqList &L, int e)

{ if(L.length==MAX_SIZE) return false; //存储空间已满

L.elems[L.length] = e;

L.length++;                 //表长增1

return true;

}

 顺序表插入元素

bool listInsert(SqList &L,int i, int e)

{ if(i<0 || i>=L.length)return false; //i值不合法 if(L.length==MAX_SIZE) return false; //存储空间已满

for(int j=L.length-1; j>=i; j--){

L.elems[j+1]=L.elems[j];//从最后一个元素开始后移，直到第i个元素后移

}

L.elems[i]=e; //将新元素e放入第i个位置 L.length++; //表长增1

return true;

}

 

 顺序表删除元素

bool listDelete(SqList &L,int i)

{ if(i<0 || i>=L.length) return false; //不合法

if(i == L.length-1){//删除最后一个元素，直接删除

L.length--; return true;

}

for (int j=i; j<L.length-1; j++){

L.elems[j] =L.elems[j+1]; //被删除元素之后的元素前移

}

L.length--; return true;

}

 顺序表销毁

void destroyList(SqList &L)

{ if (L.elems) delete []L.elems;//释放存储空间

L.length = 0;

L.size = 0; }

完整代码实现

#include <iostream>
#include <Windows.h>

using namespace std;

#define MAX_SIZE	100

typedef struct
{
	int* elems;
	int length;
	int size;
}SqList;

bool initList(SqList& L)
{
	L.elems = new int[MAX_SIZE];
	if (!L.elems)
	{
		return false;
	}

	L.size = MAX_SIZE;
	L.length = 0;
	return true;
}

bool AppendList(SqList& L, int z)
{
	if (L.length == L.size)
	{
		return false;
	}

	L.elems[L.length] = z;
	L.length += 1;

	return true;
}

bool insertList(SqList& L, int z, int i)
{
	if (L.length == L.size || i<0)
	{
		return false;
	}

	//插入的数在顺序表末尾
	if (L.length - 1 == i)
	{
		L.elems[L.length] = z;
		L.length += 1;
		return true;
	}

	//插入的数没在顺序表末尾
	for (int j = L.length - 1; i <= j; j--)
	{
		L.elems[j + 1] = L.elems[j];
	}

	L.elems[i] = z;
	L.length += 1;
	return true;
}

bool deleteList(SqList& L, int z, int i)
{
	if (L.elems==NULL)
	{
		cout << "数据为空！" << endl;
		return false;
	}

	for (int j = i; j <= L.length-2 ; j++)
	{
		L.elems[j] = L.elems[j + 1];
	}

	L.length = L.length - 1;
	return true;
}

bool destroyList(SqList& L)
{
	if (L.elems)
	{
		delete[]L.elems;
	}

	L.length = 0;
	L.size = 0;
	return true;
}

void printList(SqList& L)
{
	cout << "数据有：" << endl;

	for (int i = 0; i < L.length; i++)
	{
		cout << L.elems[i] << " ";
	}
}

int main1(void)
{
	SqList list;
	int x = 0;

	//初始化顺序表
	initList(list);
	
	//追加数据
	for (int i = 0; i < 10; i++)
	{
		AppendList(list, i);
	}
	printList(list);
	cout << endl;
	
	cout << "请输入你要插入的数据和对应位置：";
	insertList(list, 9, 3);
	printList(list);

	cout << "请输入你要删除的数据和对应位置：";
	deleteList(list, 9, 3);
	printList(list);

	//销毁顺序表
	cout << "请销毁顺序表：";
	destroyList(list);
	

	system("pause");
	return 0;
}

顺序表的企业级应用案例：

高并发 WEB 服务器中顺序表的应用

高性能的 web 服务器 Squid 每秒可处理上万并发的请求，从网络连接到服务器的客户端与服务器端在交互时会保持一种会话（和电话通话的场景类似）。服务器端为了管理好所有的客户端连接，给每个连接都编了一个唯一的整数编号，叫做文件句柄，简称 fd.

为了防止某些恶意连接消耗系统资源，当某个客户端连接超时（在设定的一定时

间内没有发送数据）时，服务器就需要关闭这些客户端的连接具体

实现方案：

1. 当有新的请求连到服务器时，如果经过服务器频率限制模块判断，貌似恶意连接，则使用顺序表来保存此连接的超时数据，超时值使用时间戳来表示,时间戳是指格林威治时间 1970 年 01 月 01 日 00 时 00 分 00 秒(相当于北京时间 1970 年 01 月 01 日

08 时 00 分 00 秒)起至现在的总秒数，其结构体定义如下：

typedef struct {

        int fd ;

        time_t timeout; // 使用超时时刻的时间戳表示

}ConnTimeout;

 2. 服务器程序每隔一秒钟扫描一次所有的连接，检查是否超时，如果存在超时的

连接，就关闭连接，结束服务，同时将顺序表中的记录清除！

代码如下：

webServer.cpp

#include <iostream>
#include <time.h>
#include <Windows.h>
#include "webServer.h"

using namespace std;

static void checkTimeouts(TimeoutSqList& list, time_t now);

int main(void)
{
	time_t now, end;
	time_t last_timeout;
	TimeoutSqList list;

	time(&now);
	end = now + 60;
	last_timeout = now;

	initList(list);

	//1.模拟频率限制模块通过判断分析，增加恶意连接到顺序表中
	for (int i = 0; i < 10; i++)
	{
		ConnTimeout e;
		e.fd = i;
		e.timeout = now + 5 + 2 * i; 
		AppendList(list, e);
	}

	printList(list);

	do
	{
		if (last_timeout + 0.999 < now)
		{
			checkTimeouts(list, now);//检查超时的连接
			last_timeout = now;
		}
		Sleep(10);//防止cpu空转

		time(&now);
	} while (now < end);


	/*time_t now;

	time(&now);
	cout << "当前的时间戳 - timestamp:" << now << endl;
	Sleep(2000);
	time(&now);
	cout << "两秒以后的时间戳 - timestamp:" << now << endl;*/

	system("pause");
	return 0;
}

void checkTimeouts(TimeoutSqList& list, time_t now)
{
	int fd, i;
	
	cout << "检查超时fd……\n";

	for (i = 0; i < list.length; i++)
	{
		if (list.elems[i].timeout > now)
		{
			continue;
		}

		//超时，清理连接
		fd = list.elems[i].fd;
		//关闭连接
		printf("连接[fd=%d] 已经超时，关闭连接!\n", fd);

		//删除顺序表中的元素
		i--;
		deleteList(list, i);
		
	}
}

TimeoutSqList.cpp

#include "webServer.h"
#include <iostream>
#include <Windows.h>


using namespace std;


bool initList(TimeoutSqList& L)
{
	L.elems = new ConnTimeout[MAX_SIZE];
	if (!L.elems)
	{
		return false;
	}

	L.size = MAX_SIZE;
	L.length = 0;
	return true;
}

bool AppendList(TimeoutSqList& L, ConnTimeout z)
{
	if (L.length == L.size)
	{
		return false;
	}

	L.elems[L.length] = z;
	L.length += 1;

	return true;
}

bool insertList(TimeoutSqList& L, ConnTimeout z, int i)
{
	if (L.length == L.size || i < 0)
	{
		return false;
	}

	//插入的数在顺序表末尾
	if (L.length - 1 == i)
	{
		L.elems[L.length] = z;
		L.length += 1;
		return true;
	}

	//插入的数没在顺序表末尾
	for (int j = L.length - 1; i <= j; j--)
	{
		L.elems[j + 1] = L.elems[j];
	}

	L.elems[i] = z;
	L.length += 1;
	return true;
}

bool deleteList(TimeoutSqList& L, int i)
{
	if (L.elems == NULL)
	{
		cout << "数据为空！" << endl;
		return false;
	}

	for (int j = i; j <= L.length - 2; j++)
	{
		L.elems[j] = L.elems[j + 1];
	}

	L.length = L.length - 1;
	return true;
}

bool destroyList(TimeoutSqList& L)
{
	if (L.elems)
	{
		delete[]L.elems;
	}

	L.length = 0;
	L.size = 0;
	return true;
}

void printList(TimeoutSqList& L)
{
	cout << "当前：" << L.size << "，已保存元素的个数 length：" << L.length << endl;

	for (int i = 0; i < L.length; i++)
	{
		cout << "fd：" << L.elems[i].fd << "，timeout：" << L.elems[i].timeout << endl;
	}
}

webServer.h

#ifndef _WEB_SERVER_H_
#define _WEB_SERVER_H_

#include <time.h>

#define MAX_SIZE 100

typedef struct
{
	int fd;
	time_t timeout;//使用超时时刻的时间戳表示
}ConnTimeout;

typedef struct
{
	ConnTimeout* elems; //顺序表的基地址
	int length;			//顺序表的长度
	int size;			//顺序表的大小
}TimeoutSqList;

//顺序表的接口
bool initList(TimeoutSqList& L);
bool AppendList(TimeoutSqList& L, ConnTimeout z);
bool deleteList(TimeoutSqList& L, int i);
bool destroyList(TimeoutSqList& L);
void printList(TimeoutSqList& L);


#endif

会飞的鱼-blog
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构顺序表c语言
qq_42764860的博客
04-18 320
#include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef int ElemType; typedef struct{ ElemType elem[MaxSize]; int length; }SqList;//定义顺序表结构体 void InitList(SqList &L) {L=(SqL...
数据结构之顺序表
qq_53822523的博客
05-27 2319
数据结构顺序表之增删查改的最全攻略
＜数据结构＞ 顺序表
bit_zyx的博客
03-13 9328
目录 一、顺序表介绍 二、准备工作 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
【数据结构】顺序表实例探究
最新发布
qq_64818885的博客
10-31 289
typedef是类型定义的意思。typedef struct 是为了使用这个结构体方便。若struct SeqList {}这样来定义结构体的话。在申请SeqList 的变量时，需要这样写，struct SeqList n;若用typedef，可以这样写，typedef struct SeqList{}SL;。在申请变量时就可以这样写，SL n;区别就在于使用时，是否可以省去struct这个关键字。//给int类型起一个别名——SLDataType
C语言，线性表(顺序表 链表)
yin的博客
01-24 893
C语言数据结构中两个常见的线性表，用来存储数据等； 一、建立顺序表 定义  将线性表中的元素相继存放在一个连续的存储空间中。            可利用一维数组描述存储结构 特点   线性表的顺序存储方式 遍历   顺序访问, 可以随机存取 +++++++++++++++++++++++++++++++++++ 顺序表代码： #include #define MAXSIZE
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
数据结构C++顺序表
03-04
本主题聚焦于一种基础且重要的数据结构——顺序表，尤其关注如何在C++中实现这一概念。 顺序表是一种线性数据结构，其中元素在内存中按顺序存储。在C++中，我们可以使用数组来实现顺序表。这种结构的优点是访问速度...
数据结构实验——顺序表
12-22
顺序表作为数据结构的一种，是我们在学习和实践中经常会遇到的概念。在这个实验中，我们将深入探讨顺序表的实现及其相关操作。 顺序表是一种线性数据结构，它的元素在内存中是连续存放的，就像数组一样。每个元素都...
顺序表（数据结构）
outdated_socks的博客
04-07 5351
顺序表详解
【数据结构】- 顺序表详解(动图演示！！！！）
success
08-23 902
顺序表(SeqList)是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
顺序表（顺序存储结构）
weixin_63032791的博客
05-29 2005
顺序存储结构会申请一段连续的内存空间来存储数据，下面详解一下顺序表的各大使用 在此之前必须要了解一个知识点：当传参的时候，如果你需要改变这个参数的数值，则需要传递这个参数变量的地址，当你不需要改变它的数值的时候，只需要传递该参数就行，这个对于非常学习数据结构十分重要。 相关的头文件定义： #include "stdio.h" #include "stdlib.h" #include "math.h" #include "time.h" #define OK 1 #define E
数据结构与算法 2 线性表
神东的博客
09-18 304
目录 2.1 顺序表的形式 2.2 顺序表的结构与实现 顺序表的两种基本实现方式 元素存储区替换 元素存储区扩充 2.3顺序表的操作 2.4 python中的顺序表 list的基本实现技术 2.1 顺序表的形式 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生...
顺序表的原理与初始化
骆驼胡杨的博客
07-22 471
顺序表是简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以 快速定位第几个元素，中间不允许有空值，插入、删除时需要移动大量元素。 顺序表的三个要素： 用 elems 记录存储位置的基地址 分配一段连续的存储空间 size 用 length 记录实际的元素个数，即顺序表的长度 结构体定义 #define MAX_SIZE 100 //表示顺序表的空间大小 struct _SqList{ ElemType *elems; // 顺序表的基地址 int length;
数据结构之顺序表：顺序表的结构及基本操作
weixin_44180787的博客
09-04 5205
目录一、数据结构1.1 算法与数据结构的区别二、顺序表2.1 顺序表的基本形式【重点】2.2 顺序表的两种基本实现方式【重点】1、一体式结构：2、分离式结构:2.3 元素存储区替换与扩充1. 元素存储区的替换2. 元素存储区的扩充2.4 顺序表的操作1. 增加元素2. 删除元素2.5 Python中的顺序表 一、数据结构 数据结构指数据对象中数据元素之间的关系。 计算机只有三种数据类型：int、float、char。存储在内存中，1个int占4个字节。 1.1 算法与数据结构的区别 程序 = 数据结构
c语言(结构体)实现顺序表
wht1000001000wyw的博客
10-06 2054
先创建了这三个文件： SeqList.h头文件是用来声明，Main.cpp文件是主函数文件，SeqList.cpp是用来实现函数。 SeqList.h代码如下： #ifndef _SEQLIST_H_ #define _SEQLIST_H_ #include<stdio.h> #include<malloc.h> #include<assert.h> #define SEQLIST_INIT_SIZE 8 // 容量大小，可以自己设置 typedef int ElemT
c语言结构体在顺序表中的实现
qq_45853287的博客
11-12 2532
c语言结构体在顺序表中的实现 #define MAX 100 typedef int datatype; typedef struct { datatype elem[100]; int last; }List,*SeqList;//定义顺序表的类型 SeqList InitList()//初始化顺序表 { SeqList L; L=(SeqList)malloc(sizeof(Liat)...
第2章线性表1
08-04
线性表是一种基本的线性数据结构，它由一组具有线性逻辑关系的数据元素组成，可以在线性表的任意位置进行插入和删除数据元素的操作。线性表的数据元素之间具有顺序关系，每个元素除了第一个和最后一个之外，都有一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

会飞的鱼-blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值