【4.线性表的基本操作】

1. 静态结构

#include <iostream>
const int MAXSIZE = 100;  // 定义最大容量
struct SqList {
    int data[MAXSIZE];  // 存储数据的数组
    int length;         // 当前线性表的长度
};

1.初始化线性表

//初始化线性表
void InitList(SqList &L) {
    L.length = 0;  // 初始化长度为0
}

2.求表长

int Length(const SqList &L) {
    return L.length;
}

3.按值查找操作

int LocateElem(const SqList &L, int e) {
    for (int i = 0; i < L.length; ++i) {
        if (L.data[i] == e) {
            return i + 1;  // 返回元素的位置，从1开始计数
        }
    }
    return 0;  // 如果没有找到，返回0
}

4.按位查找操作

int GetElem(const SqList &L, int i) {
    if (i < 1 || i > L.length) {
        std::cerr << "Index out of range!" << std::endl;
        exit(1);
    }
    return L.data[i - 1];  // 返回第i个位置的元素值
}

5.插入操作

bool ListInsert(SqList &L, int i, int e) {
    if (i < 1 || i > L.length + 1) {
        std::cerr << "Invalid position!" << std::endl;
        return false;
    }
    if (L.length >= MAXSIZE) {
        std::cerr << "List is full!" << std::endl;
        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;
}

6.删除操作

bool ListDelete(SqList &L, int i, int &e) {
    if (i < 1 || i > L.length) {
        std::cerr << "Invalid position!" << std::endl;
        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;
}

7.输出操作

void PrintList(const SqList &L) {
    for (int i = 0; i < L.length; ++i) {
        std::cout << L.data[i] << " ";
    }
    std::cout << std::endl;
}

8.判空操作

bool Empty(const SqList &L) {
    return L.length == 0;
}

9.销毁操作

void DestroyList(SqList &L) {
    L.length = 0;  // 将长度设置为0，表示销毁
}

2. 动态结构

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

#define ERROR 0
#define OK 1
//顺序表
typedef struct seqList {
	int n;
	int maxLength;
	int* element;
}SeqList;
typedef int Status;
//初始化
Status Init(SeqList* L, int mSize) {
	L->maxLength = mSize;
	L->n = 0;
	L->element = (int*)malloc(sizeof(int) * mSize);
	if (!L->element)
		return ERROR;
	return OK;
}
//插入
Status Insert(SeqList* L, int i, int x) {
	int j;
	if (i<-1 || i>L->n - 1)
		return ERROR;
	if (L->n == L->maxLength)
		return ERROR;
	for (j = L->n - 1; j > i; j--) {
		L->element[j + 1] = L->element[j];
	}
	L->element[i + 1] = x;
	L->n++;
	return OK;
}
//删除
Status Delete(SeqList* L, int i) {
	int j;
	if (i<0 || i>L->n - 1)
		return ERROR;
	if (!L->n)
		return ERROR;
	for (j = i + 1; j < L->n; j++)
		L->element[j - 1] = L->element[j];
	L->n--;
	return OK;

}
//修改
Status Change(SeqList* L, int i, int x) {
	if (i<0 || i>L->n - 1)
		return ERROR;
	if (!L->n)
		return ERROR;
	L->element[i-1] = x;
	return OK;
}
//查找
Status Find(SeqList L, int i, int *x) {
	if (i < 0 || i>L.n - 1)
		return ERROR;
	*x = L.element[i];
	return OK;
}
//输出
Status Ouput(SeqList* L) {
	int i;
	if (!L->n)
	return ERROR;
	for ( i = 0; i <=L->n-1; i++)
	{
		printf("%d ", L->element[i]);
	}
	return OK;
}
//销毁
Status Destory(SeqList* L) {
	L->n = 0;
	L->maxLength = 0;
	free(L->element);
	return OK;
}
int main() {
	SeqList L;
	int n = 10;
	int i;
	Init(&L, n);
	
	for (i = 0; i <n; i++)
	{
		Insert(&L, i - 1, i);
	}
	
	Ouput(&L);
	
	int v = 0;
	Find(L, 8, &v);
	printf("\n");
	printf("%d", v);
	printf("\n");
	Delete(&L, 1);
	Ouput(&L);
	printf("\n");
	Change(&L, 6, 66);
	Ouput(&L);
	printf("\n");
	return 0;
}