线性表顺序存储方式实现，表和前台业务数据的分离

最新推荐文章于 2024-04-22 22:57:23 发布

原创最新推荐文章于 2024-04-22 22:57:23 发布 · 501 阅读

0 ·

CC 4.0 BY-SA版权

C/C++基础的系统学习专栏收录该内容

31 篇文章

订阅专栏

本文介绍了一个使用C语言实现的顺序表数据结构，并通过教师信息管理实例展示了业务数据与链表算法的分离技巧。文章详细讲解了顺序表的创建、插入、获取、删除等操作，并提供了完整的代码示例。

先贴出前台测试代码

#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "seqlist.h"


typedef struct _Teacher
{
	char name[64];
	int age ;
	int buf;
}Teacher;

void main()
{
	int ret = 0, i = 0;
	Teacher t1, t2, t3;
	SeqList* list = NULL;

	t1.age = 10;
	t2.age = 20;
	t3.age = 30;

	list = SeqList_Create(10);

	
	//仔细思考：业务数据 和 链表算法（底层库）是如何分离的。。。。。。
	//业务数据结点的管理（内存的生命周期）甩给了上层应用（业务模型）
	ret = SeqList_Insert(list, (SeqListNode*) &t1, 0);
	ret = SeqList_Insert(list, (SeqListNode*) &t2, 0);
	ret = SeqList_Insert(list, (SeqListNode*) &t3, 0);

	
	//循环遍历
	for (i=0; i<SeqList_Length(list); i++)
	{
		Teacher *tmp = (Teacher *)SeqList_Get(list, i);
		printf("age:%d \n", tmp->age);
	}
	
	//循环删除
	for (i=0; i<SeqList_Length(list); i++)
	{
		SeqList_Delete(list, 0);
	}
	
	 SeqList_Destroy(list);
	system("pause");
}

顺序表代码

#ifndef  __MY_SEQLIST_H__ 
#define __MY_SEQLIST_H__

typedef void SeqList;
typedef void SeqListNode;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);


#endif  //__MY_SEQLIST_H__

#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "seqlist.h"

typedef struct _tag_SeqList
{
	int nLength;                // 线性表当前长度
	int nCapacity;              // 线性表的容量
	unsigned int* node;         // 里面存放的是前台结构体的指针
}TSeqList;

SeqList* SeqList_Create(int capacity)
{
	TSeqList* seqList = NULL;
	
	if (capacity <= 0)
	{
		return NULL;
	}

	// 这是比较复杂的一种写法，下面会有一种比较巧妙和方便的一种写法
	//{
	//	seqList = (TSeqList*)malloc(sizeof(TSeqList));

	//	if (!seqList)
	//	{
	//		return NULL;
	//	}

	//	seqList->node = (unsigned int*)malloc(capacity * sizeof(unsigned int));

	//	if (!seqList->node)
	//	{
	//		return NULL;
	//	}
	//	seqList->nCapacity = capacity;
	//	seqList->nLength = 0;
	//}

	// 下面这种方法比较简单
	// 直接申请一块连续的内存，其大小可以容纳TSeqList和其中的node
	// 然后seqList + 1指向该内存TSeqList的末尾，所以剩下的一块内存就可以强制转换成node的内存空间了
	// 这样的话不单单申请的时候没有那么复杂，释放的时候也很简单，直接释放就可以
	{
		seqList = (TSeqList*)malloc(sizeof(TSeqList) + capacity * sizeof(unsigned int));

		if (!seqList)
		{
			return NULL;
		}
		seqList->node = (unsigned int *)(seqList + 1);	// 
		seqList->nCapacity = capacity;
		seqList->nLength = 0;
	}

	return seqList;
}

void SeqList_Destroy(SeqList* list)
{
	TSeqList* seqList = (TSeqList*)list;

	if (!seqList)
	{
		return;
	}

	// 对应比较复杂的申请方式
	//if (seqList->node)
	//{
	//	free(seqList->node);
	//}

	//free(seqList);

	// 对应简单的申请方式
	free(seqList);
}

void SeqList_Clear(SeqList* list)
{
	TSeqList* seqList = (TSeqList*)list;
	int i;

	if (!seqList)
	{
		return;
	}
	seqList->nLength = 0;
}

int SeqList_Length(SeqList* list)
{
	TSeqList* seqList = (TSeqList*)list;
	int i;

	if (!seqList)
	{
		return -1;
	}

	return seqList->nLength;
}

int SeqList_Capacity(SeqList* list)
{
	TSeqList* seqList = (TSeqList*)list;
	int i;

	if (!seqList)
	{
		return -1;
	}

	return seqList->nCapacity;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
	TSeqList* seqList = (TSeqList*)list;
	int i;

	if (!seqList || !node)
	{
		return;
	}

	if (pos < 0 || pos >= seqList->nCapacity)
	{
		return;
	}

	if (seqList->nLength + 1 >= seqList->nCapacity)
	{
		return;
	}

	for (i = seqList->nLength; i > pos; i--)
	{
		seqList->node[i] = seqList->node[i - 1];
	}

	seqList->node[pos] = (unsigned int)node;
	seqList->nLength++;

	return 0;
}

SeqListNode* SeqList_Get(SeqList* list, int pos)
{
	TSeqList* seqList = (TSeqList*)list;
	int i;

	if (!seqList)
	{
		return NULL;
	}

	if (pos > seqList->nLength)
	{
		return NULL;
	}
	return (SeqListNode*)seqList->node[pos];
}

SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
	TSeqList* seqList = (TSeqList*)list;
	SeqListNode* rev = NULL;
	int i;

	if (!seqList)
	{
		return NULL;
	}

	if (pos > seqList->nLength)
	{
		return NULL;
	}
	rev = (SeqListNode*)seqList->node[pos];
	for (i = pos; i + 1 <= seqList->nLength; i++)
	{
		seqList->node[i] = seqList->node[i + 1];
	}
	seqList->nLength--;
	return rev;
}