顺序表定义及增删改查操作

一、 静态分配的顺序表

1.1 数据元素的定义

# define MaxSize 50		// 定义顺序表的最大容量（最大长度）
typedef struct{
	ElemType data[MaxSize];		// 顺序表中的元素
	int length;					// 顺序表的当前长度
}SqList;						// 顺序表的类型定义

1.2 初始化顺序表操作

#include<stdio.h>
# define MaxSize 50		// 定义顺序表的最大容量（最大长度）
typedef struct{
	int data[MaxSize];		// 顺序表中的元素
	int length;				// 顺序表的当前长度
}SqList;					// 顺序表的类型定义

/* 初始化顺序表 */
void InitList(SqList &L){
    // 将所有的数据元素设置为默认值0
	for(int i=0;i<MaxSize;i++){
        L.data[i]=0;
    }
    L.length=0;		// 设置顺序表初始长度为0 
}

int main()
{
	SqList L;		// 定义顺序表L
    InitList(L);	// 初始化顺序表L
    return 0;
}

1.3 插入元素操作

#include<stdio.h>
# define MaxSize 50		// 定义顺序表的最大容量（最大长度）
typedef struct{
	int data[MaxSize];		// 顺序表中的元素
	int length;				// 顺序表的当前长度
}SqList;					// 顺序表的类型定义

/* 插入元素操作 */
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;	// 将e插入的第i个位置
    L.length++;		// 更新当前顺序表的长度，加一
    return true;
}

1.4 按位删除元素操作

#include<stdio.h>
# define MaxSize 50		// 定义顺序表的最大容量（最大长度）
typedef struct{
	int data[MaxSize];		// 顺序表中的元素
	int length;				// 顺序表的当前长度
}SqList;					// 顺序表的类型定义

/* 按位删除元素操作 */
bool ListDelete(SqList &L,int i,int &e){
    if(i<1 || i>L.length){	// 检测位置i的合法性
        return false;	
    }
	e=L.data[i-1];	// 将被删除元素赋值给变量e

    // 将第i个位置后的元素前移
    for(int j=i;j<L.length;j++){
        L.data[j-1]=L.data[j];
    }
    L.length--;		// 更新当前顺序表的长度，减一
    return true;
}

1.5 删除指定的所有元素

/* 删除指定的所有元素 */
void ListDeleteAll(SqList& L,int value) {
	int k = 0;	// 记录顺序表中非value值元素的个数

	for (int i = 0; i < L.length; i++) {
		if (L.data[i] != value) {
			L.data[k] = L.data[i];
			k++;
		}
	}
	L.length = k;
}

1.6 按位查找元素操作

#include<stdio.h>
# define MaxSize 50		// 定义顺序表的最大容量（最大长度）
typedef struct{
	int data[MaxSize];		// 顺序表中的元素
	int length;				// 顺序表的当前长度
}SqList;					// 顺序表的类型定义

/* 按照位序查找对应的元素 */
int GetElem(SqList L,int index){
	if(index<1 || index>L.length){		// 检测位序index的合法性
        printf("位置不合法!\n");
        return -1;
    }
    return L.data[index-1];
}

1.7 按值查找元素位置

#include<stdio.h>
# define MaxSize 50		// 定义顺序表的最大容量（最大长度）
typedef struct{
	int data[MaxSize];		// 顺序表中的元素
	int length;				// 顺序表的当前长度
}SqList;					// 顺序表的类型定义

/* 按值查找元素位置 */
int LocateElem(SqList L,int e){
    for(int i=0;i<L.length;i++){
        if(L.data[i]==e){	// 找到元素e,返回其位序
            return i+1;
        }
    }
    return 0;	// 未找到该元素e,返回0
}

二、动态分配的顺序表

2.1 数据元素的定义

# define InitSize 100		// 定义顺序表的初始长度
typedef struct{
	ElemType *data;		// 指向动态分配顺序表（数组）的指针
	int MaxSize;		// 顺序表的最大容量
	int length;			// 顺序表的当前长度
}SqList;				// 顺序表的类型定义

2.2 初始化操作

#include<stdio.h>
#include<stdlib.h>
# define InitSize 100		// 定义顺序表的初始长度
typedef struct{
	int *data;			// 指向动态分配顺序表（数组）的指针
	int MaxSize;		// 顺序表的最大容量
	int length;			// 顺序表的当前长度
}SqList;				// 顺序表的类型定义

/* 初始顺序表 */
void InitList(SqList &L){
    // 用malloc()函数申请一片连续的内存空间
    L.data=(int *)malloc(InitSize*sizeof(int));
    L.length=0;	
    L.MaxSize=InitSize;
}

int main()
{
	SqList L;		// 定义顺序表L
    InitList(L);	// 初始化顺序表L
    return 0;
}

2.3 扩展顺序表空间大小

#include<stdio.h>
#include<stdlib.h>
# define InitSize 100		// 定义顺序表的初始长度
typedef struct{
	int *data;			// 指向动态分配顺序表（数组）的指针
	int MaxSize;		// 顺序表的最大容量
	int length;			// 顺序表的当前长度
}SqList;				// 顺序表的类型定义

/* 扩展顺序表空间大小 */
void IncreaseSize(SqList &L,int len){
    int *p=L.data;	// p指针指向旧的内存空间
    L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));
    // 将旧的内存空间的数据复制到新申请到的内存空间中
    for(int i=0;i<L.MaxSize;i++){
        L.data[i]=p[i];
    }
    L.MaxSize=L.MaxSize+len;	// 更新顺序表的最大容量
    free(p);	// 释放旧的内存空间 
}