目录
——逻辑结构：数据的逻辑结构可以看作从具体问题抽象出来数学模型，他与数据的存储无关。
——物理结构：是指数据的逻辑结构在计算机中的存储形式（又称映像），因此也称为存储结构。
1. 原地移除数组中所有的元素val，要求时间复杂度为O(N)，空间复杂度为O(1).
绪论
——逻辑结构：数据的逻辑结构可以看作从具体问题抽象出来数学模型，他与数据的存储无关。
是面向问题的
在任何问题中，数据元素都不会是孤立的，在他们之间存在着这样或那样的关系，这种数据元素之间存在的关系称为数据的逻辑结构。根据数据元素之间关系的不同特性，通常有以下4类基本的逻辑结构。
是指数据对象中数据元素之间的相互关系
可具体分为以下四种关系
A:集合结构
数据元素之间的关系除了同属于一个集合外，它们之间没有其他关系
B:线性结构
数据元素之间的关系除了同属于一个集合外，数据元素之间还存在着一对一的顺序关系
C:树形结构
数据元素之间存在着一对多的层次关系
D:图形结构
数据元素之间存在着多对多的任意关系
——物理结构：是指数据的逻辑结构在计算机中的存储形式（又称映像），因此也称为存储结构。
是面向计算机的
物理结构研究的是数据结构在计算机中的实现方法，实际就是实现数据结构中数据元素的存储表示及数据元素之间关系的表示。
数据的存储结构应正确反映数据元素之间的逻辑关系
数据元素的存储结构形式有两种：顺序存储 和 链式存储
一：顺序存储结构
是把数据元素存放在地址连续的存储单元里
其数据间的逻辑关系和物理关系是一致的
二： 链式存储结构
是把数据元素存放在任意的存储单元里
这组存储单元可以是连续的
也可以是不连续的
1.线性表
线性表（linear list）是n个具有相同特性的数据元素的有限序列。
线性表是一种在实际中广泛使 用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。
2.顺序表
2.1概念及结构
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存 储。在数组上完成数据的增删查改。
顺序表有一个要求：数据必须从第一个位置开始，连续存储的
顺序表一般可以分为：
1. 静态顺序表：使用定长数组存储元素。
2. 动态顺序表：使用动态开辟的数组存储。
2.2 接口实现
静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空 间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间 大小，所以下面我们实现动态顺序表。
typedef int SLDataType;
//顺序表的动态存储
typedef struct SeqList
{
SLDataType *array;//指向数组的指针
int size;//有效数据个数
int capacity;//容量 - 空间大小
}SL;2.2. 1 顺序表的动态扩容、打印及初始化
//顺序表打印
void SLPrint(SL* ps);
void SLPrint(SL* ps)
{
assert(ps);
for (int i = 0; i < ps->size; i++)
{
printf("%d ", ps->array[i]);
}
printf("\n");
}// 顺序表初始化
void SLInit(SL* ps);
void SLInit(SL* ps)
{
assert(ps);
ps->array = NULL;
ps->size = ps->capacity = 0;
}// 检查空间，如果满了，进行增容
void SLCheckCapacity(SL* ps);
void SLCheckCapacity(SL* ps)
{
assert(ps);
//检查容量空间，满了就要扩容
if (ps->capacity == ps->size)
{
int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//扩容
SLDataType* tmp = (SLDataType*)realloc(ps->array, newCapacity * sizeof(SLDataType));
if (NULL == tmp)
{
perror("realloc");
exit(-1);
}
ps->array = tmp;
ps->capacity = newCapacity;
}
}2.2.2 顺序表头尾基本增删接口
//顺序表尾插
void SLPushBack(SL* ps, SLDataType x);
void SLPushBack(SL* ps, SLDataType x)
{
assert(ps);
/*SLCheckCapacity(ps);
ps->array[ps->size] = x;
ps->size++;*/
SLInsert(ps, ps->size, x);
}//顺序表尾删
void SLPopBack(SL* ps);
void SLPopBack(SL* ps)
{
assert(ps);
//温柔检查是否越界
/*if (ps->size == 0)
{
printf("SeqList is empty\n");
return;
}
else
--ps->size;*/
//暴力检查
//assert(ps->size > 0);
//--ps->size;
SLErase(ps, ps->size-1);
}//越界时不一定报错的
//系统对越界的检查是，设岗抽查
//顺序表头插
void SLPushFront(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x)
{
assert(ps);
//SLCheckCapacity(ps);
//int end = ps->size - 1;
//while (end>=0)
//{
// ps->array[end + 1] = ps->array[end];
// --end;
//}
//ps->array[0] = x;
//ps->size++;
SLInsert(ps, 0, x);
}//顺序表头删
void SLPopFront(SL* ps);
void SLPopFront(SL* ps)
{
assert(ps);
//assert(ps->size > 0);
//int begin = 1;
//while (begin < ps->size)
//{
// ps->array[begin - 1] = ps->array[begin];
// ++ begin;
//}
//ps->size--;
SLErase(ps, 0);
}顺序表
尾插尾删时间复杂度度为O(1),效率很高
而头插头删，需要挪动数据，时间复杂度为O(N)，效率很低，怎么解决呢？——链表
2.2.3 顺序表的指定位置插入删除接口
// 顺序表在pos位置插入x
void SLInsert(SL* ps, int pos, SLDataType x);
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->array[end+1] = ps->array[end];
end--;
}
ps->array[pos] = x;
ps->size++;
}// 顺序表在pos位置删除
void SLErase(SL* ps, int pos);
void SLErase(SL* ps, int pos)
{
assert(ps);
assert(ps->size > 0 && pos < ps->size);
int begin = pos;
while (begin < ps->size-1)
{
ps->array[begin] = ps->array[begin + 1];
++begin;
}
ps->size--;
}
2.2.4 顺序表的查找和修改接口
// 顺序表查找
int SLFind(SL* ps, SLDataType x);
int SLFind(SL* ps, SLDataType x)
{
assert(ps);
for (int i = 0; i < ps->size; i++)
{
if (ps->array[i] == x)
{
return i;
}
}
return -1;
}顺序表一般不使用查找，因为要遍历整个数组，效率低，提升效率的算法后续增加
而二分查找不适合顺序表，因为顺序表内容是无序的，需要排序，而排序的代价过大
//顺序表修改
int SLModify(SL* ps, int pos, SLDataType x);
int SLModify(SL* ps, int pos, SLDataType x)
{
assert(ps);
assert(pos < ps->size&& pos>=0);
ps->array[pos] = x;
}2.2.5 顺序表接口结合的多种用法
注意：查找，修改，删除结合可以形成多种用法
void TestSeqList7()
{
SL sl;
SLInit(&sl);
SLPushFront(&sl, 8);
SLPushFront(&sl, 2);
SLPushFront(&sl, 3);
SLPushFront(&sl, 4);
SLPushFront(&sl, 5);
SLPushFront(&sl, 2);
SLPrint(&sl);
int deleData = 0;
printf("Please enter the data you need to delete:>");
scanf("%d", &deleData);
int pos = SLFind(&sl, deleData);
if (pos != -1)
{
SLErase(&sl, pos);
}
else
{
printf("NOT FIND:%d!\n", deleData);
}
SLPrint(&sl);
int x = 0; int y = 0;
printf("Please enter the data you need to modify, and the modified data:>");
scanf("%d %d", &x,&y);
pos = SLFind(&sl, x);
if (pos != -1)
{
SLModify(&sl, pos, y);
}
else
{
printf("The data:>%d you want to delete was not found!\n", x);
}
SLPrint(&sl);
//删除所有的数字2
printf("Remove all number 2:>\n");
while ((pos = SLFind(&sl, 2)) != -1)
{
SLErase(&sl, pos);
}
SLPrint(&sl);
}
int main(int argc,char* argv[])
{
TestSeqList7();
//越界时不一定报错的
//系统对越界的检查是，设岗抽查
return 0;
}
2.2.6 顺序表简易菜单
void menu()
{
printf("***********************************\n");
printf("1、尾插 2、头插\n");
printf("3、查找 4、删除\n");
printf("5、修改 6、打印 -1、退出\n");
printf("***********************************\n");
}
int main()
{
SL sl;
SLInit(&sl);
int option = -1;
do
{
menu();
scanf("%d", &option);
int val, pos;
switch (option)
{
case 1:
printf("请连续输入你要插入的数据,以0结束:>");
while (scanf("%d", &val)!=EOF && val != 0)
{
SLPushBack(&sl, val);
}
break;
case 2:
break;
case 3:
{
int deleData = 0;
printf("Please enter the data you need to delete:>");
scanf("%d", &deleData);
int pos = SLFind(&sl, deleData);
if (pos != -1)
{
SLErase(&sl, pos);
}
else
{
printf("NOT FIND:%d!\n", deleData);
}
break;
}
case 4:
break;
case 5:
{
int x = 0; int y = 0;
printf("Please enter the data you need to modify, and the modified data:>");
scanf("%d %d", &x, &y);
pos = SLFind(&sl, x);
if (pos != -1)
{
SLModify(&sl, pos, y);
}
else
{
printf("The data:>%d you want to delete was not found!\n", x);
}
break;
}
case 6:
SLPrint(&sl);
break;
case -1:
{
exit(0);
break;
}
default:
break;
}
} while (option != EOF);
SLDestory(&sl);
return 0;
}2.3 数组相关面试题
### 双指针法
双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
- 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
- 慢指针：指向更新 新数组下标的位置
1. 原地移除数组中所有的元素val，要求时间复杂度为O(N)，空间复杂度为O(1).
27. 移除元素 - 力扣（LeetCode）要求：空间复杂度围为O(1) ,时间复杂度为O(N)
int removeElement(int* nums, int numsSize, int val) {
int src = 0, dst = 0;
if (numsSize == 0)
return 0;
while (src < numsSize)
{
if (nums[src] != val)
{
nums[dst++] = nums[src];
}
src++;
}
return dst;
}2. 删除排序数组中的重复项。(去重算法)
26. 删除有序数组中的重复项 - 力扣（LeetCode）空间复杂度要求O(1) 时间复杂度O(N)
int removeDuplicates(int* nums, int numsSize){
int src = 0, dst = 0;
if (numsSize <= 1)
return 1;
while (src < numsSize)
{
if (nums[src] != nums[dst])
{
dst++;
nums[dst] = nums[src];
}
src++;
}
return dst+1;
}3. 合并两个有序数组。
88. 合并两个有序数组 - 力扣（LeetCode）时间复杂度O(M+N)
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
int end1 = m - 1, end2 = n - 1;
int end = m + n - 1;
while (end1 >= 0 && end2 >= 0)
{
if (nums1[end1] <= nums2[end2])
{
nums1[end --] = nums2[end2--];
}
else
{
nums1[end --] = nums1[end1--];
}
}
if (end1 < 0 && end2 >= 0)
{
while (end2 >= 0)
{
nums1[end2--] = nums2[end2];
}
}
}2.4 顺序表的问题及思考
问题：
1. 中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到 200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
链表学习
5733
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
