顺序表的实现--线性表（一）

最新推荐文章于 2024-05-05 14:19:10 发布

当格子衫爱上Helloworld

最新推荐文章于 2024-05-05 14:19:10 发布

阅读量826

点赞数 1

分类专栏：数据结构与算法文章标签：顺序表数据结构

本文链接：https://blog.csdn.net/weixin_42826139/article/details/88547215

版权

数据结构与算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

顺序表（顺序存储的结构）

什么是顺序表

顺序表，全名顺序存储结构，是线性表的一种。线性表用于存储逻辑关系为“一对一”的数据，顺序表自然也不例外。此外，线性表是逻辑，顺序表是这种逻辑结构在内存上的实现，顺序表存储数据时，会提前申请一整块足够大小的物理空间，然后将数据依次存储起来，存储时做到数据元素之间不留一丝缝隙。

例如，使用顺序表存储集合 {1,2,3,4,5}，数据最终的存储状态为：

1	2	3	4	5

由此我们可以得出，将“具有 ‘一对一’ 逻辑关系的数据按照次序连续存储到一整块物理空间上”的存储结构就是顺序存储结构。

通过观察图 1 中数据的存储状态，我们可以发现，顺序表存储数据同数组非常接近。其实，顺序表存储数据使用的就是数组。

顺序表的结构

使用顺序表存储数据之前，除了要申请足够大小的物理空间之外，为了方便后期使用表中的数据，顺序表还需要实时记录以下 2 项数据：

顺序表申请的存储容量；
顺序表的长度，也就是表中存储数据元素的个数；
另外可以追加个顺序表申请空间大小，顺序表的长度不等于申请空间，因为有可能存不满

注意：正常状态下，顺序表申请的存储容量要大于顺序表的长度
那用c语言表示这种结构为：

typedef struct Sqlist{
    int * array;//声明了一个名为array的长度不确定的数组，也叫“动态数组”
    int length;//记录当前顺序表的长度
    int size;//记录顺序表分配的存储容量
}sqlist;

注意，array 是我们声明的一个未初始化的动态数组，不要只把它看做是普通的指针。

顺序表的初始化

顺序表的初始化，也就是初步建立一个顺序表。建立顺序表需要做如下工作：

给 head 动态数据申请足够大小的物理空间；
给 size 和 length 赋初值；

代码如下：

#define SIZE 5
//初始化顺序表
table* initTable(table * t){
    //table t;
    t->head = (int *)malloc(sizeof(int) * SIZE); //申请空间
    if(!t->head){
        printf("申请空间失败\n");
        exit(0);
    }
    t->length = 0; //当前长度位0
    t->size = SIZE; //总容量
    return t;
}

整个顺序表初始化的过程被封装到了一个函数中，此函数返回值是一个已经初始化完成的顺序表。这样做的好处是增加了代码的可用性，也更加美观。与此同时，顺序表初始化过程中，要注意对物理空间的申请进行判断，对申请失败的情况进行处理，这里只进行了“输出提示信息和强制退出”的操作，可以根据你自己的需要对代码中的 if 语句进行改进。

顺序表的操作

顺序表插入元素

向已有顺序表中插入数据元素，根据插入位置的不同，可分为以下 3 种情况：

插入到顺序表的表头；
在表的中间位置插入元素；
尾随顺序表中已有元素，作为顺序表中的最后一个元素；
所以要判断插入位置是否正确

虽然数据元素插入顺序表中的位置有所不同，但是都使用的是同一种方式去解决，即：通过遍历，找到数据元素要插入的位置，然后做如下两步工作：

将要插入位置元素以及后续的元素整体向后移动一个位置；
将元素放到移动出来的空位置上；
所以要判断是否有空间进行插入，也就是表是否是满的。

例如，在 {1,2,3,4,5} 的第 3 个位置上插入元素 6，实现过程如下：
第3个位置为3

1	2	3	4	5

第3个位置及其以后的位置后移

1	2		3	4	5

第3个位置插入6元素

1	2	6	3	4	5

因此，顺序表插入数据元素的 C 语言实现代码如下：

//插入元素
table * add_elem(table *t, int elem, int pos){
    if(pos < 1 || pos > t->length+1){   //判断插入位置
        printf("插入位置不符合\n");
        return t;
    }
    if(t->length == t->size){   //判断表是否满，满了则扩容
        t->head = (int *)realloc(t->head, sizeof(int) * (t->size + SIZE));
        if(!t->head){
            printf("扩容失败\n");
            return t;
        }
        t->size = t->size + SIZE;   //增加申请空间的大小
    }
    int i = 0;
    for(i = t->length - 1; i >= pos - 1; --i)   //元素后移
        t->head[i+1] = t->head[i];
    t->head[pos - 1] = elem;           //插入元素
    t->length++;        //表的当前长度加1
    return t;
}

注意，动态数组额外申请更多物理空间使用的是 realloc 函数。并且，在实现后续元素整体后移的过程，目标位置其实是有数据的，还是 3，只是下一步新插入元素时会把旧元素直接覆盖。

移动元素一定从表末尾开始逐一后移，不然数据会被覆盖掉。

顺序表删除元素

从顺序表中删除指定元素，实现起来非常简单，只需找到目标元素，并将其后续所有元素整体前移 1 个位置即可。

后续元素整体前移一个位置，会直接将目标元素删除，可间接实现删除元素的目的。

例如，在 {1,2,3,4,5}移除第3个元素，实现过程如下：
第3个位置为3

1	2	3	4	5

第3个以后的元素（4，5）逐一前移

1	2	4	5

因此，顺序表删除元素的 C 语言实现代码为：

//返回要删除的元素
int delete_elem(table *t, int pos){
    if(pos < 1|| pos > t->length){  //判断删除位置
        printf("删除位置不符合\n");
        return -1;
    }
    int i = 0;
    for(i = pos; i < t->length ; ++i){  //删除位置以后的元素前移
        t->head[i - 1] = t->head[i];
    }
    t->length--;	//表当前长度减1
    return t->head[pos - 1];
}

注意：移动是是从删除位置逐一前移，这样第3个元素3才会被覆盖。

顺序表查找元素

顺序表中查找目标元素，可以使用多种查找算法实现，比如说二分查找算法、插值查找算法等。
这里，我们选择顺序查找算法，具体实现代码为：

//查找元素
int find_elem(table *t, int elem){
    int i = 0;
    for(i = 0; i < t->length; ++i){  //遍历
        if(elem == t->head[i])
            return i+1;  //返回找到的元素的索引（第几个元素）
    }
    printf("查找不到元素：%d\n", elem);
    return -1;
}

顺序表更改元素

顺序表更改元素的实现过程是：

找到目标元素；
直接修改该元素的值；

顺序表更改元素的 C 语言实现代码为：

//更改元素
table * change(table *t, int elem, int newElem){
    int pos = find_elem(t, elem);       //查找旧元素的位置
    t->head[pos - 1] = newElem;     //找到后替换
    return t;
}

遍历元素

void print(table *t){
    int len = t->length;	//顺序表当前长度
    int i = 0;
    for(i = 0; i < len; ++i){
        printf("%d  ", t->head[i]);
    }
    printf("\n");
}

重置顺序表

void reset(table *t){
    int len = t->length;	//顺序表当前长度
    int i = 0;
    for(i = 0; i < len; ++i){
        t->head[i] = 0;
    }
}

销毁顺序表

顺序表初始化时，使用了malloc，那么程序结束时就要释放内存，即free(t)

其他操作

判空：length == 0
判满：size == length
按索引O(1)查找：t->array[i];
等等，不过有了这几个基本操作，相信你能掌握好顺序表。

以上是顺序表使用过程中最常用的基本操作，这里给出完整的实现代码：

#include <stdio.h>
#include <stdlib.h>
#define SIZE 5
typedef struct Table{
    int *head; //可变长数组头
    int length; //当前长度
    int size; //总量存储空间
} table;
//初始化顺序表
table* initTable(table * t){
    //table t;
    t->head = (int *)malloc(sizeof(int) * SIZE); //申请空间
    if(!t->head){
        printf("申请空间失败\n");
        exit(0);
    }
    t->length = 0; //当前长度位0
    t->size = SIZE; //总容量
    return t;
}
//插入元素
table * add_elem(table *t, int elem, int pos){
    if(pos < 1 || pos > t->length+1){   //判断插入位置
        printf("插入位置不符合\n");
        return t;
    }
    if(t->length == t->size){   //判断表是否满，满了则扩容
        t->head = (int *)realloc(t->head, sizeof(int) * (t->size + SIZE));
        if(!t->head){
            printf("扩容失败\n");
            return t;
        }
        t->size = t->size + SIZE;   //增加申请空间的大小
    }
    int i = 0;
    for(i = t->length - 1; i >= pos - 1; --i)   //元素后移
        t->head[i+1] = t->head[i];
    t->head[pos - 1] = elem;           //插入元素
    t->length++;        //表的当前长度加1
    return t;
}
//删除元素
int delete_elem(table *t, int pos){
    if(pos < 1|| pos > t->length){  //判断删除位置
        printf("删除位置不符合\n");
        return -1;
    }
    int i = 0;
    for(i = pos; i < t->length ; ++i){  //删除位置以后的元素前移
        t->head[i - 1] = t->head[i];
    }
    t->length--;
    return t->head[pos - 1];
}
//查找元素
int find_elem(table *t, int elem){
    int i = 0;
    for(i = 0; i < t->length; ++i){  //遍历
        if(elem == t->head[i])
            return i+1;  //返回找到的元素的索引（第几个元素）
    }
    printf("查找不到元素：%d\n", elem);
    return -1;
}
//更改元素
table * change(table *t, int elem, int newElem){
    int pos = find_elem(t, elem);       //查找旧元素的位置
    t->head[pos - 1] = newElem;     //找到后替换
    return t;
}
void print(table *t){
    int len = t->length;
    int i = 0;
    for(i = 0; i < len; ++i){
        printf("%d  ", t->head[i]);
    }
    printf("\n");
}
void destory(table *t){
	if(!t)
		free(t);
}
int main(){
    table t;
    initTable(&t);
    int input;
    int flag = 1;
    while(flag){
        printf("请输入操作\n");
        printf("1.插入数据\n");
        printf("2.删除数据\n");
        printf("3.查找数据\n");
        printf("4.改变数据\n");
        printf("5.打印数据\n");
        printf("6.推出操作\n");
        scanf("%d", &input);
        switch (input)
        {
            case 1:
            {
                int a, p;
                printf("请输入插入的元素a和位置p: \n");
                scanf("%d %d", &a, &p);
                add_elem(&t, a, p);
                break;
            }
            case 2:
            {
                printf("请输入删除的位置\n");
                int a;
                scanf("%d", &a);
                printf("删除的元素为：%d\n", delete_elem(&t, a));
                break;
            }
            case 3:{
                printf("请输入要查询的值\n");
                int a;
                scanf("%d", &a);
                printf("查询的值是第  %d  个值\n", find_elem(&t, a));
                break;
            }
            case 4:{
                printf("请输入要改变的元素以及新元素\n");
                int a, p;
                scanf("%d %d", &a, &p);
                if(change(&t, a, p)){
                    printf("修改成功\n");
                }
                else{
                    printf("修改失败\n");
                }
                break;
            }
            case 5:
            {
                printf("遍历顺序表的结果为\n");
                print(&t);
                break;
            }
            case 6:
            {
                flag = 0;
                break;
            }
        }
    }
    destory(&t);
}

当格子衫爱上Helloworld

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
顺序表的实现--线性表（一）

顺序表（顺序存储的结构）什么是顺序表顺序表，全名顺序存储结构，是线性表的一种。线性表用于存储逻辑关系为“一对一”的数据，顺序表自然也不例外。此外，线性表是逻辑，顺序表是这种逻辑结构在内存上的实现，顺序表存储数据时，会提前申请一整块足够大小的物理空间，然后将数据依次存储起来，存储时做到数据元素之间不留一丝缝隙。例如，使用顺序表存储集合 {1,2,3,4,5}，数据最终的存储状态为：1...
复制链接

扫一扫

专栏目录