线性表之顺序表

线性表

　　线性表（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;
}

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

　　顺序表优缺点

　　　　优点：①空间连续，支持随机访问；

　　　　　　　②尾插、尾删效率高，时间复杂度O(1)；

　　　　　　　③空间利用率高，不容易产生内存碎片，因为每次开辟空间都是开辟较大的空间，当你不用时，别人仍可以用；

　　　　　　　④实现简单，逻辑思路不复杂；

　　　　缺点：①在除过尾部的其他地方，插入、删除元素时间复杂度都为O(N)，效率低；

　　　　　　　②增容时，很有可能需要另开辟一片空间，然后将数据搬运过去，然后释放掉原有空间，开销大；

　　　　注：在我写的代码中，每一次增容时都需要另开辟空间、搬运数据、释放原有空间，是因为我实现的方式比较繁琐，但是是为了更清楚的逻辑思路；除过我写的这种方式，其实还可以用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;
    }
    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 ( K > 0) {
        if (--ASize >= 0) 
            K = A[ASize] + K;
        ret[--count] = K % 10;
        K /= 10;
    }
    if (ret[0] == 0) {
        ret[--count] = K;
        (*returnSize)--;
        return ++ret;
    }
    else
        return ret;
}