线性表之顺序表

最新推荐文章于 2024-03-18 22:30:23 发布

bfsm

最新推荐文章于 2024-03-18 22:30:23 发布

阅读量110

点赞数

分类专栏：知识总结——数据结构（基础）文章标签：数据结构算法 leetcode c语言

本文链接：https://blog.csdn.net/Jokersorry/article/details/111513875

版权

知识总结——数据结构（基础）专栏收录该内容

8 篇文章 0 订阅

订阅专栏

线性表

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

顺序表

顺序表是一段在内存上物理地址连续的线性表，也就是说，它是逻辑、物理上都连续的，通常情况下，以数组形式存储，然后后续操作就在数组上进行增删改查；顺序表根据它的创建方式分为：

静态顺序表创建

使用定长的数组存储：

// 顺序表的静态存储

//使用宏来表示定长数组的大小
#define N 100

//使用typedef来重命名数据类型，如果后续顺序表中存储的数据类型需要改变，那么只需修改这里的数据类型即可，很方便
typedef int SLDataType;

typedef struct SeqList
{
 SLDataType array[N]; // 定长数组
 size_t size; // 有效数据的个数
}SeqList;

静态顺序表只适用于确定数据多少的情况下，否则不好确定定长数组的大小，创建大了浪费空间，创建小了不够用，所以一般实际开发中不经常用，我们更多的是使用动态顺序表，下面就重点来实现一下动态顺序表。

动态顺序表

使用动态开辟的数组存储：

// 顺序表的动态存储

//使用typedef来重命名数据类型，如果后续顺序表中存储的数据类型需要改变，那么只需修改这里的数据类型即可，很方便
typedef int SLDataType;

typedef struct SeqList
{
 SLDataType* array; // 指向动态开辟的数组
 size_t size ; // 有效数据个数
 size_t capicity ; // 容量空间的大小
}SeqList;

动态顺序表可以在数据进行输入的过程中，如果发现空间满了，那么我们可以进行动态的申请空间，而不是放弃原来的表，重新创建新的顺序表，这是非常人性化的一件事；

实现接口

当我们将顺序表创建出来后，拿给用户使用时，我们是不需要让用户明白到底是如何向里面输入数据、如何拿出数据等等的原理的，我们只需要提供一个接口，而用户只需将一个数据放到接口中，那么就完成了一个操作，这会给用户带来极大的方便；
那么下面我就来实现一下各种接口，需要注意的是，接口的函数名一般是有默认形式，也就是说这个借口实现什么样的功能，那它的名字最好写的规范些，方便别人的使用；

//这是 .h 部分的文件
#pragma once

//使用这种方式来重命名数据类型，这样可以很方便的修改后续数据的数据类型，相当于#define的作用
typedef int SeqListType;

//动态创建顺序表
typedef struct SeqList {
    //使用指针指向一块动态开辟的内存
    SeqListType* _date;
    //表示顺序表中的有效数据
    size_t _size;
    //表示顺序表的最大容量
    size_t _capacity;
}SeqList;

//包含所有函数的声明
//顺序表初始化
void SeqListInit(SeqList* s1);
//顺序表销毁
void SeqListDestroy(SeqList* s1);
//检查顺序表是否已满
void CheckCapacity(SeqList* s1);
//顺序表尾插
void SeqListPushBack(SeqList* s1, SeqListType val);
//顺序表尾删 
void SeqListPopBack(SeqList* s1);
//顺序表头插
void SeqListPushFront(SeqList* s1, SeqListType val);
//顺序表头删
void SeqListPopFront(SeqList* s1);
//顺序表任意插
void SeqListInsert(SeqList* s1, int pos, SeqListType val);
//顺序表任意删
void SeqListErase(SeqList* s1, int pos);
//打印顺序表
void SeqListPrint(SeqList* s1);
//顺序表判空
int SeqListEmpty(SeqList* s1);
//顺序表大小
int SeqListSize(SeqList* s1);
//顺序表查找下标
int SeqListFindIdx(SeqList* s1, SeqListType val);
//顺序表下标对应元素
SeqListType SeqListGetIdx(SeqList* s1, int pos);

//这是 .c 部分的代码
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"SQList.h"

//顺序表初始化
void SeqListInit(SeqList* s1) {
    s1->_date = NULL;
    s1->_size = s1->_capacity = 0;
}

//顺序表销毁
void SeqListDestroy(SeqList* s1) {
    //参数合法性检验,是空就不用释放了
    if (s1 == NULL||s1->_date == NULL) {
        return;
    }
    free(s1->_date);
    s1->_date = NULL;
}

//检查顺序表是否已满
void CheckCapacity(SeqList* s1) {
    //参数合法性检验
    if (s1 == NULL) {
        return;
    }
    if (s1->_capacity == s1->_size) {
        //由于一开始容量为0，不好进行相乘运算，所以先增加1
        s1->_capacity = s1->_capacity == 0 ? 1 : s1->_capacity;
        //每次以二倍的容量增加
        SeqListType* temp = (SeqListType*)malloc(sizeof(SeqListType) * 2 * s1->_capacity);
        //使用memcpy函数来进行将旧空间的数据拷贝到新空间
        memcpy(temp, s1->_date, sizeof(SeqListType) * s1->_size);
        //释放掉旧空间
        free(s1->_date);
        //更新变量
        s1->_capacity = 2 * s1->_capacity;
        s1->_date = temp;
        temp = NULL;
    }
}

//顺序表尾插
void SeqListPushBack(SeqList* s1, SeqListType num) {
    //参数合法性检验
    if (s1 == NULL) {
        return;
    }
    //在插入数据之前应该检查是否满了
    CheckCapacity(s1);
    s1->_date[s1->_size] = num;
    ++s1->_size;
}

//顺序表尾删 
void SeqListPopBack(SeqList* s1) {
    //参数合法性检验
    if (s1 == NULL||s1->_size == 0) {
        return;
    }
    --s1->_size;
}

//顺序表头插
void SeqListPushFront(SeqList* s1, SeqListType val) {
    //参数合法性检验
    if (s1 == NULL) {
        return;
    }
    CheckCapacity(s1);
    int end = s1->_size;
    while (end > 0) {
        s1->_date[end] = s1->_date[end - 1];
        --end;
    }
    s1->_date[0] = val;
    ++s1->_size;
}

//顺序表头删
void SeqListPopFront(SeqList* s1) {
    //参数合法性检验
    if (s1 == NULL||s1->_size == 0) {
        return;
    }
    int start = 1;
    while (start < s1->_size) {
        s1->_date[start - 1] = s1->_date[start];
        ++start;
    }
    --s1->_size;
}

//顺序表任意插
void SeqListInsert(SeqList* s1, int pos, SeqListType val) {
    //参数合法性检验
    if (s1 == NULL) {
        return;
    }
    CheckCapacity(s1);
    int end = s1->_size;
    while (end > pos) {
        s1->_date[end] = s1->_date[end - 1];
        --end;
    }
    s1->_date[pos] = val;
    ++s1->_size;
}

//顺序表任意删
void SeqListErase(SeqList* s1, int pos) {
    //参数合法性检验
    if (s1 == NULL || s1->_size == 0) {
        return;
    }
    ++pos;
    while (pos < s1->_size) {
        s1->_date[pos - 1] = s1->_date[pos];
        ++pos;
    }
    --s1->_size;
}

//打印顺序表
void SeqListPrint(SeqList* s1) {
    //参数合法性检验
    if (s1 == NULL || s1->_size == 0) {
        return;
    }
    for (int i = 0; i < s1->_size; ++i) {
        printf("%d ", s1->_date[i]);
    }printf("\n");
}

//顺序表判空
int SeqListEmpty(SeqList* s1) {
    if (s1 == NULL || s1->_size == 0) {
        return 0;
    }
    return 1;
}

//顺序表大小
int SeqListSize(SeqList* s1) {
    if (s1 == NULL) {
        return 0;
    }
    return s1->_size;
}

//顺序表查找下标,这个模块代码不完善
//因为一个顺序表中重复的数字很多,所以我们应该返回一个数组，里面包含的val出现的所有位置
//但是实现起来较麻烦，所以不在此展示
int SeqListFindIdx(SeqList* s1, SeqListType val) {
    if (s1 == NULL||s1->_size == 0) {
        return -1;
    }
    for (int i = 0; i < s1->_size; ++i) {
        if (s1->_date[i] == val) {
            return i;
        }
    }
    return -1;
}

//顺序表下标对应元素
SeqListType SeqListGetIdx(SeqList* s1, int pos) {
    //此模块无法进行判空，因为如果为空，那么该返回什么值呢？
    //返回的值都有可能是顺序表中的某一个值，所以此模块默认已经进行判空
    return s1->_date[pos];
}

int main() {
    SeqList s1;
    SeqListInit(&s1);
    return 0;
}

以上就是对顺序表各种操作的接口实现，在上面的代码中，对每一个功能都进行了函数封装，这有利于后期对代码的维护；而且在上面的代码中，对数据的头插头删，尾插尾删，其实是可以通过对在任意位置插入删除函数调用，这样使得代码复用性高，也是便于后期维护。

顺序表优缺点

优点：
- 1.空间连续，支持随机访问；
- 2.尾插、尾删效率高，时间复杂度 O(1)；
- 3.空间利用率高，不容易产生内存碎片，因为每次开辟空间都是开辟较大的空间，当你不用时，别人仍可以用；
- 4.实现简单，逻辑思路不复杂；
缺点：
- 1.在除过尾部的其他地方，插入、删除元素时间复杂度都为 O(N)，效率低；
- 2.增容时，很有可能需要另开辟一片空间，然后将数据搬运过去，然后释放掉原有空间，开销大；

注：在我写的代码中，每一次增容时都需要另开辟空间、搬运数据、释放原有空间，是因为我实现的方式比较繁琐，但是是为了更清楚的逻辑思路；除过我写的这种方式，其实还可以用realloc函数，将开辟新空间、搬运数据、释放原有空间合为一体，十分方便，当内存空间足够时，是直接在原有空间后面在开辟连续的空间，省去数据搬运、释放空间的步骤。

数组相关面试题

原地移除数组 nums 中所有等于 val 的元素，并返回数组的新长度，元素顺序可变，不需考虑数组中超出新长度后面的元素。要求空间复杂度为 O(1)。例如：nums=[3,2,2,3],val = 3;返回长度为 2，且 nums 中的前两个元素均为 2。(leetcode,27)

int removeElement(int* nums, int numsSize, int val) {
        int size = 0;
        for (int i = 0; i < numsSize; i++) {
            if (nums[i] != val) {
                nums[size] = nums[i];
                size++;
            }
        }
        return size;
    }

原地删除排序数组的重复项，返回移除后的数组长度。要求空间复杂度 O(1)。例如：给定nums=[1, 1, 2]，返回长度为 2，并且 nums 中前两个元素修改为 1, 2。(leetcode,26)

int removeDuplicates(int* nums, int numsSize) {
    int idx = 1;
    int flag = nums[0];
    int count = 1;
    for (int i = 1; i < numsSize; i++) {
        if (flag != nums[i]) {
            nums[idx++] = nums[i];
            flag = nums[i];
            count++;
        }
    }
    return count;
}

两个有序数组 nums1、nums2，数组元素个数为 m、n，将 nums2 合并到 nums1 中，使 nums1 成为有序数组,假设 nums1 有足够的空间。例如：nums1=[1,2,3]、m=3，nums2=[2,5,6]、n=3，输出 nums1=[1,2,2,3,5,6]。(leetcode,88)

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
    int count = m + n-1;
    m--,n--;
    while (m >= 0 || n >= 0) {
        if (nums1[m] < nums2[n]) {
            nums1[count] = nums2[n];
            count--;
            n--;
        }
        else {
            nums1[count] = nums1[m];
            count--;
            m--;
        }
    }
}

给定一个数组，右旋 k 位，k 为非负数，也就是将数组的后面 k 位，整体移动到数组前面。空间复杂度为 O(1)。例如：nums=[1,2,3,4,5,6,7]、k=3，输出nums=[5,6,7,1,2,3,4]。(leetcode,189)

void swap(int* nums,int start,int end) {
    for (; start < end; start++, end--) {
        int temp = 0;
        temp = nums[start];
        nums[start] = nums[end];
        nums[end] = temp;
    }
}
void removeDuplicates(int* nums, int numsSize,int k) {
    swap(nums, 0, numsSize - k - 1);
    swap(nums, numsSize - k, numsSize - 1);
    swap(nums, 0, numsSize-1);
}

对于非负整数 X，有数组 A 是按照X从左到右每一位的顺序组成的数组，给定数组 A，再给一个整数 K，返回 X+K 的数组形式。例如：X=1231,A=[1,2,3,1],K=34,返回 1265 的数组形式 nums=[1,2,5,6]。(leetcode,989)

int* addToArrayForm(int* A, int ASize, int K, int* returnSize) {
    if (K == 0) {
        *returnSize = ASize;
        return A;
    }
    //求K的位数，然后和ASize比较，最大的+1就是新申请数组的大小
    int count = (log10(K) + 1) > ASize ? (log10(K) + 2) : ASize + 1;
    *returnSize = count;
    int* ret = (int*)calloc(count, sizeof(int));
    if (ret == NULL)
        return NULL;
    while (ASize >= 0) {
        if (--ASize >= 0)
            K = A[ASize] + K;
        ret[--count] = K % 10;
        K /= 10;
    }
    if (ret[0] == 0) {
        ret[--count] = K;
        //做判断，如果首元素是0，那就将数组的大小-1，并将返回第二个元素的地址
        (*returnSize)--;
        return ++ret;
    }
    else
        //如果首元素不是0，那么就返回数组的首地址
        return ret;
}

博客园发表于 2020-12-07 11:27

bfsm

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
线性表之顺序表

目录线性表顺序表静态顺序表创建动态顺序表实现接口顺序表优缺点数组相关面试题线性表线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上（也就是在内存上的排列）并不一定是连续的，线性表在内存中的结构通常以数组和链式结构的形式存储。顺序表顺序表是一段在内存上物理地址连续的线性表，也就是说，它是逻辑、物理上都连续的，通常情
复制链接

扫一扫

专栏目录