数据结构之顺序表

最新推荐文章于 2024-12-11 08:15:00 发布

原创最新推荐文章于 2024-12-11 08:15:00 发布 · 150 阅读

1 ·

CC 4.0 BY-SA版权

数据结构专栏收录该内容

7 篇文章

订阅专栏

本文深入解析动态顺序表的实现原理，包括初始化、增删改查等核心操作，并提供详细的代码示例，帮助读者理解线性数据结构在内存管理中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.什么是线性结构？
线性结构是一个有序数据元素的集合。
2. 线性结构中都包含什么内容？
常见的线性结构有：线性表、栈、队列、双队列、数组、串。
3. 什么是顺序表？顺序表的分类？
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删改查。
顺序表一般可1.分为静态顺序表：使用定长数组存储。2.动态顺序表：使用动态开辟的数组存储。
4.动态顺序表基本功能实现

// 动态的顺序表 
typedef int DataType; 
typedef struct SeqList 
{ 
	DataType* _array; 
	int _capacity; // 顺序表的总大小 
int _size; // 顺序表中有效元素的个数 
}SeqList, *PSeq; 

// 顺序表的初始化 
void SeqListInit(PSeq ps, int capacity); 
void SeqListInit(PSeq ps, int capacity) {
	ps->_array = (DataTppe*)malloc(sizeof(DataTppe)*capacity);
	if (ps->_array == NULL) {
		assert(0);
		return;
	}
	ps->_capacity = capacity;
	ps->_size = 0;
}

// 在顺序表的尾部插入值为data的元素 
void SeqListPushBack(PSeq ps, DataType data); 
void SeqListPushBack(PSeq ps, DataTppe data) {
	assert(ps);
	CheckCapacity(ps);
	ps->_array[ps->_size] = data;
	ps->_size++;

}
// 删除顺序表最后一个元素 
void SeqListPopBack(PSeq ps); 
void SeqListPopBack(PSeq ps) {
	assert(ps);
	if (SeqListEmpty(ps)) {
		return;
	}
	ps->_size--;
}
// 在顺序表的头部插入值为data的元素 
void SeqListPushFront(PSeq ps, DataType data); 
void SeqListPushFront(PSeq ps, DataTppe data) {
	assert(ps);
	CheckCapacity(ps);
	for (int i = ps->_size-1; i >=0; i--) {
		ps->_array[i + 1] = ps->_array[i];

	}
	ps->_array[0] = data;
	ps->_size++;

}
// 删除顺序表头部的元素 
void SeqListPopFront(PSeq ps); 
void SeqListPopFront(PSeq ps) {
	assert(ps);
	if (SeqListEmpty(ps)) {
		return;
	}
	for (int i = 1; i < ps->_size; i++) {
		ps->_array[i - 1] = ps->_array[i];
	}
	ps->_size--;
}
// 在顺序表pos位置插入值为data的元素 
void SeqListInsert(PSeq ps, int pos, DataType data); 
void SeqListInsert(PSeq ps, int pos, DataTppe data) {
	assert(ps);
	if (pos<0 || pos>ps->_size) {
		return;
	}
	CheckCapacity(ps);
	for (int i = ps->_size; i > pos; i--) {
		ps->_array[i] = ps->_array[i - 1];
	}
	ps->_array[pos] = data;
	ps->_size++;
}
// 删除顺序表中pos位置上的元素 
void SeqListErase(PSeq ps, int pos); 
void SeqListErase(PSeq ps, int pos) {
	assert(ps);
	if (pos<0 || pos>ps->_size) {
		return;
	}
	for (int i = pos + 1; i < ps->_size; i++) {
		ps->_array[i - 1] = ps->_array[i];
	}
	ps->_size--;
}
// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的下标，否则返回-1 
int SeqListFind(PSeq ps, DataType data); 
int SeqListFind(PSeq ps, DataTppe data) {
	assert(ps);
	for (int i = 0; i < ps->_size; i++) {
		if (ps->_array[i] == data) {
			return i;
		}
	}
	return -1;
}
// 检测顺序表是否为空，如果为空返回非0值，非空返回0 
int SeqListEmpty(PSeq ps); 
int SeqListEmpty(PSeq ps) {
	assert(ps);
	return 0 == ps->_size;
}
// 返回顺序表中有效元素的个数 
int SeqListSize(PSeq ps); 
int  SeqListSize(PSeq ps) {
	assert(ps);
	return ps->_size;
}
// 返回顺序表的容量大小 
int SeqListCapacity(PSeq ps); 
int SeqListCapacity(PSeq ps) {
	assert(ps);
	return ps->_capacity;
}
// 将顺序表中的元素清空 
void SeqListClear(PSeq ps); 
void SeqListClear(PSeq ps) {
	assert(ps);
	ps->_size = 0;
}
// 删除顺序表中第一个值为data的元素 
void SeqListRemove(PSeq ps, DataType data); 
void SeqListRemove(PSeq ps, DataTppe data) {
	SeqListErase(ps, SeqListFind(ps, data));
}
// 销毁顺序表 
void SeqListDestroy(PSeq ps); 
void SeqLsitDestrory(PSeq ps) {
	if(ps->_array) {
		free(ps->_array);
		ps->_array == NULL;
		ps->_capacity = 0;
		ps->_size = 0;
	}
}
// 顺序表的扩容 
void CheckCapacity(PSeq ps); 
void CheckCapacity(PSeq ps) {
	assert(ps);
	if (ps->_size == ps->_capacity) {
		int newCapacity = ps->_capacity * 2;
		int* pTemp = (DataTppe*)malloc(newCapacity * sizeof(DataTppe));
		if (pTemp == NULL) {
			assert(0);
			return;
		}
		for (int i = 0; i < ps->_size; i++) {
			pTemp[i] = ps->_array[i];
		}
		free(ps->_array);
		ps->_array = pTemp;
		ps->_capacity = newCapacity;
	}
}