02 线性表的顺序存储

线性表的顺序存储

目录

• 线性表的顺序存储
  • 一、线性表的顺序存储
    • 0.相关操作
    • 1.顺序存储的定义
    • 2.用数组创建顺序存储的线性表
    • 3.初始化顺序存储的线性表
    • 4.判定线性表是否为空
    • 5.销毁线性表
    • 6.返回线性表长度
    • 7.输出线性表
    • 8.获取线性表中某个元素
    • 9.按元素值查找位置
    • 10.在第i个位置插入数据元素
    • 11.删除第 i 个数据元素
    • 12.全部代码

一、线性表的顺序存储

0.相关操作

1. 创建(引用型指针)：CreateList(L,a,n)用数组创建线性表
2. 初始化(引用型指针)：InitList(L)
3. 销毁(1/1+)(引用型指针)：DestroyList(L)
4. 是否为空(1)(bool)：ListEmpty(L)
5. 获取长度(1)(int)：ListLength(L)
6. 输出：输出线性表DispList(L)
7. 获取某个元素(int/bool)：GetElem(L,i)/GetElem(L,i,e)
8. 找到某元素位置(int)：LocateElem(L,e)
9. 插入元素(引用型指针)(bool)：ListInsert(L,i,e)
10. 删除元素(引用型指针)(bool)：ListDelete(L,i,e)

void CreateList(SqList *&L, ElemType a[], int n);//用数组创建线性表
void InitList(SqList *&L);//初始化线性表InitList(L)
void DestroyList(SqList *&L);//销毁线性表DestroyList(L)
bool ListEmpty(SqList *L);//判定是否为空表ListEmpty(L)
int ListLength(SqList *L);//求线性表的长度ListLength(L)
void DispList(SqList *L);//输出线性表DispList(L)
int/bool GetElem(SqList *L,int i);//求某个数据元素值GetElem(L,i)/GetElem(L,i,e)
int LocateElem(SqList *L, ElemType e);//按元素值查找LocateElem(L,e)
bool ListInsert(SqList *&L,int i,ElemType e);//插入数据元素ListInsert(L,i,e)
bool ListDelete(SqList *&L,int i);//删除数据元素ListDelete(L,i,e)

1.顺序存储的定义

#include <stdio.h>
#include <malloc.h>
#define MaxSize 50
typedef int ElemType;
typedef struct
{
    ElemType data[MaxSize];//一个数组与它限定的容量
    int length;//一个变量储存实际长度
} SqList;

2.用数组创建顺序存储的线性表

标题中的数组指的是结构体中的数组data[]
①传入形参，引用型指针，数组，实际长度
②分配内存
③顺序存储获取数组元素
④赋实际长度，注意值

void CreateList(SqList *&L, ElemType a[], int n){//形参使用引用型指针L，分配内存，获取L的地址；需要保存的数组a；当前a的实际长度n；
    L = (SqList * )malloc(sizeof(SqList));
    for( int i = 0; i < n; i++)
        L->data[i]=a[i];
    L->length = n;
}

3.初始化顺序存储的线性表

①传入形参使用引用型指针
②重新分配内存
③赋实际长度

void InitList(SqList *&L){//形参使用引用型指针L，重新分配内存，改变L的地址；
    L=(SqList * )malloc(sizeof(SqList));
    L->length = 0;//实际长度赋0
}

4.判定线性表是否为空

①形参传入结构体指针
②返回表达式：实际长度==0

tips:注意类型

bool ListEmpty(SqList *L){//形参使用结构体指针L，获取结构体地址；
    return(L->length == 0);//返回长度
}

5.销毁线性表

①传入引用型指针,释放该指针所对应的空间
②释放该指针
③避免野指针，给L赋NULL，实际长度赋0

void DestroyList(SqList *&L){//形参使用引用型指针L，获取结构体地址；
    free(L);//free释放指针变量指向的空间
    /*L->length = 0;
    L = NULL;*/
}

6.返回线性表长度

①传入结构体指针
②返回实际长度

tips:注意类型

int ListLength(SqList *L){//形参传入结构体指针L，获取结构体地址；
    return(L->length);//返回长度
}

7.输出线性表

①传入结构体指针
②循环输出

void DispList(SqList *L){//形参传入结构体指针L，获取结构体地址；
    for(int i = 0; i < L->length; i++)//循环输出
        printf("%d ",L->data[i]);
    printf("
");
}

8.获取线性表中某个元素

①传入结构体指针，第几个元素i，引用型变量e；
②判断是否 i 符合规定
③e储存第i个元素

/*返回bool型*/
bool GetElem(SqList *L, int i, ElemType &e){//形参传入结构体指针L，获取结构体地址；第几个元素变量i；储存用元素e；
    if(i < 1 || i > L->length)//判断i是否合法
        return false;
    e = L->data[i-1];
    return true;
}

/*返回int型*/
int GetElem(SqList *L, int i){
    if(i < 1 || i > L->length)
         printf("Error:");   
    return(L->data[i-1]);
} 

9.按元素值查找位置

①传入结构体指针，查找的变量e
②在范围内，进行不相等情况下的循环遍历
③如果最终 i 遍历大于等于实际长度，则无，否则返回 i+1

int LocateElem(SqList *L, ElemType e){//形参传入结构体指针；储存用元素e；
    int i = 0;
    while(i < L->length && L->data[i]!=e )//遍历查找
        i++;
    if(i >= L->length)
        return 0;
    else
        return i+1;
}

10.在第i个位置插入数据元素

① 传入引用型指针，第几个位置变量i，插入的变量e
② 检测是否合法
③ 位序转下标
④ 倒着往后挪
⑤ i 位置赋值，实际长度+1

problem：第三行的范围是否有问题？
tips：共有实际长度+1个位置，[1,length+1] .

bool ListInsert(SqList *&L, int i, ElemType e){//形参传入引用型指针；第几个 位置 变量i；储存用元素e；
    int j;
    if(i < 1 || i > L->length + 1){//判断插入位置是否合法
        printf("Error：插入位置出错");
        return false;
    }
    if(L->Length == MaxSize){//判断空间是否足够
        printf("Error：空间已满！");
        return false;
    }
    i--;//位置序号转成下标
    for( j = L->length; j > i; j--)//倒着 均后挪1位
        L->data[j] = L->data[j-1];
    L->data[i] = e;//i位置赋值
    L->length++;//实际长度加一
    return true;
}

11.删除第 i 个数据元素

①传入引用型指针，第几个元素变量i
②判断传入i是否合法
③位序转下标
④前移一位
⑤实际长度－1

bool ListDelete(SqList *&L, int i){//形参传入引用型指针；第几个元素变量i；
    int j;
    if(i < 1 || i > L->length)//判断位序变量i是否合法
        return false;
    i--;//位序转成下标
    for(j = i; j < L->length; j--)//均前移1位
        L->data[j-1] = L->data[j];
    L->length--;//实际长度-1
    return true;
}

12.全部代码

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define MaxSize 50
typedef int ElemType;
typedef struct
{
    ElemType data[MaxSize];//一个数组与它限定的容量
    int length;//一个变量储存实际长度
} SqList;
void CreateList(SqList *&L, ElemType a[], int n);//用数组创建线性表
void InitList(SqList *&L);//初始化线性表InitList(L)
void DestroyList(SqList *&L);//销毁线性表DestroyList(L)
bool ListEmpty(SqList *L);//判定是否为空表ListEmpty(L)
int ListLength(SqList *L);//求线性表的长度ListLength(L)
void DispList(SqList *L);//输出线性表DispList(L)
bool GetElem(SqList *L, int i, ElemType &e);//求某位置元素值GetElem(L,i,e)
int LocateElem(SqList *L, ElemType e);//按元素值查找LocateElem(L,e)
bool ListInsert(SqList *&L,int i,ElemType e);//插入数据元素ListInsert(L,i,e)
bool ListDelete(SqList *&L,int i);//删除数据元素ListDelete(L,i,e)

void CreateList(SqList *&L, ElemType a[], int n){
    L = (SqList *)malloc(sizeof(SqList));
    for(int i = 0; i < n;  i++)
        L->data[i] = a[i];
    L->length = n;
}

void InitList(SqList *&L){
    L = (SqList *)malloc(sizeof(SqList));
    L->length = 0;
}

void DestroyList(SqList *&L){
    L->length = 0;
    L = NULL;
    free(L);
}

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

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

void DispList(SqList *L){
    for(int i = 0; i < L->length; i++)
        printf("%d ",L->data[i]);
    printf("
");
}

bool GetElem(SqList *L, int i, ElemType &e){
    if(i < 1 || i > L->length)
        return false;
    e = L->data[i-1];
    return true;
}

int LocateElem(SqList *L, ElemType e){
    int i = 0;
    while(i < L->length && L->data[i]!=e )
        i++;
    if(i >= L->length)
        return 0;
    else
        return i+1;
}

bool ListInsert(SqList *&L, int i, ElemType e){
    int j;
    if(i < 1 || i > L->length + 1){
        printf("Error：插入位置出错");
        return false;
    }
    if(L->length == MaxSize){
        printf("Error：空间已满！");
        return false;
    }
    i--;
    for( j = L->length; j > i; j--)
        L->data[j] = L->data[j-1];
    L->data[i] = e;
    L->length++;
    return true;
}

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

int main()
{
    SqList *sq;
    ElemType a[6]= {5,8,7,2,4,9};
    ElemType e;
    int i,x,choice;
    printf("第一步.创建线性表......
");
    CreateList(sq, a, 6);
    while(1){
    	printf("创建成功！请选择菜单执行相关操作
");
	    printf("		1.销毁线性表
");
	    printf("		2.判定线性表是否为空
");
	    printf("		3.求线性表的长度
");
	    printf("		4.输出线性表
");
	    printf("		5.求线性表第i个位置上的元素
");
	    printf("		6.查找线性表中元素e的位置
");
	    printf("		7.在线性表第i个位置插入元素
");
	    printf("		8.删除线性表第i个位置上的元素
");
	    printf("		0.退出
");
	    printf("		请输入你的选择：");
	    scanf("%d",&choice);
		switch(choice)
		{
			case 0: exit(0);
			case 1: DestroyList(sq);
					printf("线性表销毁成功~~程序直接退出！！");
					exit(0);
			case 2: if(ListEmpty(sq))
						printf("线性表为空！");
					else
						printf("线性表不为空！");
					break;
			case 3: printf("该线性表长度为%d
",ListLength(sq));
					break;
			case 4: printf("输出线性表：
");
					DispList(sq);
					break;
			case 5: printf("请输入待查找元素的位置:");scanf("%d",&i);
					GetElem(sq, i, e);
					printf("第%d个位置上的元素为%d",i,e);
					break;
			case 6: printf("请输入要查找的元素：");scanf("%d",&x);
					printf("%d元素在线性表的第%d个位置
",x,LocateElem(sq,x));
					break;
			case 7: printf("请输入要插入位置和值(空格隔开):");scanf("%d%d",&i,&x);
					ListInsert(sq,i,x);
					break;
			case 8: printf("请输入要删除的位置");scanf("%d",&i);
					ListDelete(sq,i);
					break;
		}
		printf("按任意键继续……");
		getchar();getchar();
    }
    return 0;
}