【数据结构笔记】线性表（代码）

顺序表

基本操作

InitList(&L)
Length(L);
LocateElem(L, e);
GetElem(L, i);
ListInsert(&L, i, e);
ListDelete(&L, i, &e);
PrintList(L);
Empty(L);
DestroyList(&L);

InitList(&L)

静态分配

#include <iostream>
using namespace std;

// 定义最大长度
#define MaxSize 10

// typedef 为结构体类型定义一个别名。
typedef struct {
	int data[MaxSize];	
	int length; 		// 顺序表的当前长度
} SqList;

// 初始化
void InitList(SqList &L) {
	L.length = 0;
}

动态分配

c

#include <iostream>
using namespace std;

// 默认最大长度
#define InitSize 10

// typedef 为结构体类型定义一个别名。
typedef struct {
	int *data;			// 指示动态分配数组的指针
	int MaxSize;		// 顺序表的最大容量
	int length; 		// 顺序表的当前长度
} SeqList;

// c malloc
void InitList(SeqList &L) {
	L.data = (int *) malloc(InitSize * sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
}

// c
// len 为增加的长度，不是变成len
void IncreaseSize(SeqList &L, int len) {
	int *p = L.data;
	L.data = (int *) malloc((L.MaxSize + len) * sizeof(int));
	for (int i = 0; i < L.length; ++i) {
		L.data[i] = p[i];
	}
	L.MaxSize += len;
	free(p);
}

// c free
void DestroyList(SeqList &L) {
    free(L.data);
    L.length = 0;
    L.MaxSize = 0;
}

c++

// c++ new
void InitList(SeqList &L) {
    L.data = new int[InitSize];
    L.length = 0;
    L.MaxSize = InitSize;
}

// c++ delete
void DestroyList(SeqList &L) {
    delete[] L.data;
    L.length = 0;
    L.MaxSize = 0;
}

// c++
void IncreaseSize(SeqList &L, int len) {
    int *p = L.data;
    L.data = new int[L.MaxSize + len];
    for (int i = 0; i < L.length; ++i) {
        L.data[i] = p[i];
    }
    L.MaxSize += len;
    delete[] p;
}

基本操作实现

#include <iostream>
using namespace std;

// 定义最大长度
#define MaxSize 10

// typedef 为结构体类型定义一个别名。
typedef struct {
	int data[MaxSize];	
	int length; 		// 顺序表的当前长度
} SqList;

// 初始化
void InitList(SqList &L) {
	L.length = 0;
}

/** 
 * @brief 顺序表插入
 * @param SqList & L	顺序表
 * @param int i			元素位序
 * @param int e			插入元素值
 * @return 返回说明
 *     -<em>false</em> 插入成功
 *     -<em>true</em> 插入失败
 */
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;
	++L.length;
	return true;
}

/** 
 * @brief 顺序表删除
 * @param SqList & L	顺序表
 * @param int i			元素位序
 * @param int e			删除元素值
 * @return 返回说明
 *     -<em>false</em> 删除失败
 *     -<em>true</em> 删除成功
 */
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) {
		L.data[j-1] = L.data[j];
	}
	--L.length;
	return true;
}

/** 
 * @brief 顺序表 按位查找
 * @param SqList & L	顺序表
 * @param int i			元素位序
 * @param int e			查找第i位次元素值
 * @return 返回说明
 *     -<em>false</em> 查找失败
 *     -<em>true</em> 查找成功
 */
bool GetElem(const SqList &L, int i, int &e) {
    if (i < 1 || i > L.length) {
        return false;  // 超出范围，返回失败
    }
    e = L.data[i - 1];  // 下标从 0 开始，需要减一
    return true;
}

/** 
 * @brief 顺序表 按值查找
 * @param SqList & L	顺序表
 * @param int i			元素位序
 * @param int e			查找第i位次元素值
 * @return 返回说明
 *     int 值为e的元素位次
 *		0 查询失败
 */
int LocateElem(const SqList &L, int e) {
	for (int i = 0; i < L.length; ++i) {
		if (L.data[i] == e) {	// 结构体 需要判断每一项是否相等
			return i + 1;
		}
	}
	return 0;					// 退出循环，说明查找失败，返回0	
}

/** 
 * @brief 顺序表输出
 * @param const SqList &L	顺序表
 * @return void
 */
void PrintList(const SqList &L) {
    for (int i = 0; i < L.length; ++i) {
        cout << L.data[i] << " ";
    }
    cout << endl;
}

/** 
 * @brief 顺序表判空操作
 * @param const SqList &L	顺序表
 * @return 返回说明
 *     -<em>false</em> 不为空
 *     -<em>true</em> 为空
 */
bool Empty(const SqList &L) {
    return L.length == 0;
}

/** 
 * @brief 顺序表求表长
 * @param const SqList &L	顺序表
 * @return 返回说明
 *     int 表长 
 */
int Length(const SqList &L) {
    return L.length;
}

int main() {
	SqList L;
    InitList(L);  // 初始化一个空顺序表

    // 测试 ListInsert 函数
    ListInsert(L, 1, 1);
    ListInsert(L, 2, 2);
    ListInsert(L, 3, 3);
    cout << "After inserting elements: ";
    PrintList(L);  // 期望输出：1 2 3

    // 测试 ListDelete 函数
    int deletedElement = 0;
    ListDelete(L, 2, deletedElement);  // 删除第2个元素
    cout << "Deleted element: " << deletedElement << endl;  // 期望输出：Deleted element: 2
    cout << "After deleting elements: ";
    PrintList(L);  // 期望输出：1 3

    // 测试 GetElem 函数
    int element = 0;
    bool success = GetElem(L, 2, element);  // 获取第2个元素
    if (success) {
        cout << "Element at position 2: " << element << endl;  // 期望输出：Element at position 2: 3
    } else {
        cout << "Failed to get element." << endl;
    }

    // 测试 LocateElem 函数
    int position = LocateElem(L, 1);  // 查找元素1的位置
    if (position != 0) {
        cout << "Position of element 1: " << position << endl;  // 期望输出：Position of element 1: 1
    } else {
        cout << "Element 1 not found." << endl;
    }

    // 测试 Empty 函数
    bool isEmpty = Empty(L);  // 判断顺序表是否为空
    cout << "Is the list empty? " << (isEmpty ? "Yes" : "No") << endl;  // 期望输出：Is the list empty? No

    // 测试 Length 函数
    int length = Length(L);  // 获取顺序表的长度
    cout << "Length of the list: " << length << endl;  // 期望输出：Length of the list: 2

    return 0;
}