[数据结构]1.线性表的顺序存储结构——顺序表

[数据结构]1.线性表的顺序存储结构——顺序表

1.定义数组a[]大小MaxSize，创建数据结构SqList

#include <iostream>
#include <stdio.h> 
/* 定义数组大小最大长度 MaxSize */ 
#define MaxSize 50

typedef int ElemType;

/* 创建数据结构 */ 
typedef struct
{
	ElemType data[MaxSize];    //存放线性表中的元素 
	int length;				   //存放线性表的长度 
} SqList;					   //顺序表的类型 

int main(int argc, char** argv) {
	return 0;
}

2.完成顺序表的基本操作

1.建立顺序表

void CreateList(SqList *&L,ElemType a[],int n)   //由a[]中的n个元素建立顺序表 
{
	int i=0;
	int k=0;                                     //k表示L中的元素个数，初始值为0 
	L=(SqList *)malloc(sizeof(SqList));          //分配存放线性表的空间 
	while(i<n)									 //i扫描数组a[]中的元素 
	{
		L->data[k]=a[i];                         //将元素a[i]存放到L中 
		k++;
		i++;
	}
	L->length=k;                                 //设置L的长度k 
} 

部分语句解释

SqList *&L

• 当调用上述算法创建好L所指的顺序表后，需要回传给对应的实参，也就是说，L是输出型参数，所以在形参L的前面需要加上引用符“&”。

L=(SqList *)malloc(sizeof(SqList));

• 从总体的来说，这句是给指针分配空间。 赋值号左边L是一个SqList *指针，指向名为SqList的结构体；赋值号右边，malloc(sizeof(SqList))是分配一块大小为sizeof(SqList)的内存，并返回首地址并赋值给左边的L指针，
  (SqList *)表示把这个地址强制转化为SqlList *的指针。

2.初始化表的基本运算算法

2.1初始化线性表

• 功能：构造一个空的线性表L。
• 实际上只需要分配线性表的存储空间并将length域设置为0即可。

void InitList(SqList *&L)
{
	L=(SqList * )malloc(sizeof(SqList));  //分配存放线性表的空间
	L->length=0;                          //置空线性表的长度0 
} 

2.2销毁线性表

• 功能：释放线性表L占用的空间内存
• 使用malloc函数分配的存储空间，不需要的时候必须销毁，因为系统会自动释放顺序表的指针变量L，但是不会自动释放L所指向的存储空间，可能会造成内存泄漏。

void DestroyList(SqList * &L)
{
	free(L);           //释放L所指的顺序表空间	
} 

2.3判断线性表是否为空表

• 功能：判断线性表是否为空，返回值为true或者false。

bool ListEmpty(SqList *L)
{
	return(L->length==0);
} 

2.4求线性表的长度

• 功能：求顺序表的长度。

int ListLength(SqList *L)
{
	return(L->length);
}

2.5输出线性表

• 功能：输出线性表。

void DispList(SqList *L)
{
	for(int i=0;i<L->length;i++)   //扫描输出各元素的值
	{
		printf("%d",L->data[i]);
	}
	printf("\n");
} 

2.6求线性表中某个元素的值

bool GetEllem(SqList *L,int i,ElemType &e)
{
	if(i<1||i>L->length)
	{
		return false;     //参数i错误是返回false 
	}
	e=L->data[i-1];       //取元素值 
	return true; 		  //成功找到元素时返回true 
} 

2.7按元素值查找

int LocateElem(SqList *L, ElemType e)
{
	int i=0;
	while(i<L->length && L->data[i]!=e)
	{
		i++;           //查找元素e 
	}
	if(i>=L->length)
	{
		return 0;      //未找到时返回0 
	}
	else
	{
		return i+1;    //找到时返回其逻辑序号 
	}
}

2.8插入数据元素

bool ListInsert(SqList * &L, int i, ElemType e)
{
	int j;
	if(i<1 || i>L->length+1)
	{
		return false;
	}
	i--;                      //将顺序表逻辑序号转化为物理序号 
	for(j=L->length;j>i;j--)  //将data[i]及后面的元素顺移 
	{
		L->data[j]=L->data[j-1];
	}
	L->data[i]=e;             //插入e 
	L->length++;              //顺序表长度+1 
	return true;
} 

2.9删除数据元素

bool ListDelete(SqList *&L, int i, ElemType &e)
{
	int j;
	if(i<0 || i>L->length)
		return false;
	i--;                    //将顺序表逻辑序号转化为物理序号 
	e=L->data[i];           
	for(j=i;j<L->length-1;j++) //将data[i]之后的元素都前移一位 
		L->data[j]=L->data[j+1];
	L->length--;            //顺序表长度-1
	return true;
} 

3.综合使用

#include <iostream>
#include <stdio.h> 
/* 定义数组大小最大长度 MaxSize */ 
#define MaxSize 50

typedef int ElemType;

/* 创建数据结构 */ 
typedef struct
{
	ElemType data[MaxSize];    //存放线性表中的元素 
	int length;				   //存放线性表的长度 
} SqList;					   //顺序表的类型 
 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

void CreateList(SqList *&L,ElemType a[],int n);       //建立顺序表 
void DestroyList(SqList * &L);                        //销毁线性表 
bool ListEmpty(SqList *L);                            //判断线性表是否为空表 
int ListLength(SqList *L);                            //求线性表的长度 
void DispList(SqList *L);                             //输出线性表 
bool GetEllem(SqList *L,int i,ElemType &e);           //求线性表中某个元素的值 
int LocateElem(SqList *L, ElemType e);                //按元素值查找
bool ListInsert(SqList * &L, int i, ElemType e);      //插入数据元素 
bool ListDelete(SqList *&L, int i, ElemType &e);      //删除数据元素 
int main(int argc, char** argv) {
	return 0;
}

/* 1.建立顺序表 */
void CreateList(SqList *&L,ElemType a[],int n)   //由啊a[]中的n个元素建立顺序表 
/* 当调用上述算法创建好L所指的顺序表后，需要回传给对应的实参，也就是说，L是输出型参数，所以在形参L的前面需要加上引用符“&”。 */
{
	int i=0;
	int k=0;                                     //k表示L中的元素个数，初始值为0 
	L=(SqList *)malloc(sizeof(SqList));          //分配存放线性表的空间 
	/* 从总体的来说，这句是给指针分配空间。 
　　   赋值号左边L是一个SqList *指针，指向名为SqList的结构体；
	   赋值号右边，malloc(sizeof(SqList))是分配一块大小为sizeof(SqList)的内存，
	   并返回首地址并赋值给左边的L指针，
	   (SqList *)表示把这个地址强制转化为SqlList *的指针。*/
	while(i<n)									 //i扫描数组a[]中的元素 
	{
		L->data[k]=a[i];                         //将元素a[i]存放到L中 
		k++;
		i++;
	}
	L->length=k;                                 //设置L的长度k 
} 

/* 2.初始化表的基本运算算法 */

/* 2.1初始化线性表 */
void InitList(SqList *&L)
{
	L=(SqList * )malloc(sizeof(SqList));  //分配存放线性表的空间
	L->length=0;                          //置空线性表的长度0 
} 

/* 2.2销毁线性表 */
void DestroyList(SqList * &L)
{
	free(L);           //释放L所指的顺序表空间	
} 

/* 2.3判断线性表是否为空表 */
bool ListEmpty(SqList *L)
{
	return(L->length==0);
} 

/* 2.4求线性表的长度 */
int ListLength(SqList *L)
{
	return(L->length);
}

/* 2.5输出线性表 */
void DispList(SqList *L)
{
	for(int i=0;i<L->length;i++)   //扫描输出各元素的值
	{
		printf("%d",L->data[i]);
	}
	printf("\n");
} 

/* 2.6求线性表中某个元素的值 */
bool GetEllem(SqList *L,int i,ElemType &e)
{
	if(i<1||i>L->length)
	{
		return false;     //参数i错误是返回false 
	}
	e=L->data[i-1];       //取元素值 
	return true; 		  //成功找到元素时返回true 
} 

/* 2.7按元素值查找 */
int LocateElem(SqList *L, ElemType e)
{
	int i=0;
	while(i<L->length && L->data[i]!=e)
	{
		i++;           //查找元素e 
	}
	if(i>=L->length)
	{
		return 0;      //未找到时返回0 
	}
	else
	{
		return i+1;    //找到时返回其逻辑序号 
	}
} 

/* 2.8插入数据元素 */
bool ListInsert(SqList * &L, int i, ElemType e)
{
	int j;
	if(i<1 || i>L->length+1)
	{
		return false;
	}
	i--;                      //将顺序表逻辑序号转化为物理序号 
	for(j=L->length;j>i;j--)  //将data[i]及后面的元素顺移 
	{
		L->data[j]=L->data[j-1];
	}
	L->data[i]=e;             //插入e 
	L->length++;              //顺序表长度+1 
	return true;
} 

/* 2.9删除数据元素 */
bool ListDelete(SqList *&L, int i, ElemType &e)
{
	int j;
	if(i<0 || i>L->length)
		return false;
	i--;                    //将顺序表逻辑序号转化为物理序号 
	e=L->data[i];           
	for(j=i;j<L->length-1;j++) //将data[i]之后的元素都前移一位 
		L->data[j]=L->data[j+1];
	L->length--;            //顺序表长度-1
	return true;
}