线性表的实现:静态和动态

一下为静态实现代码,这事实上只是数组的某种"处理"

#define MaxSize 50
#include <iostream>;
using namespace std;
typedef int ElementType;
typedef struct {
    ElementType data[MaxSize];
    int length;
} SqList;
bool InitList(SqList& L) {
    for (int i = 0; i < MaxSize; i++)
        L.data[i] = 0;//保险起见...
    L.length = 0;
    return true;
}
//在指定位置插入元素
bool ListInsert(SqList& L, int i, ElementType e) {
    if (i > L.length + 1 || i < 1)
        return false;
    if (L.length >= MaxSize)
        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;
}
//删除指定位置元素
bool ListDelete(SqList &L, int i) {
    if (i > L.length || i < 1)
        return false;
    for (int j = i; j < L.length; j++)
        L.data[j - 1] = L.data[j];
    L.length--;
    return true;
}
//按照位置查找
int LocateElem(SqList L, ElementType e)
{
    int i;
    for (i = 0; i < L.length; i++)
        if (e == L.data[i])
            return i + 1;
    return 0;
}
//返回指定位置值
ElementType GetElem(SqList L,int i) {
    return L.data[i - 1];
}
bool ListShow0(SqList L) {
    for (int i = 0; i < L.length; i++)
        cout << L.data[i];
    return true;
}
bool ShunXuBiaoJingTai() {
    SqList L;
    InitList(L);
    return true;
}

这是动态分配的代码,借此机会,也可以学习一下C语言中malloc函数的使用以及指针的位移操作.

#define InitSize 10//初始长度
#define ElementType double
//#include <stdio.h>
#include<iostream>
using namespace std;
//#include<stdlib.h>;
#include<malloc.h>
typedef struct SeqList{
	ElementType *data;//指向动态分配的指针
	int MaxSize;//最大数据
	int length;//当前长度
}SeqList;


//初始化
bool InitList(SeqList& L) {
	L.data = (ElementType*)malloc(sizeof(ElementType) * InitSize);
	L.length = InitSize;
	L.MaxSize = InitSize;
	return true;
}
//增加表长
void IncreaseList(SeqList& L, int len) {
	ElementType* p = L.data;//创建指针p,指向原来数据的位置,这也说明p指向的并不是"L",而是L所在的位置
	L.data = (ElementType*)malloc(sizeof(ElementType) * (L.MaxSize + len));//申请全新的内存空间
	for (int i = 0; i < L.length; i++)
		L.data[i] = p[i];//即使p指向了先前结构体,但是p并不是结构体,所以不能用"p.data[]"来访问
	L.MaxSize += len;
	free(p);//释放指针
}
//插入元素
void AddList(SeqList& L, int i, ElementType e) {
	L.data[i - 1] = e;
}
//展示
void ShowList(SeqList L) {
	for (int i = 0; i < L.MaxSize; i++) {
		cout<<L.data[i]<<" ";
	}
}
bool ShunXuBiaoDongTai() {
	SeqList L;
	InitList(L);
	for (int n = 10; n > 0; n--) {
		AddList(L, n, n);
	}
	IncreaseList(L, 5);
	for (int n = 15; n > 0; n--) {
		AddList(L, n, n);
	}
	ShowList(L);
	return true;
}

int main() {
	ShunXuBiaoDongTai();
	return 0;
}

malloc函数,用于申请一片连续的内存空间
L.data=(ElementType*)malloc(sizeof(ElementType)*InitSize;
前一个括号用于强制类型转换,将malloc返回的指针转换为指定类型指针.

另外,malloc函数生成的数据可以用free来释放.值得注意的是,free函数并不会在物理意义上改变数据.但是会将内存空间标志为"可使用",之后计算机存储可以覆盖这一片内存

另外介绍一下指针的"位移"
在代码中,p和L都不是指针(是结构体),却可以通过p[i],L.data[i]的方式来读取数据,这实际上是系统将malloc函数生成的空间按照sizeof(ElementType)来划分,这也决定了当i改变时每次的"偏移量".举个栗子,p+i 将返回 p 所指向的内存空间中距离 p 指向地址 i 个 ElementType 类型大小的位置的地址，而 *(p+i) 则表示该位置上的元素值。

同理,指针的指针也可以偏移,以下是一段简单的实例.

需要注意的是，在使用指针和数组进行访问时，如果出现指针或数组越界的情况，将会导致程序崩溃或者产生不可预料的错误。因此，在进行指针和数组操作时，必须小心谨慎，确保操作的合法性和安全性。

#include <stdio.h>

int main() {
    int a = 123;
    int b = 456;
    int c = 789;

    int* arr[] = { &a, &b, &c };
    int** pp = arr; // 指向指针数组的指针

    printf("%d %d %d\n", *(pp[0]), *(pp[1]), *(pp[2])); // 输出 123 456 789
    printf("%d %d %d\n", **(pp), **(pp+1), **(pp+2)); // 同样输出 123 456 789
    printf("%d %d %d\n", *pp[0], *pp[1], *pp[2]); // 同样输出 123 456 789

    return 0;
}

最后介绍一下realloc函数,这个函数用于重新分配malloc函数的空间.

经验来自ChatGPT:

在 C 语言中，realloc() 函数是用于重新分配内存的函数。它可以改变一个已经动态分配了内存的指针所指向的空间大小。如果要分配的新空间大小比原来更大，那么函数会自动为新分配的部分填充零。realloc() 函数的声明如下：

void *realloc(void *ptr, size_t size);

其中，ptr 是指向动态分配的内存块的指针，size 是新分配的空间大小。

当 ptr 不为 NULL 时，realloc() 函数会尝试重新分配 ptr 所指向的内存块大小为 size 字节。此时，有以下几种情况：

1. 如果 size 小于或等于原来分配的空间大小，则 realloc() 什么也不做，返回原始的指针 ptr。

2. 如果 size 大于原来分配的空间大小，而且原来的内存块后面有足够的连续未使用的空间，则 realloc() 会扩大这块内存，并返回该内存块的首地址。此时，原来的内存内容被保留，新分配的内存部分将填充零。

3. 如果 size 大于原来分配的空间大小，而且原来的内存块后面没有足够的连续未使用的空间，则 realloc() 将会在另外一块内存中重新分配一块大小为 size 字节的内存，并将原先内存块中的数据拷贝到新的内存块中，同时原先的内存块被释放掉。此时，返回的是新分配的内存块的首地址。

4. 如果 size 等于 0，则该函数返回 NULL，并释放先前分配的内存块。

需要注意的是，realloc() 函数可能会返回一个新的指针地址，因此，我们应该重新将该指针赋值给原来的变量，避免出现地址泄漏或野指针等问题。

使用realloc函数如下图.可以替换原有代码

void IncreaseList2(SeqList& L, int n) {
	L.data = (ElementType*)realloc(L.data, sizeof(ElementType) * (L.MaxSize + n));
	L.MaxSize += n;
}