文章目录
一、线性表
1.1 线性表的概念
线性表（linear list）是n个具有相同特性的数据元素的有限序列。
线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
二、顺序表
2.1 顺序表的概念
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
2.2 顺序表的结构
2.2.1 顺序表的分类
顺序表一般可以分为：
- 静态顺序表：使用定长数组存储元素。
所以静态顺序表只适用于确定知道需要存多少数据的场景。
静态顺序表的定长数组导致N定长，空间开多了浪费，开少了不够用。
所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小。- 动态顺序表：使用动态开辟的数组存储。
2.2.2 静态顺序表代码示例
#define N 10
typedef int SLDateType;
struct SeqList
{
SLDateType arr[N];
int sz;
};
//缺点：无法充分利用好内存空间，每次都需要手动调整具体大小，
//可能产生开辟内存不够或过多等问题。
2.2.3 动态顺序表代码示例
//SeqList.h 声明变量及函数
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define INIT_CAPACITY 4
typedef int SLDataType;
typedef struct SeqList
{
SLDataType* a;
int size;
int capacity;
}SL;
void SLInit(SL* ps);//顺序表初始化
void SLPushBack(SL* ps, SLDataType x);//顺序表尾插
void SLpopBack(SL* ps); //顺序表尾删
void SLCheckCapacity(SL* ps);//顺序表检查是否需要扩容
void SLPushFront(SL* ps, SLDataType x);//顺序表头插
void SLpopFront(SL* ps);//顺序表头删
void SLInsert(SL* ps, int pos,SLDataType x);//顺序表任意位置插入
void SLErase(SL* ps, int pos);//顺序表任意位置删除
void SLPrint(SL* ps);//顺序表打印
void SLDestroy(SL* ps);//顺序表释放
int SLFind(SL* ps, SLDataType x);//顺序表数据查找
//SeqList.c 实现函数
#include "SeqList.h"
void SLInit(SL* ps)
{
assert(ps);
ps->a = (SLDataType *)malloc(sizeof(SLDataType) * INIT_CAPACITY);
if (ps->a == NULL)
{
perror("malloc fail");
return;
}
ps->size = 0;
ps->capacity = INIT_CAPACITY;
}
void SLCheckCapacity(SL* ps)
{
assert(ps);
if (ps->size == ps->capacity)
{
SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity * 2);
if (tmp == NULL)
{
perror("realloc fail");
return;
}
ps->a = tmp;
ps->capacity *= 2;
}
}
void SLPushBack(SL* ps, SLDataType x)
{
/*SLCheckCapacity(ps);
ps->a[ps->size++] = x;*/
SLInsert(ps, ps->size, x);
}
void SLpopBack(SL* ps)
{
/*assert(ps);
assert(ps->size > 0);
ps->size--;*/
SLErase(ps, ps->size - 1);
}
void SLPushFront(SL* ps, SLDataType x)
{
/*assert(ps);
SLCheckCapacity(ps);
int end = ps->size - 1;
while (end >= 0)
{
ps->a[end + 1] = ps->a[end];
--end;
}
ps->a[0] = x;
ps->size++;*/
SLInsert(ps, 0, x);
}
void SLpopFront(SL* ps)
{
/*assert(ps);
int begin = 1;
while (begin < ps->size)
{
ps->a[begin - 1] = ps->a[begin];
++begin;
}
ps->size--;*/
SLErase(ps, 0);
}
void SLInsert(SL* ps, int pos, SLDataType x)
{
assert(ps);
assert(pos >= 0 && pos <= ps->size);
SLCheckCapacity(ps);
int end = ps->size - 1;
while (end >= pos)
{
ps->a[end + 1] = ps->a[end];
--end;
}
ps->a[pos] = x;
ps->size++;
}
void SLErase(SL* ps, int pos)
{
assert(ps);
assert(pos >= 0 && pos < ps->size);
int begin = pos + 1;
while(begin < ps->size)
{
ps->a[begin - 1] = ps->a[begin];
++begin;
}
ps->size--;
}
void SLPrint(SL* ps)
{
assert(ps);
int i = 0;
for (i = 0; i < ps->size; i++)
{
printf("%d ", ps->a[i]);
}
printf("\n");
}
int SLFind(SL* ps, SLDataType x)
{
assert(ps);
for (int i = 0; i < ps->size; ++i)
{
if (ps->a[i] == x)
{
return i;
}
}
return -1;
}
void SLDestroy(SL* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->capacity = ps->size = 0;
}
//test.c 调用测试
#include "SeqList.h"
void TestSeqList1()
{
SL s;
SLInit(&s);
SLPushBack(&s, 1);
SLPushBack(&s, 2);
SLPushBack(&s, 3);
SLPushBack(&s, 4);
SLPushBack(&s, 5);
SLPushBack(&s, 6);
SLPushBack(&s, 7);
SLPushBack(&s, 8);
SLPushBack(&s, 9);
SLPrint(&s);
SLInsert(&s, 4, 40);
SLPrint(&s);
SLInsert(&s, 0, 40);
SLPrint(&s);
SLErase(&s, 4);
SLPrint(&s);
SLErase(&s, 4);
SLPrint(&s);
SLpopBack(&s);
SLPrint(&s);
SLpopBack(&s);
SLPrint(&s);
SLpopBack(&s);
SLPrint(&s);
SLpopBack(&s);
SLPrint(&s);
SLpopBack(&s);
SLPrint(&s);
SLpopBack(&s);
SLPrint(&s);
SLpopBack(&s);
SLPrint(&s);
SLpopBack(&s);
SLPrint(&s);
SLDestroy(&s);
}
void TestSeqList2()
{
SL s;
SLInit(&s);
SLPushFront(&s, 1);
SLPushFront(&s, 2);
SLPushFront(&s, 3);
SLPushFront(&s, 4);
SLPrint(&s);
SLpopFront(&s);
SLPrint(&s);
SLpopFront(&s);
SLPrint(&s);
SLpopFront(&s);
SLPrint(&s);
SLDestroy(&s);
}
int main()
{
TestSeqList1();
TestSeqList2();
return 0;
}
结果如下：
2.3 顺序表习题（Leetcode）
2.3.1 移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与val 不同的元素的数量。
更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums的大小并不重要。返回 k。
int removeElement(int* nums, int numsSize, int val) {
int src = 0;
int dst = 0;
while(src < numsSize)
{
if(nums[src] == val)
{
src++;
}
else
{
nums[dst++] = nums[src++];
}
}
return dst;
}
2.3.2 删除有序数组中的重复项
给你一个非严格递增排列的数组nums，请你原地删除重复出现的元素，使每个元素只出现一次,返回删除后数组的新长度。元素的相对顺序应该保持一致。然后返回nums中唯一元素的个数。
int removeDuplicates(int* nums, int numsSize) {
int src = 1;
int dst = 0;
while(src < numsSize)
{
if(nums[src] != nums[dst])
{
nums[++dst] = nums[src];
}
src++;
}
return dst + 1;
}
2.3.3 合并两个有序数组
给你两个按非递减顺序排列的整数数组nums1和nums2，另有两个整数m和n，分别表示nums1和nums2中的元素数目。
void merge(int* nums1,int nums1Size,int m,int* nums2,int nums2Size,int n)
{
//nums1Size = m + n;nums2Size = n;
int dst = nums1Size - 1;
int end1 = m - 1;
int end2 = n - 1;
while(end1 >= 0 && end2 >= 0)
{
if(nums2[end2] > nums1[end1])
{
nums1[dst--] = nums2[end2--];
}
else
{
nums1[dst--] = nums1[end1--];
}
}
while(end2 >= 0)
{
nums1[dst--] = nums2[end2--];
}
}
2.3.4 顺序表结构的缺陷
- 在进行中间或头部的插入和删除时，时间复杂度为O(N)。
- 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
- 增容一般是呈2倍的增长，势必会有一定的空间浪费。
三、链表
3.1 链表的概念
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
3.2 链表的分类
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
1、单向或者双向
//SLite.h
#include <stdio.h>
#include <stdlib.h>
typedef int SLTDataType;
typedef struct SListNode
{
SLTDataType data;
struct SListNode* next;
}SLTNode;
void SLTPrint(SLTNode* phead);
//SLite.h
#include "SList.h"
void SLTPrint(SLTNode* phead)
{
SLTNode* cur = phead;
while (cur->next != NULL)
{
printf("%d-> ", cur->data);
cur = cur->next;
}
printf("NULL\n");
}
//test.c
2、带头或者不带头
3、循环或者非循环
- 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。
- 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单。
3.3 链表的实现
1444
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
