2.2顺序表的增删改查

数据结构

2.1线性表的定义和基本操作

InitList(&L):初始化表。

DestroyList(&L):销毁表。

ListInsert(&L,i,e):插入操作。

ListDelete(&L,i,e):删除操作。

LocalElem(L,e):按值查找操作。

GetElem(L,i):按位查找操作。

Length(L):求表长

PrintList(L):输出操作

Empty(L):判空操作

Tips：

对数据的操作（记忆思路） --创销、增删改查
c语言函数的定义 -- <返回值类型> 函数名（<参数1类型> 参数1，<参数2类型> 参数2）
实际开发中，可根据实际需求定义其他的基本操作
函数名和参数的形式、命名都可以改变
什么时候要传入引用“&” --对参数的修改结果需要 带回来

1778484722427

2.2.1顺序表的定义

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

#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];
    int length;
}SqList;

#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;
}

int main(){
	Sqlist L;
	InitList(L);
	
	return(0);
}

顺序表的实现--动态分布

#define InitSize 10 //顺序表的初始长度
typedef struct{
	ElemType *data;//指示动态分配数组的指针
	int MaxSize;//顺序表的最大容量
	int length;//顺序表的当前长度
}Sqlist;//顺序表的类型定义(动态分配方式)

//c -- malloc、free函数
//	   L.data=(Elemtype *)malloc(sizeof(ElemType)* InitSize)
//malloc函数返回一个指针，需要强制转型为你定义的数据元素类型指针
//malloc函数的参数，指明要分配多大的连续内存空间
//C++ -- new、detelt关键字

#include <stdio.h>
#define InitSize 10
typedef struct{
	ElemType *data;
	int MaxSize;
	int length;
}Sqlist;

void InitList(Sqlist &L){
	
	L.data = (int *)malloc(InitSize*sizeof(int));
	L.length=0;
	L.MaxSize=InitSize;
}
void IncreaseSize(Sqlist &L,int len){
	int *p=L.data;
	L.data=(int *)malloc((L.maxSize+len)*sizeof(int));
	for(int i=1:i<L.length;i++){
		L.data[i]=p[i];	
	}
	L.MaxSize=L.MaxSize+len;
	free(p);
}


int main(){
	Sqlist L;
	InitList(L);
	
	IncreaseSize(L,5);
	return(0);
}

1778487527744

1778487500877

2.2.2_1顺序表的插入删除

#define MaxSize 10

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

void ListInsert(SqList &L,int i,int e){
    for(int j=L.length;j>=i;j--)
        L.data[j] = L.data[j-1];
    L.data[i-1] = e;
    L.length++;
}

int main(){
    SqList(L);
    InitList(L);
    
    ListInsert(L,3,3);
    return 0;
}

豆包后可执行

#include <stdio.h>
#define MaxSize 10

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

bool ListInsert(SqList &L, int i, int e) {
    if (i < 1 || i > L.length + 1)
        return false;
    if (L.length >= MaxSize)
        return false;

    int j;
    for (j = L.length; j >= i; j--)
        L.data[j] = L.data[j - 1];

    L.data[j] = e;
    L.length++;
    return true;
}

// 打印顺序表
void PrintList(SqList L) {
    for (int k = 0; k < L.length; k++)
        printf("%d ", L.data[k]);
    printf("\n");
}

int main() {
    SqList L;
    L.length = 0;

    ListInsert(L, 1, 10);
    ListInsert(L, 2, 20);
    ListInsert(L, 2, 15);

    PrintList(L);  // 输出：10 15 20
    return 0;
}

时间复杂度：O(n)

删除

bool ListDelete(SqList &L,int i,int &e){
    if(i<1||i>L.length)//判断i的范围是否有效
        return false;
    e=L.data[i-1];
    for(int j=i;j<L.length;j++)//将被删除的元素赋值给e
        L.data[j-1]=L.data[j];//将第i个位置后的元素前移
    L.length--;//线性表长度减一
    return true;
}

int main(){
    SqList L;//声明一个顺序表
    InitList(L);//初始化顺序表
    //。。。此处省略一些代码，插入几个元素
    int e = -1;//用变量e把删除的元素带回来
    if(ListDelete(L,3,e))
        printf("已删除第三个数，删除元素值为=%d\n",e);
    else
    	printf("位序不合法，删除失败\n");
    return 0;
    
}

豆包后

#include <stdio.h>
#define MaxSize 10

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

// 初始化顺序表
void InitList(SqList &L) {
    L.length = 0;  // 一开始长度为0
}

// 顺序表删除：删除第 i 个元素，用 e 返回被删元素
bool ListDelete(SqList &L, int i, int &e) {
    // 1. 判断位序是否合法
    if (i < 1 || i > L.length)
        return false;  // 你之前写成 flase，已修复

    // 2. 把被删除的元素存起来
    e = L.data[i - 1];

    // 3. 元素前移
    for (int j = i; j < L.length; j++)
        L.data[j - 1] = L.data[j];

    // 4. 长度减一
    L.length--;
    return true;
}

int main() {
    SqList L;
    InitList(L);

    // 手动插入几个元素方便测试
    L.data[0] = 11;
    L.data[1] = 22;
    L.data[2] = 33;
    L.data[3] = 44;
    L.length = 4;  // 当前有 4 个元素

    int e = -1;

    // 删除第 3 个元素（值为33）
    if (ListDelete(L, 3, e))
        printf("已删除第3个元素，删除元素值为 = %d\n", e);  // 中文分号已修复
    else
        printf("位序不合法，删除失败\n");

    return 0;
}

时间复杂度O(n)

1778574776028

2.2.2_2顺序表的查找

GetElem(L,i):按位查找

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

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

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

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

1778576092530

顺序表的按值查找

LocateElem(L,e):按值查找

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

//在顺序报L中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SeqList L,ElemType e){
    for (int i=0;i<L.length;i++)
        if(L.data[i]==e)
            return i+1;//数组下标为i的元素值等于e，返回其位序i+1
    return 0;//退出循环，说明查找失败
}

结构体无法直接用==进行比较需要依次对比各个分量来判断两个结构体是否相等

1778576890654

时间复杂度O(n)

1778576998324

豆包增删改查完全版

#include <stdio.h>
#define MaxSize 10       // 顺序表最大容量
typedef int ElemType;    // 数据元素类型（存整数）

// 1. 顺序表结构体定义（静态分配）
typedef struct {
    ElemType data[MaxSize];
    int length;         // 当前元素个数
} SqList;

// 2. 初始化顺序表
void InitList(SqList &L) {
    L.length = 0;       // 最开始没有元素
}

// 3. 判空
bool IsEmpty(SqList L) {
    return L.length == 0;
}

// 4. 判满
bool IsFull(SqList L) {
    return L.length >= MaxSize;
}

// ===================== 【增】插入 =====================
// 在第 i 个位置插入元素 e，成功返回true，失败false
bool ListInsert(SqList &L, int i, ElemType e) {
    // 位置非法 / 表满 → 不能插
    if (i < 1 || i > L.length + 1) return false;
    if (IsFull(L)) return false;

    // 从后往前挪，腾出位置
    for (int j = L.length; j >= i; j--) {
        L.data[j] = L.data[j - 1];
    }
    L.data[i - 1] = e;  // 插入新元素
    L.length++;
    return true;
}

// ===================== 【删】删除 =====================
// 删除第 i 个元素，用 e 返回被删元素
bool ListDelete(SqList &L, int i, ElemType &e) {
    if (i < 1 || i > L.length) return false; // 位置非法
    if (IsEmpty(L)) return false;

    e = L.data[i - 1];          // 保存被删元素
    for (int j = i; j < L.length; j++) {
        L.data[j - 1] = L.data[j];  // 前移覆盖
    }
    L.length--;
    return true;
}

// ===================== 【查】按位查找 =====================
// 获取第 i 个元素的值
ElemType GetElem(SqList L, int i) {
    if (i < 1 || i > L.length) return -1; // 非法返回-1
    return L.data[i - 1];
}

// ===================== 【查】按值查找 =====================
// 查找第一个值等于 e 的元素，返回位序，找不到返回0
int LocateElem(SqList L, ElemType e) {
    for (int i = 0; i < L.length; i++) {
        if (L.data[i] == e) {
            return i + 1;  // 下标→位序
        }
    }
    return 0;
}

// ===================== 【改】按位修改 =====================
// 修改第 i 个元素为 e
bool UpdateElem(SqList &L, int i, ElemType e) {
    if (i < 1 || i > L.length) return false;
    L.data[i - 1] = e;
    return true;
}

// ===================== 打印顺序表 =====================
void PrintList(SqList L) {
    printf("当前表：");
    for (int i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
}

// ===================== 主函数测试 =====================
int main() {
    SqList L;
    InitList(L);

    // 插入
    ListInsert(L, 1, 10);
    ListInsert(L, 2, 20);
    ListInsert(L, 2, 15);
    PrintList(L);  // 10 15 20

    // 删除
    int e;
    ListDelete(L, 2, e);
    printf("删除元素：%d\n", e);  // 15
    PrintList(L);  // 10 20

    // 按位查找
    printf("第1个元素：%d\n", GetElem(L, 1));  // 10

    // 按值查找
    printf("值为20的位序：%d\n", LocateElem(L, 20));  // 2

    // 修改
    UpdateElem(L, 2, 99);
    PrintList(L);  // 10 99

    return 0;
}

posted @ 2026-05-12 17:18 轻狂书生han 阅读(7) 评论(0) 收藏举报

刷新页面返回顶部

轻狂书生han