目录
线性表
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串等等
线性表在逻辑上是线性结构的，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
顺序表
顺序表使用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数据存储。在数组上完成数据的增删查改。
顺序表一般分为：
1.静态顺序表：使用定长数组存储元素
2.动态顺序表：使用动态开辟的数组存储
了解了线性表与顺序表之后，下面我们就来实现以下动态顺序表吧。?
顺序表的实现
函数接口的声明
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;
//动态顺序表
typedef struct Seqlist
{
SLDataType *a;
int sz;//表示数组中存储了多少个数据
int capacity;//表示数组实际能存储的空间容量
}SL;
//初始化
void SeqlistInit(SL* ps);
//顺序表的打印
void SeqlistPrint(SL* ps);
//顺序表的销毁
void SeqlistDestory(SL* ps);
//尾插
void SeqlistPushBack(SL*ps, SLDataType x);
//头插
void SeqlistPushFront(SL*ps, SLDataType x);
//尾删
void SeqlistPopBack(SL*ps);
//头删
void SeqlistPopFront(SL*ps);
//顺序表查找
int SeqlistFind(SL*ps, SLDataType x);
//顺序表检查是否要扩容
void SeqlistCheck(SL*ps);
//顺序表在pos位置插入x
void SeqlisInsert(SL*ps, int pos, SLDataType x);
//顺序表删除pos位置的值
void SeqlistErase(SL*ps, int pos);
//顺序表修改pos位置的值
void SeqlistModify(SL*ps, int pos, SLDataType x);函数接口的实现:
#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"
//顺序表检查是否要扩容
void SeqlistCheck(SL*ps)
{
if (ps->sz == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
//当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
if (temp == NULL)
{
printf("realloc failed\n");
exit(-1);
}
//扩容成功
else
{
ps->a = temp;
ps->capacity = newcapacity;
}
}
}
//初始化的实现
void SeqlistInit(SL* ps)
{
ps->a = NULL;
ps->sz = ps->capacity = 0;
}
//顺序表的打印
void SeqlistPrint(SL* ps)
{
int i = 0;
for (i = 0; i < ps->sz; i++)
{
printf("%d ", ps->a[i]);
}
printf("\n");
}
//顺序表的销毁
void SeqlistDestory(SL* ps)
{
free(ps->a);
ps->a = NULL;
ps->a = 0;
ps->capacity = 0;
}
//尾插的实现
void SeqlistPushBack(SL*ps, SLDataType x)
{
assert(ps);
//如果空间不够或者空间为0时，就得扩容
SeqlistCheck(ps);
//if (ps->sz == ps->capacity)
//{
// int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
// SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
// //当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
// if (temp == NULL)
// {
// printf("realloc failed\n");
// exit(-1);
// }
// //扩容成功
// else
// {
// ps->a = temp;
// ps->capacity = newcapacity;
// }
//}
//假如空间足够，那么我们直接往后插入
ps->a[ps->sz] = x;
ps->sz++;//顺序表有效元素个数+1
}
//头插的实现
void SeqlistPushFront(SL*ps, SLDataType x)
{
assert(ps);
//当空间不够的时候就扩容
SeqlistCheck(ps);
//if (ps->sz == ps->capacity)
//{
// int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
// SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
// //当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
// if (temp == NULL)
// {
// printf("realloc failed\n");
// exit(-1);
// }
// //扩容成功
// else
// {
// ps->a = temp;
// ps->capacity = newcapacity;
// }
//}
//当空间足够的时候，头插的话得向后挪并且是从后往前挪，从前往后会造成覆盖达不到效果
int end = ps->sz-1;
while (end>=0)
{
ps->a[end + 1] = ps->a[end];
end--;
}
ps->a[0] = x;
ps->sz++;//顺序表有效元素个数+1
}
//尾删的实现
void SeqlistPopBack(SL*ps)
{
assert(ps);
assert(ps->sz > 0);
ps->sz--;//顺序表有效元素个数-1
}
//头删的实现
void SeqlistPopFront(SL*ps)
{
assert(ps);
assert(ps->sz > 0);
int begin = 1;
while (begin <ps->sz)
{
//从前往后覆盖
ps->a[begin-1] = ps->a[begin];
begin++;
}
ps->sz--;//顺序表有效元素个数-1
}
//顺序表查找
int SeqlistFind(SL*ps, SLDataType x)
{
assert(ps);
int i = 0;
for (i = 0; i < ps->sz; i++)
{
if (ps->a[i] == x)
{
//找到了
return i;
}
}
//找不到
return -1;
}
//顺序表在pos位置插入x
void SeqlisInsert(SL*ps, int pos, SLDataType x)
{
assert(ps);
assert(pos >= 0 && pos <= ps->sz);
//当空间不够的时候就扩容
SeqlistCheck(ps);
//相当于头插
int end = ps->sz - 1;
while (end >= pos)
{
ps->a[end + 1] = ps->a[end];
end--;
}
ps->a[pos] = x;
ps->sz++;//顺序表有效元素个数+1
}
//顺序表删除pos位置的值
void SeqlistErase(SL*ps, int pos)
{
assert(ps);
assert(pos >= 0 && pos < ps->sz);
int begin = pos;
while (begin < ps->sz)
{
//从前往后覆盖
ps->a[begin-1] = ps->a[begin];
begin++;
}
ps->sz--;
}
//顺序表修改pos位置的值
void SeqlistModify(SL*ps, int pos, SLDataType x)
{
assert(ps);
assert(pos >= 0 && pos < ps->sz);
ps->a[pos] = x;
}顺序表的初始化
将结构体中指向动态开辟的数组的指针置空，将size与capacity置为0.
//初始化的实现
void SeqlistInit(SL* ps)
{
ps->a = NULL;
ps->sz = ps->capacity = 0;
}顺序表的销毁
释放在堆上动态开辟的空间，并且将size与capacity置成0
//顺序表的销毁
void SeqlistDestory(SL* ps)
{
free(ps->a);
ps->a = NULL;
ps->a = 0;
ps->capacity = 0;
}顺序表的打印
依次打印动态开辟的数组中的有效数据
//顺序表的打印
void SeqlistPrint(SL* ps)
{
int i = 0;
for (i = 0; i < ps->sz; i++)
{
printf("%d ", ps->a[i]);
}
printf("\n");
}顺序表检查是否要扩容
当size与capacity相等并且都为0时，就将capacity的容量变成4，若是size与capacity相等但是不为0时，我们就需要扩容了将capacity的容量扩成2倍。
//顺序表检查是否要扩容
void SeqlistCheck(SL*ps)
{
if (ps->sz == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
//当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
if (temp == NULL)
{
printf("realloc failed\n");
exit(-1);
}
//扩容成功
else
{
ps->a = temp;
ps->capacity = newcapacity;
}
}
}顺序表的尾插
首先要判断一下空间容量是否充足，若空间满了就应该当先扩容再尾插，若空间充足即可直接尾插。
//尾插的实现
void SeqlistPushBack(SL*ps, SLDataType x)
{
assert(ps);
//如果空间不够或者空间为0时，就得扩容
SeqlistCheck(ps);
//if (ps->sz == ps->capacity)
//{
// int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
// SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
// //当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
// if (temp == NULL)
// {
// printf("realloc failed\n");
// exit(-1);
// }
// //扩容成功
// else
// {
// ps->a = temp;
// ps->capacity = newcapacity;
// }
//}
//假如空间足够，那么我们直接往后插入
ps->a[ps->sz] = x;
ps->sz++;//顺序表有效元素个数+1
}顺序表的头插
首先要判断一下空间容量是否充足，若空间满了应当先扩容，若空间足够想要头插的话得将有效数据先往后挪并且是从后往前挪，从前往后会造成覆盖达不到想要的效果，挪动之后再插入数据。
//头插的实现
void SeqlistPushFront(SL*ps, SLDataType x)
{
assert(ps);
//当空间不够的时候就扩容
SeqlistCheck(ps);
//if (ps->sz == ps->capacity)
//{
// int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
// SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType*)*newcapacity);
// //当一个指针为NULL指针时，realloc就相当于malloc，这里我们还需要判断一下是否扩容成功
// if (temp == NULL)
// {
// printf("realloc failed\n");
// exit(-1);
// }
// //扩容成功
// else
// {
// ps->a = temp;
// ps->capacity = newcapacity;
// }
//}
//当空间足够的时候，头插的话得向后挪并且是从后往前挪，从前往后会造成覆盖达不到效果
int end = ps->sz-1;
while (end>=0)
{
ps->a[end + 1] = ps->a[end];
end--;
}
ps->a[0] = x;
ps->sz++;//顺序表有效元素个数+1
}顺序表的尾删
首先对有效数据sz进行判断，如果有效数据为0就不需要删除，大于0就只需要将ps->sz--就可以了。
//尾删的实现
void SeqlistPopBack(SL*ps)
{
assert(ps);
assert(ps->sz > 0);
ps->sz--;//顺序表有效元素个数-1
}顺序表的头删
首先对有效数据sz进行判断，如果有效数据为0就不需要删除，如果有效数据大于0的话，需要将有效数据向前挪动，并且是进行从前往后的覆盖，然后再将ps->sz--就可以达到效果了
//头删的实现
void SeqlistPopFront(SL*ps)
{
assert(ps);
assert(ps->sz > 0);
int begin = 1;
while (begin <ps->sz)
{
//从前往后覆盖
ps->a[begin-1] = ps->a[begin];
begin++;
}
ps->sz--;//顺序表有效元素个数-1
}顺序表的查找
在有效数据中进行查找，找到了就返回该位置的下标，找不到则返回-1；
//顺序表查找
int SeqlistFind(SL*ps, SLDataType x)
{
assert(ps);
int i = 0;
for (i = 0; i < ps->sz; i++)
{
if (ps->a[i] == x)
{
//找到了
return i;
}
}
//找不到
return -1;
}顺序表在pos位置插入x
要想插入数据，首先就得检查空间容量是否足够，空间不足的话首先的扩容，空间足够的话需要将pos位置与pos后面的数据向后挪动，并且是从后往前挪，再将x插入到pos的位置上，(需要注意的是pos的位置必须>=0并且不能超过ps->sz-1)，最后对ps->sz++即可
//顺序表在pos位置插入x
void SeqlisInsert(SL*ps, int pos, SLDataType x)
{
assert(ps);
assert(pos >= 0 && pos <= ps->sz);
//当空间不够的时候就扩容
SeqlistCheck(ps);
//相当于头插
int end = ps->sz - 1;
while (end >= pos)
{
ps->a[end + 1] = ps->a[end];
end--;
}
ps->a[pos] = x;
ps->sz++;//顺序表有效元素个数+1
}顺序表删除pos位置的值
删除pos位置的值，需要将pos位置之后的元素从前往后挪动，覆盖pos位置的数据，最后再将ps->sz--即可
//顺序表删除pos位置的值
void SeqlistErase(SL*ps, int pos)
{
assert(ps);
assert(pos >= 0 && pos < ps->sz);
int begin = pos;
while (begin < ps->sz)
{
//从前往后覆盖
ps->a[begin-1] = ps->a[begin];
begin++;
}
ps->sz--;
}顺序表修改pos位置的值
直接修改pos位置的值即可
//顺序表修改pos位置的值
void SeqlistModify(SL*ps, int pos, SLDataType x)
{
assert(ps);
assert(pos >= 0 && pos < ps->sz);
ps->a[pos] = x;
}顺序表的缺陷
1.空间不够了需要扩容，增容是需要付出代价的
2.避免频繁扩容（频繁扩容会导致内存碎片变多），空间满了我们一般都是扩2倍，这样做可能会导致一定的空间浪费
3.顺序表要求数据从开始位置连续存储，那么我们在头部或者中间位置插入删除数据就需要挪动数据，效率不高
力扣练习题
Leetcode27.移除元素
题目描述：
给你一个数组 nums?和一个值 val，你需要 原地 移除所有数值等于?val?的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
思路一：遍历数组找到等于val的值，通过挪动数据来覆盖val达到移除所有等于val的元素的效果，时间复杂度是O(N^2),空间复杂度O(1)
?
思路二：开一个与原数组空间一样大的数组，然后再遍历原数组，不等于val的值就放到新数组里面去，然后再将新数组的值拷回到原数组，时间复杂度是O(N),空间复杂度O(N)，这是一种拿空间换时间的做法。
思路三：双指针的做法，定义一个src与dest，并且让它俩都从数组0下标开始，如果src下标的值等于val，直接让src++，dest不动，如果src下标的值不等于val，那么就把src下标的值赋给dest下标的值，并且让src++，dest++,最后返回的dest正好就是数组新的长度。时间复杂度O(N),空间复杂度O(1)
?
int removeElement(int* nums, int numsSize, int val){ int src = 0; int dest = 0; //遍历完这个数组就结束 while(src<numsSize) { //当src下标元素等于val时，src++ if(nums[src]==val) { src++; } //否则的话将src下标元素的值赋给dest下标元素的值，然后src++，dest++ else { nums[dest] = nums[src]; dest++; src++; } } return dest; }
Leetcode26.删除有序数组中的重复项
题目链接：26. 删除有序数组中的重复项
题目描述：
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
思路：这道题我们还是采用双指针的解法，不过是快慢指针，定义两个变量，一个是快指针src=1，一个是慢指针dest=0，先考虑特殊情况（如果数组大小为0，直接返回0即可) 然后再来看一般情况，通过src去遍历数组，如果src下标元素的值与dest下标元素的值相等，那么让src++，dest不动，如果不相等，就先让dest++再将src下标元素的值赋给dest下标元素的值，再让src++即可。时间复杂度O(N),空间复杂度O(1).
?
int removeDuplicates(int* nums, int numsSize){ int src = 1;//快指针 int dest = 0;//慢指针 //特殊情况数组大小为0 if(numsSize==0) { return 0; } //遍历数组 while(src<numsSize) { //如果快指针和慢指针所指向的元素是一样的，那么慢指针不动，快指针向后移 if(nums[src]==nums[dest]) { src++; } //如果快指针和慢指针所指向的元素不一样的，那么慢指针先向后移，将快指针指向元素的值赋给慢指针，快指针再往后移 else { dest++; nums[dest] = nums[src]; src++; } } return dest+1; }
Leetcode88.合并两个有序数组
题目链接：88. 合并两个有序数组
题目描述：
给你两个按 非递减顺序 排列的整数数组?nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
思路：这道题我们需要采用归并的思想，并且是从后往前归并（从大到小），从前往后的话会造成覆盖达不到我们想要的效果。由于nums1的长度是nums1与nums2有效数据长度之和，因此从nums1与nums2中挑选出较大的数依次插入到nums1数组的后面（从后往前），如果nums2先插入完了，那么我们直接返回nums1就可以了，但是如果是nums1的有效数据先插入完，但是nums2的优先数据还没插入完的话，我们还需要额外将nums2剩余的数据插入到nums1中。时间复杂度O(N),空间复杂度O(1).
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){ int end1 = m-1; int end2 = n-1; int end = n+m-1;//num1最后一个元素的下标 while(end1>=0&&end2>=0) { if(nums1[end1]>nums2[end2]) { nums1[end] = nums1[end1]; end--; end1--; } else { nums1[end] = nums2[end2]; end--; end2--; } } //nums1的有效数已经全放到了nums1后面的位置，nums2还没有完全放进去 while(end2>=0) { nums1[end] = nums2[end2]; end--; end2--; } return nums1; }
Leetcode189.旋转数组
题目链接：189. 旋转数组
题目描述：
给定一个数组，将数组中的元素向右移动?k?个位置，其中?k?是非负数。
思路：先将n-k个数进行逆置，再将后k个数进行逆置，最后再整体逆置。这样就达到我们想要的效果了。时间复杂度O(N),空间复杂度O(1).
?
void Reverse(int*nums,int left,int right) { while(left<right) { int temp = nums[left]; nums[left] = nums[right]; nums[right] = temp; left++; right--; } } void rotate(int* nums, int numsSize, int k){ if(k>=numsSize) { k%=numsSize; } //前n-k个数逆置 Reverse(nums,0,numsSize-k-1); //后k个数逆置 Reverse(nums,numsSize-k,numsSize-1); //整体逆置 Reverse(nums,0,numsSize-1); }
以上就是本篇文章的全部内容了，大家学数据结构的时候不能够光看视频，一定要下去多敲代码做题目巩固自己所学的知识。如果觉得博主的文章对你有帮助的话，可以点赞评论收藏支持一下博主。