C语言模拟实现顺序表--数据结构

C语言模拟实现顺序表–数据结构

头文件：SeqList.h

#ifndef __SeqList_H__
#define __SeqList_H__

#define TURE 1;
#define FALSE 0;

typedef int DataType;//定义数据类型
typedef struct SeqList
{
	DataType* array;//存储的信息
	int size;//有效的元素个数
	int capacity;//容量
}SeqList,*PSeqList;


void SeqListInit(PSeqList ps);//初始化
void SeqListPrint(PSeqList ps);//打印

void CheakCapacity(PSeqList ps);//检查是否已满，增容
void SeqListPushBack(PSeqList ps, DataType data);//尾插
void SeqListPopBack(PSeqList ps);//尾删

void SeqListPushFront(PSeqList ps, DataType data);//头插
void SeqListPopFront(PSeqList ps);//头删

void SeqListInsert(PSeqList ps, int pos, DataType data);//任意位置插入
void SeqListErase(PSeqList ps, int pos);//在任意位置删除

int SeqListFind(PSeqList ps, DataType data);//查找顺序表中值为data的元素的位置
void SeqListRemove(PSeqList ps, DataType data);//移除顺序表中第一个值为data的元素
void SeqListRemoveAll(PSeqList ps, DataType data);//移除顺序表中所有值为data的元素

int SeqListSize(PSeqList ps);//获取顺序表有效元素的个数
int SeqListCapacity(PSeqList ps);//获取顺序表的容量

int SeqListEmpty(PSeqList ps);//检查顺序表是否为空

DataType SeqListFront(PSeqList ps);//获取顺序表中的第一个元素
DataType SeqListBack(PSeqList ps);//获取顺序表中的最后一个元素

void SeqListDestory(PSeqList ps);//消除（与初始化成对出现）

#endif//__SeqList_H__

源文件：SeqList.c

#include "SeqList.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void SeqListInit(PSeqList ps)
{
	assert(ps);
	ps->array = (DataType*)malloc(sizeof(DataType)* 10);
	if (ps->array == NULL)//开辟空间失败
	{
		//assert(0);
		return;
	}
	ps->capacity = 10;
	ps->size = 0;
}
void SeqListPrint(PSeqList ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d", ps->array[i]);
	}
	printf("\n");
}
void CheakCapacity(PSeqList ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity * 2;//定义新的容量
		DataType* PTemp = (DataType*)malloc(sizeof(DataType)*newcapacity);//增容
		if (PTemp == NULL)
		{
			assert(0);
			return;
		}
		//拷贝元素
		memcpy(PTemp, ps->array, ps->size*sizeof(DataType));

		//释放旧的空间
		free(ps->array);
		ps->array = PTemp;
		ps->capacity = newcapacity;
	}
}
void SeqListPushBack(PSeqList ps,DataType data)
{
	assert(ps);
	CheakCapacity(ps);//检查是否已满，增容
	ps->array[ps->size] = data;
	ps->size++;
}
void SeqListPopBack(PSeqList ps)
{
	assert(ps);
	if (0 == ps -> size)
	{
		printf("顺序表为空，没有可删除的项\n");
		return;
	}
	ps->size--;
}
void SeqListPushFront(PSeqList ps, DataType data)
{
	assert(ps);
	CheakCapacity(ps);//检查是否已满，增容
	int i = 0;
	for (i = ps->size; i > 0; i--)
	{
		ps->array[i] = ps->array[i-1];
	}
	ps->array[0] = data;
	ps->size++;
}
void SeqListPopFront(PSeqList ps)
{
	assert(ps);
	if (0 == ps->size)
	{
		printf("顺序表为空，没有可删除的项\n");
		return;
	}
	int i = 0;
	for (i = 0; i < ps->size-1; i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}
void SeqListInsert(PSeqList ps, int pos, DataType data)
{
	assert(ps);
	if (pos<0 || pos>ps->size)
	{
		printf("插入元素非法，无效\n");
		return;
	}
	CheakCapacity(ps);//检查是否已满，增容
	int i = 0;
	for (i = ps->size; i > pos; i--)
	{
		ps->array[i] = ps->array[i - 1];
	}
	ps->array[pos] = data;
	ps->size++;
}
void SeqListErase(PSeqList ps, int pos)
{
	assert(ps);
	if (pos < 0 || pos >= ps->size)
	{
		printf("删除的项不存在\n");
		return;
	}
	if (0 == ps->size)
	{
		printf("顺序表为空,没有可以删除的项\n");
		return;
	}
	int i = 0;
	for (i = pos; i < ps->size-1; i++)
	{
		ps->array[i] = ps->array[i+1];//注意：这里不能用i-1=i这种类型的
	}
	ps->size--;
}


int SeqListFind(PSeqList ps, DataType data)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->array[i] == data)
		{
			return i;
		}
	}
	printf("查找的项不存在\n");
	return -1;
}
void SeqListRemove(PSeqList ps, DataType data)
{
	assert(ps);
	int ret = SeqListFind(ps, data);
	int i = 0;
	if (ret != -1)
	{
		SeqListErase(ps, ret);
		return;
	}
	else
		printf("移除的项不存在\n");
	return;
}
void SeqListRemoveAll(PSeqList ps, DataType data)
{
	assert(ps);
	int i = 0;
	int j = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->array[i] == data)
		{
			j = i;
			SeqListErase(ps, j);
		}	
	}
}
int SeqListSize(PSeqList ps)
{
	assert(ps);
	return ps->size;
}
int SeqListCapacity(PSeqList ps)
{
	assert(ps);
	return ps->capacity;
}
int SeqListEmpty(PSeqList ps)
{
	assert(ps);
	if (ps->size == 0)
		return TURE;
	return FALSE;
}
DataType SeqListFront(PSeqList ps)
{
	DataType ret = 0;
	ret = ps->array[0];
	return ret;
}
DataType SeqListBack(PSeqList ps)
{
	DataType ret = 0;
	ret = ps->array[ps->size - 1];
	return ret;
}
void SeqListDestory(PSeqList ps)
{
	assert(ps);
	if (ps->array)
	{
		free(ps->array);
		ps->array = NULL;
		ps->size = 0;
		ps->capacity = 0;
		printf("消除成功\n");
	}
}

测试文件：test.c

#include "SeqList.h"
#include <stdio.h>

int main()
{
	SeqList seq;
	SeqListInit(&seq);//初始化
	SeqListPrint(&seq);//打印

	SeqListPushBack(&seq,3);//尾插
	SeqListPushBack(&seq,2);
	SeqListPushBack(&seq,5);
	SeqListPushBack(&seq, 1);
	SeqListPushBack(&seq, 1);
	SeqListPopBack(&seq);//尾删

	SeqListPushFront(&seq, 1);//头插
	SeqListPushFront(&seq, 0);
	SeqListPushFront(&seq, 9);
	SeqListPopFront(&seq);//头删

	SeqListInsert(&seq, 2, 6);//任意位置插入
	SeqListErase(&seq,0);//任意位置删除

	SeqListPrint(&seq);//打印

	printf("%d\n",SeqListFind(&seq, 6));//查找顺序表中值为data的元素的位置
	SeqListRemove( &seq,2);//移除顺序表中第一个值为data的元素
	SeqListPrint(&seq);//打印
	SeqListRemoveAll(&seq, 1);//移除顺序表中所有值为data的元素
	SeqListPrint(&seq);//打印

	printf("%d\n",SeqListSize(&seq));//获取顺序表有效元素的个数
	printf("%d\n", SeqListCapacity(&seq));//获取顺序表的容量

	printf("%d\n", SeqListEmpty(&seq));//检查顺序表是否为空

	printf("%d\n", SeqListFront(&seq));//获取顺序表中的第一个元素
	printf("%d\n",SeqListBack(&seq));//获取顺序表中的最后一个元素
	SeqListDestory(&seq);//消除
	return 0;
}