线性表(逻辑结构)--顺序表(存储结构)

！！做题的时候注意位序i和数组下标的区别！！

顺序表定义

顺序表：指用顺序存储的方式实现线性表顺序存储
C语言：sizeof(ElementType)

typedef struct{
	int num;
	int people;
}Customer;
sizeof(Customer);

sizeof(Customer) = 8B;

顺序表的实现

静态分配

#define Maxsize 10					//定义线性表的最大长度
typedef struct{
	ElemType data[MaxSize];			//顺序表的元素
	int length;						//顺序表的当前长度
}SqList;							//顺序表的类型定义

Sq:sequence–顺序序列

#include <stdio.h>
#define MaxSize 10
//静态分配 
typedef struct{
	int data[MaxSize];						//静态数组
	int length;
}SqList;

void InitList(SqList &L){					//对线性表L初始化
	for(int i = 0;i < MaxSize;i++){	        
		L.data(i) = 0;					    //初始化每一个数据元素都为0
	}
	L.length = 0;							//初始化线性表的长度为0
} 

bool ListInsert(SqList &L,int i,ElemType e){
	if(i < 1 || i > L.length + 1 || L.length >= MaxSize)return false;//判断插入位置i是否有效
	for(int j = L.length;j >= i; j--)L.data[j] = L.data[j-1];
	L.data[i - 1] = e;
	L.length ++;
	return ture;
}

int main(){
	SqList L;								//建立结构体
	InitList(L);							//初始化结构体中的数组和长度
	return 0;		
}

动态分配

#include <stdio.h>
#define InitSize 10
//动态分配
	
typedef struct{
	int *data;
	int MaxSize; 
	int length;
}SqList;

void InitList(SqList &L){
	L.data = (int *)malloc(InitSize*sizeof(int));
	L.MaxSize = InitSize;
	L.length = 0;
} 
 
void IncreaseSize(SqList &L,int len){
	int *p = L.data;
	L.data = (int *)malloc((L.MaxSize + len)*sizeof(int));
 	for(int i = 0;i < L.length;i++){
 		L.data[i] = p[i];
	 }
	 L.MaxSize += len;
	 free(p);
}

int main(){
	SqList L;
	InitList(L);
	IncreaseSize(L,5);
	return 0;
}

顺序表特性

• 随机访问，在常数级时间内找到第i个元素
• 存储密度高，每个节点只存储数据本身
• 拓展容量不方便
• 插入、删除操作不方便，需要移动大量元素

顺序表的插入和删除

插入

实现

#define MaxLen 10
typedef struct{
	int data[MaxLen];
	int length;
}SqList;
bool InsertList(SqList &L,int i,int e){
	if(i<1||i>L.length+1)
		return false;
	if(L.length == MaxLen)
		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 ture; 
}
int main(){
	SqList L;
	InitList(L);
	InsertList(L,5);
	return 0;
}

时间复杂度

最好情况：当i = length +1 则不进入for循环，直接插入

	L.data[i-1] = e;

最好时间复杂度O(1)

最坏情况： 当i = 1 则进入循环，n个元素全都往后移，循环n次
时间复杂度为O(n)

平均情况
设循环次数为x_n
则x_1 = n;x_2 = n-1;x_k = n-k+1
平均循环次数为

$$\frac{{\sum }_{k=1}^{n+1}{a}_k}{n+1}=\frac{n}{2}$$
时间复杂度为O(n)

删除

实现

#define MaxLen 10
typedef struct{
	int data[MaxLen];
	int length;
}SqList;
bool ListDelete(SqList &L,int i,int &e){
	if(i < 1 || i > L.length)
		retern false;
	int e = L.data[i-1];
	for(int j = i - 1;j < length - 1;j++){
		L.data[j] = L.data[j+1];
	} 
	L.length --;
	return true;
}

时间复杂度

最好情况 i = length 不进入循环 时间复杂度T(n) = O(1)
最差情况 i= 1 循环n次 时间复杂度T(n) = O(n)
平均情况 $$\frac{{\sum }_{k=0}^n{a}_k}{n}=\frac{n-1}{2}$$
时间复杂度为O(n)

查找

按位查找

GetElement(L,i):按位查找。获取表中第i个位置元素的值

实现

静态分配

#include "stdio.h"
#define MaxSize 10
typedef struct{
	int data[MaxSize];
	int length;
}sqList;
int GetElemById(sqList L,int i){
	return L.data[i-1];
}

动态分配

#define DataSize 10
typedef struct{
	int *data;
	int maxSize;
	int length;
}SqList;
int GetEleById(SqList L,int i){
	retuen L.data[i-1];
}

时间复杂度

O(1)

按值查找

实现

int GetEleByVal(SqList L,int e){
	for(int i = 0;i < L.length; i++){
		if(L.data[i] == e)//如果Data是结构类型，不能直接==
			retuen i+1;
	}
	return 0;
}

时间复杂度

be=O(1)
wo=O(n)
aver=O(n)