AI 助理
备案控制台
开发者社区 人工智能 文章 正文

【数据结构】万字深入浅出讲解顺序表（附原码 | 超详解）

2023-02-09 99
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【数据结构】万字深入浅出讲解顺序表（附原码 | 超详解）

![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/83a3b57f7f774db8a82b8877635eb1c1.png#pic_center)


> 🚀write in front🚀

> 📝个人主页：认真写博客的夏目浅石.

> 🎁欢迎各位→点赞👍 + 收藏⭐️ + 留言📝

> 📣系列专栏：[C语言实现数据结构](https://blog.csdn.net/congfen214/category_12144557.html?spm=1001.2014.3001.5482)

> 💬总结：希望你看完之后，能对你有所帮助，不足请指正！共同学习交流 🖊

> ✉️==如果无聊的话，就来逛逛我的博客栈吧==[stack-frame.cn](https://stack-frame.cn/)


@[TOC](文章目录)


---


# 前言

![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/f4e0159841ab450d861dde9e8fb5ba0d.gif#pic_center)

这几天看了数据结构的顺序表这一节，真的收获很大，第一次看没有动手敲代码就是感觉学了和没学一样，今天也是从新又看了一遍，并且边学边敲代码，终于算是非常理解顺序表这个东西了，今天就**把我所学到的知识给大家分享一下。**


---


`提示：以下是本篇文章正文内容，下面案例可供参考`


# 一、线性表概念


## 1.1线性表

>线性表（linear list）是n个**具有相同特性的数据元素的有限序列**。 线性表是一种在实际中广泛使

用的数据结构，常见的线性表：**顺序表、链表、栈、队列、字符串...**


>线性表在==逻辑上==是线性结构，也就说是连续的一条直线。但是在==物理结构上==并不一定是连续的，

线性表在物理上存储时，通常以数组和链式结构的形式存储。


![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/927de6f01b5f4794b443ae448fca26a3.png)



# 二、顺序表实现

## 2.1概念及结构


顺序表是用`一段物理地址连续的存储单元依次存储数据元素的线性结构`，一般情况下采用数组存

储。在数组上完成数据的==增删查改。==


顺序表一般可以分为：

- `静态顺序表`：使用定长数组存储。

- `动态顺序表`：使用动态开辟的数组存储.


**以下是静态顺序表：**


```c

#pragma once//防止被重复的包含


#define N 100

typedef int SQDataType;


typedef struct SeqList

{

SQDataType a[N];

SQDataType size; //有效数据

}SL;

//增删查改等接口函数


//对于结构体的定义typedef struct SeqList SL;


//静态顺序表

//问题：给少了不够用，给多了用不完浪费，不能灵活控制


```

**由于静态顺序表无法伸缩变换数组，所以今天着重讲解动态的顺序表**


**动态顺序表的实现：**


```c

//#pragma once

//#define N 10 对于动态线性表这个就没有用了

typedef int SQDataType;


typedef struct SeqList

{

SQDataType* a;

int size;   //有效数据的个数

int capacity; //容量

}SL;

```


## 2.2 接口的布局

静态顺序表只适用于`确定知道需要存多少数据的场景`。静态顺序表的定长数组导致N定大

了，空间开多了浪费，开少了不够用。所以现实中基本都是使用`动态顺序表`，**根据需要动态

的分配空间大小，所以下面我们实现动态顺序表。**


我们需要的**工程文件**：


- **SeqList.h**：用于存放函数声明、包含头文件、定义宏等等。

- **test.c**：用于写程序整体执行逻辑等。

- **SeqList.c**：用于写函数定义，写函数实现等。


## 2.3接口的实现


### SeqList.h的代码


```c

#include<string.h>

#include<stdio.h>//printf

#include<stdlib.h>//realloc

#include<assert.h>//断言


typedef int SQDataType; //方便修改数据


typedef struct SeqList //重命名方便书写

{

SQDataType* a;

int size;   //有效数据的个数

int capacity; //容量

}SL;



//初始化与销毁：

void SeqListInit(SL* ps);//初始化顺序表

void SeqListCheckCapcity(SL* ps)//创建新空间---扩容

void SeqListDestory(SL* ps)//销毁空间


//顺序表的插入操作---头插，尾插，任意插

void SeqListPushBack(SL* ps,SQDataType x);//顺序表尾插 o(1)

void SeqListPushFront(SL* ps,SQDataType x);//顺序表头插  o(n)

void SeqListInsert(SL* ps,int pos,SQDataType x) //在顺序表指定下标位置插入数据


//顺序表的删除操作---头删，尾删，任意删

void SeqListPopBack(SL* ps);//顺序表尾删 o(1)

void SeqListPopfront(SL* ps);//顺序表头删 o(n)

void SeqListErase(SL* ps,int pos) //顺序表任意下标删除


//顺序表的查找、打印、寻找

int SeqListFind(SL* ps,SQDataType x) //顺序表查找下标

int  SeqListModity(SL* ps,int pos,SQDataType x)//修改指定下标位置的数据

void SeqListPrint(SL* ps)//打印顺序表元素

```

### SeqList.c 的代码

这里就是实现上述的函数的代码啦~


- **初始化顺序表**

```c

void SeqListInit(SL* ps)

{

aseert(ps)//断言

//初始化

ps->a=NULL;//设置为空

ps->size=0;//设置为0

ps->capacity=0;//设置为0

}

```

- **检查顺序表容量和扩容**

如果顺序表空间足够，那么不需要扩容，通过相关操作插入数据，如果空间不足或者根本没有空间，那么就得扩容。


当顺序表没有空间时，我们开辟四个空间(至少为1个空间)；当顺序表空间不足，我们将当前空间扩大为两倍

```c

void SeqListCheckCapcity(SL* ps)

{

assert(ps!= NULL);  //断言

if(ps->size==ps->capacity)

{

 int newcapacity=ps->capacity==0?4:ps->capacity*2;//如果是0就改为4，不是0就扩大二倍

 SQDataType* tmp=(SQDataType*)realloc(ps->a,newcapacity*sizeof(SQDataType));

 if(tmp==NULL)

 {

  printf("realloc fail\n");//扩容失败

  exit(-1);

 }

 else //扩容成功

 {

  ps->a=tmp;//新的数组对吧

  ps->capacity =newcapacity;//有效的容量

 }

}

}

```


- **销毁顺序表**


```c

void SeqListDestory(SL* ps)//销毁

{

assert(ps != NULL);  //断言

free(ps->a);//释放动态开辟的空间

ps->a=NULL;//置空

ps->capacity=0;//数据个数置0

ps->size=0;//空间容量大小置0

}

```


- **顺序表尾插**


```c

void SeqListPushBack(SL* ps,SQDataType x)//尾插

{

//满了就要扩容

// if(ps->size==ps->capacity)

// {

//  int newcapacity=ps->capacity==0?4:ps->capacity*2;

//  SQDataType* tmp=(SQDataType*)realloc(ps->a,newcapacity*2*sizeof(SQDataType));

//  if(tmp==NULL)

//  {

//   printf("realloc fail\n");

//   exit(-1);

//  }

//  else

//  {

//   ps->a=tmp;//新的数组对吧

//   ps->capacity = newcapacity;//有效的容量

//  }

// }

SeqListCheckCapcity(ps);//扩容函数

ps->a[ps->size]=x;//设置为要改的数x

ps->size++;//让数组长度增加

}

```



**测试：**


```c

void TestSeqList1()

{

SL s1;

SeqListInit(&s1); //初始化顺序表

SeqListPushBack(&s1,1);

SeqListPushBack(&s1,2);

SeqListPushBack(&s1,3);

SeqListPushBack(&s1,4);

SeqListPushBack(&s1,5);

SeqListPushBack(&s1,6);

SeqListPushBack(&s1,7);

SeqListPushBack(&s1,8);

SeqListPushBack(&s1,9);

SeqListPushBack(&s1,10);

SeqListPushBack(&s1,11);

SeqListPrint(&s1);//打印顺序表：下面实现

//销毁顺序表：

SeqListDestory(&s1);

}

int main()

{

TestSeqList1();

//TestSeqList2();

return 0;

}

```

![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/d2e27a320a274512b9a2cca682615ad7.png)


- **顺序表尾删**

每次都在最后一个元素之后插入新的元素

```c

void SeqListPopBack(SL* ps)//尾删

{

assert(ps->size>0);//断言


//ps->a[ps->size-1]=0;

ps->size--;//数组减少

}

```


```c

void TestSeqList2()

{

SL s1;

SeqListInit(&s1);

SeqListPushFront(&s1,1);

SeqListPushFront(&s1,2);

SeqListPushFront(&s1,3);

SeqListPushFront(&s1,4);

SeqListPushFront(&s1,5);

SeqListPushFront(&s1,6);

SeqListPopBack(&s1);

SeqListPopBack(&s1);

SeqListPopfront(&s1);

SeqListPrint(&s1);

}


int main()

{

//TestSeqList1();

TestSeqList2();

return 0;

}

```

![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/986311e61354445ca6a6bc3b26b30d64.png)


- **顺序表头插**

每次都在头结点之后插入新元素，头插法较为重要，当遇到链表的逆置操作时，可以使用头插法实现

```c

void SeqListPushFront(SL* ps,SQDataType x)//头插

{

//1.初始条件

//2.结束条件

//3.迭代过程


//还是要考虑增容的情况

SeqListCheckCapcity(ps);//扩容

int end=ps->size-1;//找到end指针

while(end>=0) //循环右移

{

 ps->a[end+1]=ps->a[end];

 --end;

}

ps->a[0]=x;//插入

ps->size++;//数组加大

}


```

![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/446083fb8d36428883ac127fe2cc461d.png)

**实现：**


```c

void TestSeqList2()

{

SL s1;

SeqListInit(&s1);

SeqListPushFront(&s1,1);

SeqListPushFront(&s1,2);

SeqListPushFront(&s1,3);

SeqListPushFront(&s1,4);

SeqListPushFront(&s1,5);

SeqListPushFront(&s1,6);

SeqListPopBack(&s1);

SeqListPopBack(&s1);

SeqListPopfront(&s1);

SeqListPrint(&s1);

}


int main()

{

//TestSeqList1();

TestSeqList2();

return 0;

}

```

![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/d0e11732e3f54834a7d37a7a55352e39.png)


- **顺序表头删**


```c

void SeqListPopfront(SL* ps)//头删

{

assert(ps->size>0);


int start=1;

while(start<ps->size)

{

 ps->a[start-1]=ps->a[start];

 ++start;

}

ps->size--;

}

```

![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/9fbdc2586c074a028dbfc451634cfaa8.png)



- **打印顺序表**


```c

void SeqListPrint(SL* ps)

{

for(int i=0;i<ps->size;++i)

{

 printf("%d ",ps->a[i]);

}

printf("\n");

}

```


- **顺序表指定下标位置插入数据**

插入操作，在表L中的第i个位置上插入指定元素


想要在第i个位置上插入元素，那么就要找到第i − 1 个结点，然后将新结点插入其后面


```c

void SeqListInsert(SL* ps,int pos,SQDataType x) //任意插入

{

assert(pos<ps->size);

SeqListCheckCapcity(ps);


int end=ps->size-1;

while(end>=pos)

{

 ps->a[end+1]=ps->a[end];

 --end;

}


ps->a[pos]=x;

ps->size++;

}

```


- **顺序表任意下标删除**


但是，使用这个算法有个问题，如果p是最后一个结点，那么当程序执行到p->data = p->next->data这一句时，会出现空指针的错误，所以只能从表头开始依次寻找p的前驱

```c

void SeqListErase(SL* ps,int pos) //任意删除

{

assert(pos<ps->size);


int start=pos+1;

while(start<ps->size)

{

 ps->a[start-1]=ps->a[start];

 ++start;

}

ps->size--;

}

```


- **顺序表查找下标**

`按位查找操作`。获取表L中第i个位置的元素的值

```c

int SeqListFind(SL* ps,SQDataType x) //查找

{

for(int i=0;i<ps->size;++i)

{

 if(ps->a[i] == x)

 {

  return i;

 }

}

return -1;

}

```


- **改指定下标位置的数据**


```c

int  SeqListModity(SL* ps,int pos,SQDataType x)//修改位置的值

{

assert(pos<ps->size);

ps->a[pos]=x;

}

```

# 三、完整代码

>SeqList.h


```c

#include<string.h>

#include<stdio.h>//printf

#include<stdlib.h>//realloc

#include<assert.h>//断言


typedef int SQDataType; //方便修改数据


typedef struct SeqList //重命名方便书写

{

SQDataType* a;

int size;   //有效数据的个数

int capacity; //容量

}SL;



void SeqListInit(SL* ps);//初始化顺序表

void SeqListCheckCapcity(SL* ps)//创建新空间---扩容

void SeqListDestory(SL* ps)//销毁空间



void SeqListPushBack(SL* ps,SQDataType x);//顺序表尾插 o(1)

void SeqListPushFront(SL* ps,SQDataType x);//顺序表头插  o(n)

void SeqListInsert(SL* ps,int pos,SQDataType x) //在顺序表指定下标位置插入数据


void SeqListPopBack(SL* ps);//顺序表尾删 o(1)

void SeqListPopfront(SL* ps);//顺序表头删 o(n)

void SeqListErase(SL* ps,int pos) //顺序表任意下标删除


int SeqListFind(SL* ps,SQDataType x) //顺序表查找下标

int  SeqListModity(SL* ps,int pos,SQDataType x)//修改指定下标位置的数据

void SeqListPrint(SL* ps)//打印顺序表元素

```

>SeqList.c：


```c


//void SeqListInit(SL* ps);

//{

// //初始化

// memset(s1.a,0,sizeof(SQDataType)*N);

// s1.size=0;

//}

//

//void SeqListPushBack(SL* ps,SQDataType x);//尾插

//{

// if(ps->size>=N)

// {

//  printf("SeqList is Full\n");

//  return;

// }

//

// ps->a[ps->size]=x;

// ps->size++;

//}

//以上就是静态

//------------------------------------------------

//下面实现动态


void SeqListInit(SL* ps);

{

//初始化

ps->a=NULL;

ps->size=0;

ps->capacity=0;//开始如果是一个0的话，那么扩容就会失败

}


void SeqListPrint(SL* ps)

{

for(int i=0;i<ps->size;++i)

{

 printf("%d ",ps->a[i]);

}

printf("\n");

}


void SeqListPushBack(SL* ps,SQDataType x);//尾插

{

//满了就要扩容

// if(ps->size==ps->capacity)

// {

//  int newcapacity=ps->capacity==0?4:ps->capacity*2;

////  SQDataType* tmp=(SQDataType*)realloc(ps->a,ps->capacity*2*sizeof(SQDataType));

//  SQDataType* tmp=(SQDataType*)realloc(ps->a,ps->newcapacity*2*sizeof(SQDataType));

//  if(tmp==NULL)

//  {

//   printf("realloc fail\n");

//   exit(-1);

//  }

//  else

//  {

//   ps->a=tmp;//新的数组对吧

//   ps->capacity =newcapacity;//有效的容量

//  }

// }

SeqListCheckCapcity(&ps);

ps->a[ps->size]=x;

ps->size++;

}


void SeqListDestory(SL* ps)//销毁

{

free(ps->a);

ps->a=NULL;

ps->capacity=0;

ps->size=0;

}




void SeqListCheckCapcity(SL* ps)

{

if(ps->size==ps->capacity)

{

 int newcapacity=ps->capacity==0?4:ps->capacity*2;

 SQDataType* tmp=(SQDataType*)realloc(ps->a,newcapacity*sizeof(SQDataType));

 if(tmo==NULL)

 {

  printf("realloc fail\n");

  exit(-1);

 }

 else

 {

  ps->a=tmp;//新的数组对吧

  ps->capacity =newcapacity;//有效的容量

 }

}

}


void SeqListPushFront(SL* ps,SQDataType x);//头插

{

//1.初始条件

//2.结束条件

//3.迭代过程


//还是要考虑增容的情况

SeqListCheckCapcity(&ps);

int end=ps->size-1;

while(end>=0)

{

 ps->a[end+1]=ps->a[end];

 --end;

}

ps->a[0]=x;

ps->size++;

}


void SeqListPopBack(SL* ps)//尾删

{

assert(ps->size>0)


//ps->a[ps->size-1]=0;

ps->size--;

}


void SeqListPopfront(SL* ps)//头删

{

assert(ps->size>0)


int start=1;

while(start<ps->size)

{

 ps->a[start-1]=ps->a[start];

 ++start;

}

ps->size--;

}


void SeqListInsert(SL* ps,int pos,SQDataType x) //任意插入

{

assert(pos<ps->size);

SeqListCheckCapcity(&ps);


int end=ps->size-1;

while(end>=pos)

{

 ps->a[end+1]=ps->a[end];

 --end;

}


ps->a[pos]=x;

ps->size++;

}


void SeqListErase(SL* ps,int pos) //任意删除

{

assert(pos<ps->size)


int start=pos+1;

while(start<ps->size)

{

 ps->a[start-1]=ps->a[start];

 ++start;

}

ps->size--;

}


int SeqListFind(SL* ps,SQDataType x) //查找

{

for(int i=0;i<ps->size;++i)

{

 if(ps->a[i] == x)

 {

  return i;

 }

}

return -1;

}


int  SeqListModity(SL* ps,int pos,SQDataType x)//修改位置的值

{

assert(pos<ps->size);

ps->a[pos]=x;

}

```

>test.c


```c

#include<string.h>

#include<stdio.h>

#include<stdlib.h>

#include<assert.h>


//#pragma once

//#define N 10 对于动态线性表这个就没有用了

typedef int SQDataType;


typedef struct SeqList

{

SQDataType* a;

int size;   //有效数据的个数

int capacity; //容量

}SL;


void SeqListInit(SL* ps)

{

//

//初始化

ps->a=NULL;//设置为空

ps->size=0;//设置为0

ps->capacity=0;//设置为0

}


void SeqListCheckCapcity(SL* ps)

{

assert(ps!= NULL);  //断言

if(ps->size==ps->capacity)

{

 int newcapacity=ps->capacity==0?4:ps->capacity*2;//如果是0就改为4，不是0就扩大二倍

 SQDataType* tmp=(SQDataType*)realloc(ps->a,newcapacity*sizeof(SQDataType));

 if(tmp==NULL)

 {

  printf("realloc fail\n");//扩容失败

  exit(-1);

 }

 else //扩容成功

 {

  ps->a=tmp;//新的数组对吧

  ps->capacity =newcapacity;//有效的容量

 }

}

}


void SeqListPushBack(SL* ps,SQDataType x)//尾插

{

//满了就要扩容

// if(ps->size==ps->capacity)

// {

//  int newcapacity=ps->capacity==0?4:ps->capacity*2;

//  SQDataType* tmp=(SQDataType*)realloc(ps->a,newcapacity*2*sizeof(SQDataType));

//  if(tmp==NULL)

//  {

//   printf("realloc fail\n");

//   exit(-1);

//  }

//  else

//  {

//   ps->a=tmp;//新的数组对吧

//   ps->capacity = newcapacity;//有效的容量

//  }

// }

SeqListCheckCapcity(ps);//扩容函数

ps->a[ps->size]=x;//设置为要改的数x

ps->size++;//让数组长度增加

}


void SeqListPushFront(SL* ps,SQDataType x)//头插

{

//1.初始条件

//2.结束条件

//3.迭代过程


//还是要考虑增容的情况

SeqListCheckCapcity(ps);//扩容

int end=ps->size-1;//找到end指针

while(end>=0) //循环右移

{

 ps->a[end+1]=ps->a[end];

 --end;

}

ps->a[0]=x;//插入

ps->size++;//数组加大

}


void SeqListPopBack(SL* ps)//尾删

{

assert(ps->size>0);//断言


//ps->a[ps->size-1]=0;

ps->size--;//数组减少

}


void SeqListPopfront(SL* ps)//头删

{

assert(ps->size>0);


int start=1;

while(start<ps->size)

{

 ps->a[start-1]=ps->a[start];

 ++start;

}

ps->size--;

}


void SeqListInsert(SL* ps,int pos,SQDataType x) //任意插入

{

assert(pos<ps->size);

SeqListCheckCapcity(ps);


int end=ps->size-1;

while(end>=pos)

{

 ps->a[end+1]=ps->a[end];

 --end;

}


ps->a[pos]=x;

ps->size++;

}


void SeqListErase(SL* ps,int pos) //任意删除

{

assert(pos<ps->size);


int start=pos+1;

while(start<ps->size)

{

 ps->a[start-1]=ps->a[start];

 ++start;

}

ps->size--;

}


int SeqListFind(SL* ps,SQDataType x) //查找

{

for(int i=0;i<ps->size;++i)

{

 if(ps->a[i] == x)

 {

  return i;

 }

}

return -1;

}


int  SeqListModity(SL* ps,int pos,SQDataType x)//修改位置的值

{

assert(pos<ps->size);

ps->a[pos]=x;

}


void SeqListPrint(SL* ps)

{

for(int i=0;i<ps->size;++i)

{

 printf("%d ",ps->a[i]);

}

printf("\n");

}



void TestSeqList1()

{

SL s1;

SeqListInit(&s1);

SeqListPushBack(&s1,1);

SeqListPushBack(&s1,2);

SeqListPushBack(&s1,3);

SeqListPushBack(&s1,4);

SeqListPushBack(&s1,5);

SeqListPushBack(&s1,6);

SeqListPushBack(&s1,7);

SeqListPushBack(&s1,8);

SeqListPushBack(&s1,9);

SeqListPushBack(&s1,10);

SeqListPushBack(&s1,11);

SeqListPrint(&s1);

}


void TestSeqList2()

{

SL s1;

SeqListInit(&s1);

SeqListPushFront(&s1,1);

SeqListPushFront(&s1,2);

SeqListPushFront(&s1,3);

SeqListPushFront(&s1,4);

SeqListPushFront(&s1,5);

SeqListPushFront(&s1,6);

SeqListPopBack(&s1);

SeqListPopBack(&s1);

SeqListPopfront(&s1);

SeqListPrint(&s1);

}


int main()

{

//TestSeqList1();

TestSeqList2();

return 0;

}

```


# 总结

&emsp;&emsp;今天学习了线性表的知识，初次写数据结构的知识，给我的感觉就是，==**学三遍不如手敲代码一遍来的实在**==，所以数据结构的学习我将`多画图，多敲代码来学习`，希望大家吸取经验和我一起学习数据结构，为后面打比赛刷题打下坚实基础。


&emsp;&emsp;我是夏目浅石，希望和你一起学习进步，刷题无数！！！`希望各位大佬`==能一键三连==`支持一下博主`，hhhh~我们下期见喽

![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/img_convert/964d5c594e4c6ccea737be3c6b6bed4e.gif#pic_center)

==如果无聊的话，就来逛逛我的博客栈吧==[stack-frame.cn](https://stack-frame.cn/)


>✨$\textcolor{blue}{原创不易，还希望各位大佬支持一下}$ <br/>

>👍 $\textcolor{9c81c1}{点赞，你的认可是我创作的动力！}$ <br/>

>⭐️ $\textcolor{ed7976}{收藏，你的青睐是我努力的方向！}$ <br/>

>✏️ $\textcolor{98c091}{评论，你的意见是我进步的财富！}$ <br/>

文章标签：
C语言
人工智能
算法
存储
关键词：
数据结构顺序表
认真写博客的夏目浅石.
目录
相关文章
禁默
|
3月前
|
存储 编译器 C语言
数据结构-顺序表详解（看这篇就足够了，哈哈哈）
数据结构-顺序表详解（看这篇就足够了，哈哈哈）
禁默
72 2
三三是该溜子
|
8天前
|
数据库
数据结构中二叉树，哈希表，顺序表，链表的比较补充
二叉搜索树，哈希表，顺序表，链表的特点的比较
三三是该溜子
22 0
数据结构中二叉树，哈希表，顺序表，链表的比较补充
肾透侧视攻城狮
|
2月前
|
存储 算法 安全
2024重生之回溯数据结构与算法系列学习之顺序表【无论是王道考研人还真爱粉都能包会的；不然别给我家鸽鸽丢脸好嘛？】
顺序表的定义和基本操作之插入；删除；按值查找；按位查找等具体详解步骤以及举例说明
肾透侧视攻城狮
35 3
ephemerals__
|
2月前
|
存储 C语言
【数据结构】顺序表（c语言实现）（附源码）
本文介绍了线性表和顺序表的基本概念及其实现。线性表是一种有限序列，常见的线性表有顺序表、链表、栈、队列等。顺序表是一种基于连续内存地址存储数据的数据结构，其底层逻辑是数组。文章详细讲解了静态顺序表和动态顺序表的区别，并重点介绍了动态顺序表的实现，包括初始化、销毁、打印、增删查改等操作。最后，文章总结了顺序表的时间复杂度和局限性，并预告了后续关于链表的内容。
ephemerals__
85 3
肾透侧视攻城狮
|
2月前
|
算法 安全 NoSQL
2024重生之回溯数据结构与算法系列学习之顺序表习题精讲【无论是王道考研人还真爱粉都能包会的；不然别给我家鸽鸽丢脸好嘛？】
顺序表的定义和基本操作之插入；删除；按值查找；按位查找习题精讲等具体详解步骤以及举例说明
肾透侧视攻城狮
27 1
小强在此
|
3月前
|
存储 Java
数据结构第二篇【关于java线性表（顺序表）的基本操作】
数据结构第二篇【关于java线性表（顺序表）的基本操作】
小强在此
49 6
GuGuStudy
|
3月前
|
存储 安全 Java
【用Java学习数据结构系列】探索顺序表和链表的无尽秘密（附带练习唔）pro
【用Java学习数据结构系列】探索顺序表和链表的无尽秘密（附带练习唔）pro
GuGuStudy
30 3
GuGuStudy
|
3月前
|
存储 C语言
探索C语言数据结构：利用顺序表完成通讯录的实现
本文介绍了如何使用C语言中的顺序表数据结构实现一个简单的通讯录，包括初始化、添加、删除、查找和保存联系人信息的操作，以及自定义结构体用于存储联系人详细信息。
GuGuStudy
41 2
椰椰椰耶
|
3月前
|
存储
【数据结构】线性表和顺序表
【数据结构】线性表和顺序表
椰椰椰耶
30 1
努力学习的小廉
|
3月前
|
存储 算法 索引
【数据结构】——顺序表
【数据结构】——顺序表
努力学习的小廉
72 1

热门文章

最新文章

  • 1
    Python编程数据结构的深入理解
  • 2
    掌握Pandas核心数据结构：Series与DataFrame的四种创建方式
  • 3
    K-means聚类算法是机器学习中常用的一种聚类方法，通过将数据集划分为K个簇来简化数据结构
  • 4
    Python 中的数据结构与其他编程语言数据结构的区别
  • 5
    C语言因高效灵活被广泛应用于软件开发。本文探讨了优化C语言程序性能的策略，涵盖算法优化、代码结构优化、内存管理优化、编译器优化、数据结构优化、并行计算优化及性能测试与分析七个方面
  • 6
    Python 中的数据结构和算法优化策略
  • 7
    Python 中数据结构和算法的关系
  • 8
    在C语言中，数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
  • 9
    探索局域网电脑监控软件：Python算法与数据结构的巧妙结合
  • 10
    Pandas数据结构：Series与DataFrame
  • 1
    【Python进阶（七）】——Series数据结构
    186
  • 2
    Redis数据结构精讲：选择与应用实战指南
    1335
  • 3
    深入浅出数据结构之布隆过滤器
    75
  • 4
    数据结构/C++：位图 & 布隆过滤器
    49
  • 5
    数据结构/C++：哈希表
    84
  • 6
    数据结构/C++：红黑树
    47
  • 7
    数据结构/C++：AVL树
    49
  • 8
    栈的基本应用
    64
  • 9
    栈与队列理解
    49
  • 10
    数据结构/C++：二叉搜索树
    54

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法

    • 相关电子书

    更多
  • 如何使用Tair增强数据结构构建丰富在线实时场景
  • Apache Flink 流式应用中状态的数据结构定义升级
  • 低代码开发师（初级）实战教程
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月