408数据结构-线性表

线性表（逻辑结构，运算，）

1. 一条直线一样排列的

2. 具有相同类型的

3. 有限的

4. 每个数据元素占的空间一样大

5. 有顺序

概念：

1. 第i个元素,就是位序
2. 第一个是表头元素，最后一个是表尾元素
3. 前一个元素称为前驱，后一个称为后继。表头元素没有，前驱，表尾没有后继

线性表的运算

InitList：初始化表，构造一个空的表，分配内存空间

DestroList:销毁

ListInsert（&L,i,e）插入

ListDelete（&L,i,&e）删除

LocateElem(l,e)按值查找

GetElem(L,i)按位查找

对数据的操作 无非是创建销毁，增删改查

&使用的用法

在参数加入这个符号带入的就是这个原数据

#include<iostream>
using namespace std;

void test(int& x) {
	x = 100;
}
int main() {
	int x = 10;
	cout << "没有执行方法前X=" << x << endl;
	test(x);
	cout << "执行方法后X=" << x << endl;
	return 0;
}

顺序表的定义

在逻辑上的顺序，在物理内存中也按逻辑相邻的来体现

静态分配

//定义一个顺序表
typedef struct {
	int data[10];
	int length;
}sqlList;

//初始化顺序表
void initList(sqlList& L) {
	for (int i = 0; i < 10; i++) {
		L.data[i] = 0;
	}
	L.length = 0;

}
//声明一个顺序表
int main() {
	sqlList L;
}

动态分配

//定义一个线性表
typedef struct {
	int* data; //存数据的地址
	int MaxSize; //最大的容量
	int length; //当前的存了多少
}sqlList;

//初始化该线性表
void initList(sqlList& L) {
	L.data = (int*)malloc(sizeof(int) * initSize);
	L.length = 0;
	int MaxSize = initSize;

}
//增加操作
void add(sqlList& L, int addLen) {
    
	int* p = L.data;//先保存原来的地址
    //在开辟一段空间
	L.data = (int*)malloc(sizeof(int) * (initSize + addLen));
    //把原来的空间数据复制到新的
	for (int i = 0; i < L.length; i++) {
		L.data[i] = p[i];
	}
    //最大容量增加
	L.MaxSize = initSize + addLen;
    //释放空间
	free(p);
}
int main() {
	sqlList L;
}

顺序表的特点

1. 随机访问，找到第几个元素，就直接找到元素因为一连续的空间可算出第几个元素的地址，比如位序第3个元素，可以直接找到，因为知道第一个地址，可算出三个地址，所以顺序表可以很好的查到，元素但是，是按位查找。

   时间复杂度为1

2. 存储密度高，只存储数据

3. 插入删除不方便

插入

typedef struct {
	int date[10];
	int length;
}sqlList;

bool ListInsert(sqlList &L,int i,int e) {
	//判断插入是否合法
	if (i<1||i>L.length+1) {
		return false;
	}
	//判断是否插满了
	if (L.length == L.MaxSize) {
		return false;
	}
	//以长度为起始 把最后，后移一位，直到移动添加的位置
	for (int j = L.length; j >=i;j--) {
		L.data[j] = L.data[j - 1];
	}
	L.data[i - 1] = e;
	L.length++;

	return true;
}

时间复杂度最好为O(1) 直接插入到最后一位

表元素不用后移

最差到第一位全部后移 为O（n）

删除

typedef struct {
	int date[10];
	int length;
}sqlList;

bool ListDelete(sqlList& L, int i, int e) {
	if (i<1 || i>L.length + 1) {
			return false;
	}
	for (int j = L.length; j > L.length; j++) {
		L.data[i-1]	==L.data[i];
	}
	
	L.length--;
	return true;

}

查找

按位查找

typedef struct {
	int date[10];
	int length;
}sqlList;

int GetElem(sqlList L,int i) {
	return L.date[i - 1];
}

按值查找

typedef struct {
	int* data;
	int MaxSize;
	int length;
}sqlList;


int LocateElem(sqlList L,int e) {
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] == e) {
			return i + 1;
		}
	}
	return -1;
}

​ 顺序表 单链表

插入复杂度 n/2 （1~n）

删除复杂度 (n-1)/2 (1~n)

按位查找 1

按值查找 （1+n）/2(1~n)

单链表

	顺序表	单链表
优点	可以随机存取，存储密度高	不要求连续空间，可随便改变容量
缺点	删除添加不方便，要大片的连续空间	不可随机存取，和耗费内存，存指针