C语言：线性表和顺序表
数据结构概述
什么是数据结构
数据结构： 数据结构就是计算机存储，组织，管理数据的方式方法；
数据结构的类型
①根据数据的逻辑结构划分 (数据间关系)
-
集合：数据结构中的元素之间除了"同属一个组织"之外，别无其他关系；
-
线性数据结构： 数据之间 "一对一"的关系，数据具有唯一的前驱和后继，典型代表是链表
-
非线性数据结构：数据之间不具有唯一的前驱和后继。例如： 二维数组，二叉树…，典型代表是二叉树
②根据数据在内存中的存储方式划分
-
顺序结构：各个元素存储在连续的内存空间 ，典型代表是数组
-
链式结构：各个元素存储在不连续的内存空间 ，典型代表是链表
-
索引结构：元素在存储时，不仅存储元素数据，还建立元素附加的索引表来标识元素的地址
-
哈希(散列)结构：元素在存储时，为元素提供关键字，在元素访问时，可根据关键字来访问数据
常见的数据结构
链表 顺序表 树 图 映射 栈 队列…
算法分析【扩展】
算法分析是指算法在正确的情况下，对其优劣的分析。一个好的算法通常是指：
- 算法对应的程序所耗时间少
- 算法对应的程序所耗存储空间少
- 算法结构性好、易读、易移植和调试
数据结构与算法的本质任务，是提高程序的时间空间效率，简单讲就是让程序的执行速度越快越好，所需内存空间越少越好。虽然在很多情况下，程序的时空特性是相互制约的，就像鱼和熊掌不可兼得，但我们可以根据程序实际解决问题的侧重点，去平衡时间和空间的对性能的消耗。
2.1 时间复杂度
一般而言，时间复杂度并不考察一段代码运行所需要的绝对时间，因为不同的计算机的硬件参数不同，考察绝对时间没有意义。==时间复杂度一般指的是代码的语句执行总次数，称为语句频度。==比如：
void counting(int n)
{
for (int i = 0; i < n; i++)
{
printf("本行语句将会出现n次\n");
for (int j = 0; j < n; j++)
{
printf("本行语句将会出现n*n次\n");
}
}
}
在上述代码中，程序执行的语句频度理论是：T(n)=n2+nT(n) = n^2 + nT(n)=n2+n
但一般情况下，我们只关心多项式的最高次幂，于是上述代码的时间复杂度我们表示为：T(n)=O(n2)T(n) = O(n^2)T(n)=O(n2)
这意味着，该程序算法所需要的时间，与传进来的参数n的平方成正比
不同算法的时间复杂度相差很大，如下图所示，随着所处理的问题规模的增大，不同时间复杂度的程序所需要的时间有天壤之别
2.2 空间复杂度
空间复杂度的概念更简单一点，就是一段程序运行时所需的内存字节量
2.3 时空复杂度互换
一段程序的性能指标，既要运行快速，又要节省内存，而通常这两者又是相互制约的，很难兼得。因此在实际解决问题时，会根据需要侧重一方，牺牲另一方
线性表
概念
对于一组拥有n个数据元素的线性表，其严格数学定义是：其中任何一个数据元素 ，有且仅有一个直接前驱 a i−1a~i-1a i−1，有且仅有一个直接后继a i+1a~i+1a i+1 。首元素 无直接前驱，尾元素 无直接后继。满足这种数学关系的一组数据，当中的数据是一个挨着一个的，常被称为一对一关系。反之，如果数据之间的关系不是一对一的，就是非线性的。
举例
生活中的线性表例子非常多，比如一个班级中的以学号编排的学生，一座图书馆中的以序号编排的图书、一条正常排队等候的队列、一摞从上到下堆叠的餐盘，这些都是线性表。他们的特点都是：除了首尾两个元素，其余任何一个元素前后都对应相邻的另一个元素。
注意：
线性表是一种数据内部的逻辑关系，与存储形式无关
线性表既可以采用连续的顺序存储（顺序表），也可以采用离散的链式存储（链表）
顺序表
基本概念
-
顺序表：顺序存储的线性表。
-
链式表：链式存储的线性表，简称链表。
顺序存储就是将数据存储到一片连续的内存中，在C语言环境下，可以是具名的栈数组，或者是匿名的堆数组。
存储方式不仅仅只是提供数据的存储空间，而是必须要能体现数据之间的逻辑关系。当采用顺序存储的方式来存放数据时，唯一能用来表达数据间本身的逻辑关系的就是存储位置。比如队列中的两个人，小明和小花，如果小明在逻辑上排在相邻的小花的前面，那么在存储位置上也必须把小明存放在相邻的小花的前面。
基本操作
-
顺序表设计
一般而言，为了方便操作顺序表，需要一个专门管理顺序表的”管理结构体“，管理结构体中一般会包含：
- 顺序表总容量
- 顺序表当前最末元素下标位置
- 顺序表指针
下面是管理结构体示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
typedef struct
{
int capacity; // 顺序表容量
int last; // 最末元素下标
int *data; // 顺序表，以整型数据为例
} sequenceList;
-
初始化
所谓初始化就是建立一个不包含任何元素的顺序表，设置好管理结构体中的表的总容量、末元素下标，申请好顺序表内存空间等系列准备工作。
下面是初始化顺序表的示例代码：
sequenceList *init_list(int cap)
{
sequenceList *list = malloc(sizeof(sequenceList));
if(list != NULL)
{
list->data = malloc(sizeof(int) *cap);
if(list->data == NULL)
{
free(list);
return NULL;
}
list -> capacity = cap;
list -> last = -1;
}
return list;
}
测试：
int main()
{
sequenceList *list = init_list(10);
if(list == NULL)
{
perror("初始化顺序表失败！");
exit(0);
}
else
{
printf("初始化顺序表成功！\n");
}
}
-
增删节点
在顺序表中增加一个数据，可以有多种方式，比如在原数组的末尾增加，或者在原数组的头部增加，或者在数组中间任意一个位置增加。根据实际需要来定。
下面以在顺序表头部增删数据为例，示例代码如下：
// 判断顺序表是否为空
bool isEmpty(sequenceList *s)
{
return s->last == -1;
}
// 判断顺序表是否已满
bool isFull(sequenceList *s)
{
return s->last == s->capacity - 1;
}
// 在顺序表表头插入一个新数据
bool insert(sequenceList *s, int data)
{
if(isFull(s))
{
return false;
}
// 将原有数据全部往后挪一位
for(int i = s->last; i >= 0; i--)
{
s->data[i + 1] = s->data[i];
}
// 将新数据插入表头
s->data[0] = data;
// 最后一个数据的下标加一
s->last++;
return true;
}
// 将顺序表表头的数据删除掉
bool removeNode(sequenceList *s)
{
if(isEmpty(s))
{
return false;
}
// 将所有数据全部往前挪一位
for(int i = 0; i < s->last; i++)
{
s->data[i] = s->data[i + 1];
}
// 最后一个数据的下标减一
s->last--;
return true;
}
-
销毁顺序表
一个顺序表最后不再需要，应当要释放其所占用的内存空间，这被称为顺序表的销毁。
下面是销毁操作的示例代码：
void destroy(sequenceList* s)
{
if(s == NULL)
{
return;
}
free(s->data);
free(s);
}
完整代码
- seqlist.h
#ifndef __SEQLIST_H
#define __SEQLIST_H
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>
typedef struct
{
int capacity; // 顺序表容量
int last; // 最末元素下标
int *data; // 顺序表，以整型数据为例
} sequenceList;
// 初始化顺序表
sequenceList *init_list(int cap);
// 判断顺序表是否写满
bool isFull(sequenceList *list);
// 向顺序表插入数据
bool insert(sequenceList *s, int data);
// 非空校验
bool isEmpty(sequenceList *list);
// 遍历顺序表
void show(sequenceList *list);
// 删除顺序表数据
bool removeNode(sequenceList *list, int data);
// 释放内存
void destroy(sequenceList *s);
#endif
- seqlist.c
#include "seqlist.h"
sequenceList *init_list(int cap)
{
sequenceList *list = malloc(sizeof(sequenceList));
if (list != NULL)
{
list->data = malloc(sizeof(int) * cap);
if (list->data == NULL)
{
free(list);
return NULL;
}
list->capacity = cap;
list->last = -1;
}
return list;
}
bool isFull(sequenceList *list)
{
return list->last == list->capacity - 1;
}
// 在顺序表表头插入一个新数据
bool insert(sequenceList *s, int data)
{
if (isFull(s))
return false;
// 将原有数据全部往后挪一位
for (int i = s->last; i >= 0; i--)
s->data[i + 1] = s->data[i];
// 将新数据置入表头
s->data[0] = data;
s->last++;
return true;
}
// 判断是否为空
bool isEmpty(sequenceList *list)
{
return list->last == -1;
}
// 查看当前顺序表的元素
void show(sequenceList *list)
{
if (isEmpty(list))
{
return;
}
for (int i = 0; i <= list->last; i++)
printf("%d\t", list->data[i]);
printf("\n");
}
// 将顺序表中指定的某个元素删除掉
bool removeNode(sequenceList *list, int data)
{
if (isEmpty(list))
return false;
// 找到要删除的节点的位置
int i, pos = -1;
for (i = 0; i <= list->last; i++)
{
if (list->data[i] == data)
{
pos = i;
break;
}
}
// 找不到要删除的元素
if (i > list->last)
{
return false;
}
// 将所有数据全部往前挪一位
for (int i = pos; i < list->last; i++)
list->data[i] = list->data[i + 1];
list->last--;
return true;
}
// 释放内存
void destroy(sequenceList *s)
{
if (s == NULL)
return;
free(s->data);
free(s);
}
int main()
{
// 创建顺序表
sequenceList *list = init_list(10);
if (list == NULL)
{
perror("初始化顺序表失败!");
exit(0);
}
else
{
printf("初始化顺序表成功！\n");
}
// 测试向顺序表插入/删除信息
int n;
while (true)
{
scanf("%d", &n);
if (n > 0)
{
// 插入
if (!insert(list, n))
{
printf("容量已满，插入失败！\n");
continue;
}
}
else if (n < 0)
{
// 删除
if (!removeNode(list, -n))
{
printf("查无此数，删除失败！\n");
continue;
}
}
// 遍历
show(list);
}
// 释放
destroy(list);
}
课堂练习1
创建一个顺序表，并从键盘接收数字输入，将输入的正整数按从小到大的顺序插入顺序表，并在输入负整数的时候将其绝对值数据删除。每次输入后，将顺序表的内容打印到屏幕上。
解析：
此题考查顺序表的基本思路，先要设计好顺序表的逻辑表达，再通过对顺序表的插入和删除操作，体会顺序存储中对于插入和删除的不便性。
参考代码：
#include <stdio.h>
#include <stdlib.h> // for abs() function
#define MAX_SIZE 100 // 定义顺序表的最大容量
void insert(int array[], int *size, int value);
void remove_value(int array[], int *size, int value);
void print_array(int array[], int size);
int main()
{
int list[MAX_SIZE] = {0}; // 创建一个顺序表
int size = 0; // 当前顺序表中的元素数量
int input;
printf("请输入整数（输入非数字结束程序）：\n");
while (scanf("%d", &input) == 1)
{ // 持续读取直到遇到非数字输入
if (input >= 0)
{
// 插入正整数
insert(list, &size, input);
}
else
{
// 删除负整数的绝对值
remove_value(list, &size, abs(input));
}
print_array(list, size); // 打印顺序表内容
printf("请输入整数（输入非数字结束程序）：\n");
}
return 0;
}
// 在顺序表中按从小到大的顺序插入正整数
void insert(int array[], int *size, int value)
{
if (*size == MAX_SIZE)
{
printf("顺序表已满，无法插入新元素。\n");
return;
}
int i;
for (i = *size - 1; i >= 0 && array[i] > value; i--)
{
array[i + 1] = array[i];
}
array[i + 1] = value;
(*size)++;
}
// 从顺序表中移除指定的值
void remove_value(int array[], int *size, int value)
{
int i, found = 0;
for (i = 0; i < *size && !found; i++)
{
if (array[i] == value)
{
found = 1;
for (; i < *size - 1; i++)
{
array[i] = array[i + 1];
}
(*size)--;
}
}
}
// 打印顺序表的内容
void print_array(int array[], int size)
{
if (size == 0)
{
printf("顺序表为空。\n");
}
else
{
printf("顺序表: ");
for (int i = 0; i < size; i++)
{
printf("%d ", array[i]);
}
printf("\n");
}
}
顺序表优缺点总结
顺序存储中，由于逻辑关系是用物理位置来表达的，因此从上述示例代码可以很清楚看到，增删数据都非常困难，需要成片地移动数据。顺序表对数据节点的增删操作是很不友好的。
总结其特点如下：
- 优点
- 不需要多余的信息来记录数据间的关系，存储密度高
- 所有数据顺序存储在一片连续的内存中，支持立即访问任意一个随机数据，比如上述顺序表中第i个节点是 s->data[i]
- 缺点
- 插入、删除时需要保持数据的物理位置反映其逻辑关系，一般需要成片移动数据
- 当数据节点数量较多时，需要一整片较大的连续内存空间
- 当数据节点数量变化剧烈时，内存的释放和分配不灵活
扫一扫
2064
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
