线性表（逻辑结构、存储结构、运算）

定义（逻辑结构）：相同数据类型的、n个数据元素、有限、有序

基本操作：创销、增删改查

（1）InitList(&L):初始化表。构造空表，分配内存空间。

（2）DestroyList(&L):销毁。释放内存空间。

（3）InsertList(&L, i, e):插入。在表L的第i位插入元素e。

（4）DeletList(&L, i, &e):删除。表L在第i位置的值，用&e返回被删除的值。

（5）LocateElem(L,e)按值查找,在表中找与给定值相同元素

（6）GetElem(L,i)按位查找，获取表中第i个位置元素值

其他常用操作

（1）Lenth(L),求表长

（2）PrintList(L),输出表

（3）IsEmpty(L),判空操作

存储结构

线性表逻辑结构只有一种，存储结构有多种，顺序存储为顺序表，链式存储为链表。

顺序存储（顺序表）

定义：逻辑相邻，物理也相邻

顺序表的实现

1.静态分配

定义结构体
初始化（定义数组）

#include<stdio.h>
#define MaxSize 10//定义最大长度

typedef struct {
	int date[MaxSize];//定义数组存储数据
	int lenth;//当前长度
}SqList;//顺序表的类型定义

void InitList( SqList &L ){
	for( int i=0; i<MaxSize; i++ )
		L.date[i] = 0;
	L.lenth = 0;
}

int main(int argc, char const*argv[])
{
	SqList L;
	InitList( L );
	return 0;
}

2.动态分配

定义结构体
初始化（申请内存）
空间增加

对比：此篇文章数组空间可自增

#include<stdio.h>
#include<stdlib.h>

#define InitSize 10//注意宏定义名称与变量名称不可重复

typedef struct{
	int *data;     //指示动态分配数组的指针
	int MaxSize;
	int lenth;
}SeqList;

void InitList(SeqList &L){
	L.data = (int*)malloc(sizeof(int)*InitSize);
	L.lenth = 0;
	L.MaxSize = InitSize;
}

void IncreaseSize( SeqList &L, int len ){
	int*p = L.data;
	L.data = ( int* )malloc( sizeof(int)*(L.MaxSize+len) );
	for( int i=0; i<(L.MaxSize+len); i++ ){
		L.data[i] = p[i];//将数据复制到新的区域
	}
	L.MaxSize = L.MaxSize+len;
	free(p);
}

int main( int argc, char const*argv[] )
{
	SeqList L;
	InitList( L );
	IncreaseSize( L, 5 );
	
}

顺序表特点

（1）随机访问
（2）存储密度高
（3）空间拓展不变（复制时间长）
（4）插入、删除操作麻烦

顺序表的插入

定义结构体
初始化操作
插入操作

#include<stdio.h>

#define MaxSize 3

typedef struct{
	int data[MaxSize];
	int lenth;
}SqList;

void InitList( SqList &L ){
	for( int i=0; i<MaxSize; i++ )
		L.data[i] = 0;
	L.lenth = 0;
}

bool ListInsert( SqList &L, int i, int e ){
	if( i<1 || i>L.lenth+1 )//保证插入位置无误
		return false;
	if( i>=MaxSize )//保证空间未满
		return false;
	for( int j=L.lenth; j>=i; j--){//从最后一位开始依次往后移一位，注意是大于等于i
		L.data[j] = L.data[j-1];
	}
	L.data[i-1] = e;      //数组从0开始计数，i-1是第i位
	L.lenth++;
	return true;
}
int main( int argc, char const*argv[] ){
	SqList L;
	InitList( L );
	for( int i=0; i<MaxSize; i++ ){
		scanf( "%d",&L.data[i] );
		L.lenth++;//输入时，注意让数组长度++
	}
//	printf("%d\n",L.lenth);
	ListInsert( L, 1, 1000);
	printf("%d\n",L.data[0]);//输出时注意数组0位才是第一位
//	printf("%d",L.lenth);
	return 0;
}

顺序表的删除

定义结构体
初始化
删除操作

#include<stdio.h>

#define MaxSize 3

typedef struct{
	int data[MaxSize];
	int lenth;
}SqList;

void InitList( SqList &L ){
	for ( int i=0; i<MaxSize; i++ )
		L.data[i] = 0;
	L.lenth = 0;
}

bool ListDelet( SqList &L, int i, int &e){
	if ( i<1 || i>L.lenth )
		return false;
	if ( i>=MaxSize )
		return false;
	e = L.data[i-1];//删除前先保存其值
	for ( int j=i; j<=L.lenth; j++ ){   能取到L.lenth,即删除最后一位
		L.data[i-1] = L.data[i];
		L.lenth--;
	}
		return true;
}

int main( int argc, char const*argv[] )
{
	SqList L;
	InitList ( L );
	for( int i=0; i<MaxSize; i++ ){
		scanf("%d",&L.data[i]);
		L.lenth++;
	}
	int e = -1;
	ListDelet( L, 2, e);
	printf("%d\n",e);
	printf("%d\n",L.data[1]);
	return 0;
}

按值查找

#include<stdio.h>
#include<stdlib.h>

#define InitSize 5

typedef struct{
	int *data;
	int MaxSize;
	int lenth;
}SeqList;

void InitList(SeqList &L ){
	L.data = (int *)malloc(InitSize*sizeof(int) );
	L.lenth = 0;
	L.MaxSize = InitSize;
}

int LocateElem( SeqList &L, int e ){
	for( int i=0; i<L.lenth; i++)
		if( L.data[i] == e )注意结构体间无法如此比较
			return i+1;     如果是结构体的话，需另写函数比较
	
	return 0;
}

int main( int argc, char const*argv[] )
{
	SeqList L;
	InitList( L );
	for( int i=0; i<L.MaxSize; i++ ){
		scanf("%d",&L.data[i]);
		L.lenth++;
	}
	
	printf("%d\n",LocateElem( L, 8 ) );
	return 0;
}

按位查找

动态分配与静态分配操作一样

#include<stdio.h>

#define InitSize 10

typedef struct{
	int *data;   注意这里的指针类型可以不是int
	int MaxSize;
	int lenth;
}SeqList;

void InitList ( SeqList &L ){
	L.data = (int*)malloc(sizeof(int)*InitSize);  这里一定要转换成与指针类型相同
	L.MaxSize = InitSize;
	L.lenth = 0;
}

int GetElem( SeqList &L, int i ){
	return L.data[i-1];
}