数据结构 2.线性表

数据结构三要素----逻辑结构、数据的运算、存储结构（物理结构）

1.线性表的定义

线性表的定义：具有相同数据类型的n个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。如：L=（a1,a2,a3,.....an）

几个概念：

        ai是线性表的“第i个”元素线性表中的位序

        a1是表头元素；an是表尾元素

        除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继

2.线性表的基本操作

        InitList(&L):初始化表。构造一个空的线性表L，分配内存空间

        DestroyList(&L):销毁操作。销毁线性表，并释放L所占的内存空间

        ListInsert(&L,i,e):插入操作。在L中第i个位置插入指定元素e

        ListDelete(&L,i,&e):删除操作。删除L中第i个位置的元素，并用e返回删除元素的值

        LocateElem(L,e):按值查找操作。在L中查找具有给定关键字元素的值

        GetElem（L,i）:按位查找操作，获取L中第i个位置元素的值

        .....................

什么时候要传入参数的引用“&”----对参数的修改结果需要“带回来”

#include<stdio.h>

void test(int x){
	x=100;
	printf("test内部 x=%d\n",x);
} 

int main(){
	int x=50;
	printf("调用test前 x=%d\n",x);
	test(x);
	printf("调用test后 x=%d\n",x);
}

结果：

调用test前 x=50
test内部 x=100
调用test后 x=50

修改后：

#include<stdio.h>

void test(int &x){
	x=100;
	printf("test内部 x=%d\n",x);
} 

int main(){
	int x=50;
	printf("调用test前 x=%d\n",x);
	test(x);
	printf("调用test后 x=%d\n",x);
}

结果：

调用test前 x=50
test内部 x=100
调用test后 x=100

3.线性表的顺序存储

 顺序表--用顺序存储的方式实现线性表顺序存储。逻辑上相邻的元素存储在物理位置也相邻的存储单元中

 顺序表的实现--静态分配：

#define MaxSize 10 //定义最大长度
typedef struct{
	ElemType data[MaxSize]; //用静态数组存放数据元素 
	int length;   //顺序表长度 
}SqList; //顺序表的类型定义（静态分配方式）

 顺序表的实现--动态分配：

  顺序表的特点：

        1.随机访问，可以在O（1）时间内找到第i个元素

        2.存储密度高，每个节点只存储数据元素、

        3.拓展容量不方便（即使采用动态分配的方式实现，拓展长度的时间复杂度也比较高）

        4.插入、删除操作不方便，需要移动大量元素

4.顺序表的插入删除

#include<stdio.h> 
#define MaxSize 10 //定义最大长度
typedef struct{
	int data[MaxSize]; //用静态数组存放数据元素 
	int length;   //顺序表长度 
}SqList; //顺序表的类型定义

//初始化 
void InitList(SqList &L){
	for(int i=0;i<MaxSize;i++){
		L.data[i]=0;
	}
	L.length=0;
}
//插入  
//时间复杂度：最好O（1）最坏O（n） 平均：O（n/2）->O（n） 
bool ListInsert(SqList &L,int i,int e){
	if(i<1 || i>L.length+1) //判断i的位置是否有效 
		return false;
	if(L.length > MaxSize)  //当前存储空间已满，不能插入 
		return false;
	for(int j=L.length;j>=i;j--){  //将第i个位置元素往后移 
		L.data[j]=L.data[j-1];
	}
	L.data[i-1]=e; //在i处放入数据· 
	L.length++;    //长度+1 
	return true;	
}

//删除
//时间复杂度：最好O（1）最坏O（n） 平均：O（n-1/2）->O（n） 
bool ListDelete(SqList &L,int i,int &e){
	if(i<1 || i>L.length) //判断i的位置是否有效
		return false;
	e=L.data[i-1];  //将被删除的元素赋值给e 
	for(int j=i;j<L.length;j++){  //将第i个位置元素向前移动 
		L.data[j-1]=L.data[j];
	}
	L.length--;  //长度-1 
	return true;
} 

//按位查找 
//时间复杂度：O（1）
int GetElem(SqList L,int i){
	return L.data[i-1];
} 

//按值查找
int LocateElem(SqList L,int e){
	for(int i=0;i<L.length;i++){
		if(L.data[i] == e)
			return i+1;
	}
	return 0;
} 


int main(){
	SqList L;
	//初始化 
	InitList(L);
	//插入数据 
	ListInsert(L,1,11);
	ListInsert(L,2,12);
	ListInsert(L,3,13);
	ListInsert(L,4,14);
	ListInsert(L,5,15);
	ListInsert(L,6,16);
	ListInsert(L,7,17);
	ListInsert(L,8,18);
	ListInsert(L,9,19);
	ListInsert(L,10,20);
	printf("L插入元素后的值：：");
	for(int i=0;i<L.length;i++){
		printf("%d\t",L.data[i]);
	}
	printf("\n");
	//删除数据 
	int e=L.data[5-1];
	ListDelete(L,5,e); 
	printf("delete number is：%d\n",e);
	printf("L删除元素后的值：");
	for(int i=0;i<L.length;i++){
		printf("%d\t",L.data[i]);
	}
	printf("\n");
	//按位查找
	int num1 = GetElem(L,8);
	printf("L中第8位元素为：%d\n",num1); 
	//按值查找
	int num2 = LocateElem(L,18);
	printf("L中18为第：%d 个元素\n",num2);  
} 

结果：

L插入元素后的值：：11   12      13      14      15      16      17      18      19      20
delete number is：15
L删除元素后的值：11     12      13      14      16      17      18      19      20
L中第8位元素为：19
L中18为第：7 个元素