c++ 顺序表

总结归纳

• 动态分配对内存有着更大的控制权，但也会花费相应的时间。
• 顺序表的查找时间复杂度为O(1)，这是单链表所不具备的。
• 顺序表的插入，要从后往前遍历，因为数据要后移；顺序表的删除，要从前往后遍历，因为数据要前移。

顺序表存储

     原理：顺序表存储是将数据元素放到一块连续的内存存储空间，存取效率高，速度快。但是不可以动态增加长度

     优点：存取速度高效，通过下标来直接存储

     缺点：1.插入和删除比较慢，2.不可以增长长度   

                比如：插入或者删除一个元素时，整个表需要遍历移动元素来重新排一次顺序

链表存储

      原理：链表存储是在程序运行过程中动态的分配空间，只要存储器还有空间，就不会发生存储溢出问题

     优点：插入和删除速度快，保留原有的物理顺序，比如：插入或者删除一个元素时，只需要改变指针指向即可

     缺点：查找速度慢，因为查找时，需要循环链表访问
从它们的存储优缺点来看，各自有各自的使用场景，比如：频繁的查找却很少的插入和删除操作可以用顺序表存储，如果频繁的插入和删除操作很少的查询就可以使用链表存储
 

线性顺序表的定义

一种方法是 ：在静态分配时，由于数组的大小和空间实现已经固定，一旦空间占满，再加入新的数据将产生溢出，就会导致程序崩溃

#define InitSize 5 // 顺序表初始长度, 注意，不能放分号
struct SqList {
    int* data; // 数组
    int MaxSize; // 顺序表的最大长度
    int length; // 顺序表的当前长度
};

另一种方法是：动态分配时，储存数组的空间实在程序执行过程中通过动态存储分配语句分配的，一旦数据空间占满，可以另外开辟一块更大的存储空间，用以替换原来的存储空间，从而达到扩充存储数组空间的目的，而不需要一次性地划分所有所需空间给线性表。

#define InitSize = 100              //表长度的初始定义
typedef struct {
    int* data;                 //只是动态分配数组的指针
    int MaxSize, length;             //数组的最大容量和当前个数
}SqList;  

具体操作

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>
#define InitSize 5 // 顺序表初始长度

using namespace std;

struct SqList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

// 初始化顺序表
void InitList(SqList& L) {
	L.data = new int[InitSize];
	L.MaxSize = InitSize;
	L.length = 0;
}

// 为顺序表中的数据赋值
void AssginList(SqList& L) {
	for (int i = 0; i < InitSize; i++) {
		L.data[i] = i;
		L.length++;
	}
}

// 求表长
int Length(SqList& L) { return L.length; }

// 动态增加顺序表长度
void IncreaseSize(SqList& L, int len) {
	int* p = L.data;
	L.data = new int[L.MaxSize + len];
	for (int i = 0; i < L.length; i++) {
		L.data[i] = p[i]; // 将原数据赋值到新内存中
	}
	L.MaxSize = L.MaxSize + len;
	delete p;
}

// 按位查找：查找第i个位置的元素
int GetElem(SqList& L, int i) {
	return L.data[i - 1];
}

// 按值查找：查找值为i的元素位置
int LocateElem(SqList& L, int i) {
	for (int j = 0; j < L.length; j++) {
		if (L.data[j] == i) {
			return j + 1;
		}
	}
	return 0; // 没有查找到则返回0
}

// 插入：在第i个位置插入e
void ListInsert(SqList& L, int i, int e) {
	if (L.length = L.MaxSize) { // 内存已满需要扩充
		IncreaseSize(L, 1);
	}
	for (int j = L.length; j >= i; j--) {
		L.data[j] = L.data[j - 1]; // 插入位置之后的数据后移
	}
	L.data[i - 1] = e;
	L.length++;
}

// 删除：删除第i个位置的元素
bool ListDelete(SqList& L, int i, int& e) {
	if (i < 0 || i > L.length) { // 删除超出范围
		return false;
	}
	e = L.data[i - 1];
	for (int j = i; j < L.length; j++) {
		L.data[j - 1] = L.data[j]; // 数据前移
	}
	L.data[L.length] = 0; //最后一个元素初始化
	L.length--;
	return true;
}

// 按顺序输出
void PrintList(SqList& L) {
	for (int i = 0; i < L.length; i++) {
		cout << L.data[i] << " ";
	}
	cout << endl;
}

int main() 
{
	struct SqList L;
}

题目：

1. 从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错误信息并退出运行。

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<numeric>
#include<iomanip>
#include<math.h>
#include<bitset>
#include<vector>
#include<stack>
#include<map>
#include<stdio.h>
#include<set>

using namespace std;

//定义一个顺序表
struct SqlList {
	int* data; // 数组
	int MaxSize; // 顺序表的最大长度
	int length; // 顺序表的当前长度
};

//删除顺序表L中最小值元素结点，并通过引用性参数value返回其值
//如果删除成功，返回true；否则，返回false
bool Min_del(SqlList& L)
{
	if (L.length == 0) return false;//表空的话
	int value = L.data[0];
	int pos = 0;
	for (int i = 1; i < L.length; i++)
	{
		if (L.data[i] < value) value