【无标题】

顺序表和链表—顺序表

1.顺序表（最大的优点：支持随机访问）

1.1概念及其结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表一般可以分为：

1. 静态顺序表：使用定长数组存储元素。

2. 动态顺序表：使用动态开辟的数组存储。![在这插入图片描述](https://img-blog.csdnimg.cn/f21ac9a63a2f4d909e4b90a281753d6c.png

1.2 接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表

//SeqList.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLTDataType;

typedef struct SeqListNode
{
	SLTDataType* a;
	int capacity;
	int size;

}SLTNode;

void SLTInit(SLTNode* psl);//初始化顺序表
void SLTDestroy(SLTNode* psl);//销毁
void SLTPushBack(SLTNode* psl, SLTDataType x);//尾插
void CheckCapacity(SLTNode* psl);//检查是否已满
void SLTPopBack(SLTNode* psl);//尾删
void SLTPushFront(SLTNode* psl, SLTDataType x);//头插
void SLTPopFront(SLTNode* psl);//头删
int SLTFind(SLTNode* psl, SLTDataType x);//查找 并返回下标
void SLTInsert(SLTNode* psl, int pos, SLTDataType x);//任意位置插入
void SLTErase(SLTNode* psl,int pos);//任意位置删除
void SLTPrint(SLTNode* psl);//打印

```c
//SeqList.c
#include"SeqList.h"

void SLTInit(SLTNode* psl)
{
	psl->a = (SLTDataType*)malloc(sizeof(SLTDataType) * 4);
	assert(psl);
	psl->capacity = 4;
	psl->size = 0;
}

void CheckCapacity(SLTNode* psl)
{
	assert(psl);
	if (psl->capacity == psl->size)
	{
		int newcapacity = psl->capacity * 2;
		SLTDataType* tmp = (SLTDataType*)realloc(psl->a, sizeof(SLTDataType) * newcapacity);
		assert(tmp);
		psl->a = tmp;
		psl->capacity = newcapacity;
	}
}

void SLTDestroy(SLTNode* psl)
{
	assert(psl);
	free(psl->a);
	psl->a = NULL;
	psl->capacity = psl->size = 0;
	psl = NULL;
}

void SLTPushBack(SLTNode* psl, SLTDataType x)
{
	assert(psl);
	CheckCapacity(psl);
	psl->a[psl->size++] = x;
}

void SLTPopBack(SLTNode* psl)
{
	assert(psl);
	assert(*(psl->a));
	psl->a[psl->size--]=0;
}

void SLTPushFront(SLTNode* psl, SLTDataType x)
{
	assert(psl);
	int i = psl->size;
	while(i >=0)
	{
		psl->a[i+1] = psl->a[i];
		i--;
	}psl->a[0] = x;
	psl->size++;
}

void SLTPopFront(SLTNode* psl)
{
	assert(psl);
	assert(*(psl->a));
	int i = 0;
	while (i <psl->size-1)
	{
		psl->a[i +1] = psl->a[i];
		i++;
	}
	psl->size--;
}

int SLTFind(SLTNode* psl, SLTDataType x)
{
	assert(psl);
	assert(*(psl->a));
	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}

}

void SLTInsert(SLTNode* psl, int pos, SLTDataType x)
{
	assert(psl);
	assert(*(psl->a));
	int i = psl->size-1;
	while (i >= pos)
	{
		psl->a[i + 1] = psl->a[i];
		i--;
	}psl->a[pos] = x;
	psl->size++;

}

void SLTErase(SLTNode* psl,int pos)
{
	assert(psl);
	assert(*(psl->a));
	int i = pos;
	while (i < psl->size)
	{
		psl->a[i] = psl->a[i + 1];
	}psl->size--;

}

void SLTPrint(SLTNode* psl)
{
	assert(psl);
	for (int i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}

}
//test.c
#include"SeqList.h"

void SLTTest()
{
	SLTNode sl;
	//在这里测试函数接口


}
int main()
{
	SLTTest();

	return 0;
}

### 1.4 顺序表的问题及思考
问题：
1. 中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们
再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
所以又给出了链表