线性表顺序存储中常用的操作函数.h和.c文件

 线性表有顺序存储和链式存储，此处为顺序存储造作方法。

（1）建立线性表L

（2）判断线性表是否为空

（3）将线性表清空

（4）取出线性表L中第i个位置的值

（5）查找线性表L中与给定值e相同的元素，成功返回1，失败返回0

（6）在线性表L中第i 个位置插入元素e

（7）删除线性表L中第i个元素

（8）求线性表L的元素个数

（9）求线性表的最大容量

 

 

此处为SeqList.h文件
#ifndef _SEQLIST_H_
#define _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);

int SeqList_Empty(SeqList* list);

#endif

 

 

此处为SeqList.c文件
#include <stdio.h>
#include <malloc.h>
#include "SeqList.h"

//typedef void SeqList;
//typedef void SeqListNode;


typedef unsigned int TSeqListNode;		//线性表数据的类型 

typedef struct _tag_SeqList
{
	int capacity;					//顺序线表的最大存储空间 
	int length;						//线性表的长度length <= capacity 
	TSeqListNode* node;				//序列数据的指针 
} TSeqList;


//创建线性存储的线性表 
SeqList* SeqList_Create(int capacity) // O(1)
{
	TSeqList* ret = NULL;

	if (capacity >= 0)
	{
		//申请一个结构体和n个data总共所需的空间 ，malloc函数返回的是一个地址 
		ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode) * capacity);

	}

	if (ret != NULL)			//判断申请的空间是否为空，如果 不是空开始赋值 
	{

		ret->capacity = capacity;					//将线性表的最大容量赋值给 
		ret->length = 0;							//线性表的长度为0 
		ret->node = (TSeqListNode*)(ret + 1);
		// 结构体类型的指针，移动了一个结构体长度的距离之后，强制转换成了数据类型的指针 
	}

	return ret;							//返回数据类型指针所指向的地址 
}

//销毁线性表 （释放线性表所占用的内存） 
void SeqList_Destroy(SeqList* list) // O(1)
{
	free(list);
}


//清空线性表的内容（只进行了将线性表的长度变为了0，并没有将相关内容清零） 
//如果想要重新写入，会将之前的数据覆盖掉 
void SeqList_Clear(SeqList* list) // O(1)
{
	TSeqList* sList = (TSeqList*)list;

	if (sList != NULL)
	{
		sList->length = 0;
	}
}

//求取顺序线性表的长度，只需要将线性表之前的结构体中关于线性表长度的数值取出即可 

int SeqList_Length(SeqList* list) // O(1)
{
	TSeqList* sList = (TSeqList*)list;	//将链表类型的指针转换为结构体类型的指针 
	int ret = -1;						//将返回值初始化为-1 

	if (sList != NULL)					//判断结构体指针是否为空 
	{
		ret = sList->length;			//不为空的时候取出结构体中链表的长度数据 
	}

	return ret;
}


//求出线性表最大容量 

int SeqList_Capacity(SeqList* list) // O(1)
{
	TSeqList* sList = (TSeqList*)list;
	int ret = -1;

	if (sList != NULL)
	{
		ret = sList->capacity;
	}

	return ret;
}


//在线性表list中的第pos个位置插入结点 *node 中的数据 
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // O(n) 
{
	TSeqList* sList = (TSeqList*)list;				//将线性表指针强制转换为结构体指针 
	int ret = (sList != NULL);						//如果 强制转换成功ret=1,否则ret=0 
	int i = 0;

	//判断插入一个元素之后，是否超出顺序存储线性表的最大容量 
	ret = ret && (sList->length + 1 <= sList->capacity);
	//判断插入位置pos是否合法，0 <= pos 
	ret = ret && (0 <= pos);

	if (ret)
	{
		if (pos >= sList->length)			//当插入位置大于等于链表的长度时 ，pos等于线性表目前长度的下一个位置 
		{
			pos = sList->length;
		}


		//插入操作的时候线性表插入点右边的数据需要向右移一位 
		//当pos在最右边的时候（pos == sList->length）时，不执行for循环移位
		//当1 <= pos <sList->length时，需要执行for循环向右移位 
		for (i = sList->length; i > pos; i--)
		{
			sList->node[i] = sList->node[i - 1];
		}

		sList->node[i] = (TSeqListNode)node;	//将插入节点的数据值强制转换为结构体中指针的数据类型并赋值 

		sList->length++;						//线性表的长度加一	
	}

	return ret;			//返回插入的结果，成功返回1，失败返回0					
}


//获取顺序存储线性表list中pos位置的值 
SeqListNode* SeqList_Get(SeqList* list, int pos) // O(1) 
{
	TSeqList* sList = (TSeqList*)list;			//将线性表指针强制转换为结构体指针 
	SeqListNode* ret = NULL;					//新建线性表数据类型的指针 

	//判断强制转之后的结构体指针是否为空，获取值得位置是否合法（0 <= pos < sList->length） 
	if ((sList != NULL) && (0 <= pos) && (pos < sList->length))
	{
		//将线性表中 node指针对应的第pos个位置数据的地址取出，并强制转换为序列的类型
		ret = (SeqListNode*)(sList->node[pos]);
	}

	return ret;
}


//删除顺序存储的线性表中第pos个位置的值 
SeqListNode* SeqList_Delete(SeqList* list, int pos) // O(n)
{
	TSeqList* sList = (TSeqList*)list;				//将序列类型的指针强制转换为结构体类型指针 
	//获取顺序存储的线性表中第pos个位置的地址，并赋值给线性表节点类型的指针变量ret 
	SeqListNode* ret = SeqList_Get(list, pos);
	int i = 0;

	if (ret != NULL)								//判断 线性表节点类型的指针变量ret是否为空 
	{
		for (i = pos + 1; i < sList->length; i++)			// 
		{
			sList->node[i - 1] = sList->node[i];		//将第i个位置右边的所有数据向左移一位 
		}

		sList->length--;
	}

	return ret;			//返回删除的结果，删除成功返回1，不成功返回0 
}



int SeqList_Empty(SeqList* list)
{
	TSeqList* sList = (TSeqList*)list;				//将序列类型的指针强制转换为结构体类型指针 
	int ret = NULL;
	
	if (sList->node != NULL)
	{
		ret = 1;
	}

	return ret;		//当序列为空时,返回0，否则返回1

}