数据结构之顺序表（C语言）

1.概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表一般可以分为：

1. 静态顺序表：使用定长数组存储元素。
2. 动态顺序表：使用动态开辟的数组存储。

2接口的实现

2.1顺序表初始化

void SeqListInit(SeqList* ps)
{
	assert(ps);
	SLDateType* tmp = (SLDateType*)calloc(INIT_CAPCITY, sizeof(SLDateType));
	if (tmp == NULL)
	{
		perror("SeqListInit::calloc");
		return;
	}
	ps->a = tmp;
	ps->size = 0;
	ps->capacity = INIT_CAPCITY;
}

2.2检查容量是否已满（满了扩容）

void Check_Capcity(SeqList* ps)
{
	assert(ps);
	if (ps->capacity == ps->size)
	{
		SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("Check_Capcity::realloc");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
		printf("增容成功\n");
	}
}

2.3顺序毁尾插

void SeqListPushBack(SeqList* ps, SLDateType x) 
{
	//检查容量是否已满
	Check_Capcity(ps);
	ps->a[ps->size] = x;
	ps->size++;

}

2.4顺序表尾删

void SeqListPopBack(SeqList* ps)
{
	//进行检查，防止size--为负数
	assert(ps->size);
	ps->size--;
}

2.5顺序表头插

void SeqListPushFront(SeqList* ps, SLDateType x)
{
	//检查容量是否已满
	Check_Capcity(ps);
	int i = 0;
	for (i = ps->size-1; i >= 0; i--)
	{
		ps->a[i+1] = ps->a[i];
	}
	ps->a[0] = x;
	ps->size++;

}

2.6顺序表头删

void SeqListPopFront(SeqList* ps)
{
	assert(ps->size);
	int i = 0;
	for (i = 0; i < ps->size-1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

2.7顺序表查找

int SeqListFind(SeqList* ps, SLDateType x)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

2.8顺序表在pos位置插入x

void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	//因为顺序表是连续存放的，所以只能在中间插入
	assert(pos <= ps->size);
	Check_Capcity(ps);
	int i = 0;
	for (i = ps->size; i > pos - 1; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[pos - 1] = x;
	ps->size++;
}

2.9顺序表删除在pos位置的数据

void SeqListErase(SeqList* ps, int pos)
{
	assert(pos < ps->size);
	Check_Capcity(ps); 
	int i = 0;
	for (i = pos; i<ps->size; i++)
	{
		ps->a[i-1] = ps->a[i];
	}
	ps->size--;
}

2.10顺序表修改

int SeqListModify(SeqList* ps, int pos, SLDateType x)
{
	assert(ps->size);
	ps->a[pos - 1] = x;
}

2.11顺序表打印

void SeqListPrint(SeqList* ps)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

2.12顺序表销毁

void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

3.源代码

3.1 SeqList.h

#pragma once

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

typedef int SLDateType;
#define INIT_CAPCITY 5 //定义初始化容量大小
typedef struct SeqList
{
	SLDateType* a;// 指向动态开辟的数组
	int size;//已经存在的
	int capacity;//全部容量
}SeqList;

// 对数据的管理:增删查改 

//顺序表初始化
void SeqListInit(SeqList* ps);
//顺序表销毁
void SeqListDestroy(SeqList* ps);
//顺序表打印
void SeqListPrint(SeqList* ps);
//顺序毁尾插
void SeqListPushBack(SeqList* ps, SLDateType x);
//顺序表头插
void SeqListPushFront(SeqList* ps, SLDateType x);
//顺序表头删
void SeqListPopFront(SeqList* ps);
//顺序表尾删
void SeqListPopBack(SeqList* ps);
// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);
// 顺序表删除在pos位置的数据
void SeqListErase(SeqList* ps, int pos);
// 顺序表修改
int SeqListModify(SeqList* ps,int pos, SLDateType x);

3.2 SeqList.c

#define  _CRT_SECURE_NO_WARNINGS 1

#include"SeqList.h"

//初始化
void SeqListInit(SeqList* ps)
{
	assert(ps);
	SLDateType* tmp = (SLDateType*)calloc(INIT_CAPCITY, sizeof(SLDateType));
	if (tmp == NULL)
	{
		perror("SeqListInit::calloc");
		return;
	}
	ps->a = tmp;
	ps->size = 0;
	ps->capacity = INIT_CAPCITY;
}

//销毁
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

//打印
void SeqListPrint(SeqList* ps)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

//检查容量是否已满
void Check_Capcity(SeqList* ps)
{
	assert(ps);
	if (ps->capacity == ps->size)
	{
		SLDateType* tmp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("Check_Capcity::realloc");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
		printf("增容成功\n");
	}
}

//尾插
void SeqListPushBack(SeqList* ps, SLDateType x) 
{
	//检查容量是否已满
	Check_Capcity(ps);
	ps->a[ps->size] = x;
	ps->size++;

}

//头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	//检查容量是否已满
	Check_Capcity(ps);
	int i = 0;
	for (i = ps->size-1; i >= 0; i--)
	{
		ps->a[i+1] = ps->a[i];
	}
	ps->a[0] = x;
	ps->size++;

}

//尾删
void SeqListPopBack(SeqList* ps)
{
	//进行检查，防止size--为负数
	assert(ps->size);
	ps->size--;
}

//头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps->size);
	int i = 0;
	for (i = 0; i < ps->size-1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x)
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	//因为顺序表是连续存放的，所以只能在中间插入
	assert(pos <= ps->size);
	Check_Capcity(ps);
	int i = 0;
	for (i = ps->size; i > pos - 1; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[pos - 1] = x;
	ps->size++;
}

// 顺序表删除在pos位置的数据
void SeqListErase(SeqList* ps, int pos)
{
	assert(pos < ps->size);
	Check_Capcity(ps); 
	int i = 0;
	for (i = pos; i<ps->size; i++)
	{
		ps->a[i-1] = ps->a[i];
	}
	ps->size--;
}

// 顺序表修改
int SeqListModify(SeqList* ps, int pos, SLDateType x)
{
	assert(ps->size);
	ps->a[pos - 1] = x;
}

3.3 test.c

#define  _CRT_SECURE_NO_WARNINGS 1

#include"SeqList.h"

void TestSeqList1()
{
	//初始化
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 6);
	SeqListPushBack(&s, 7);
	SeqListPushBack(&s, 8);
	SeqListPushBack(&s, 9);
	SeqListPrint(&s);
	SeqListPushFront(&s, 10);
	SeqListPushFront(&s, 20);
	SeqListPrint(&s);

	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s);

	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPopFront(&s);
	SeqListPrint(&s);

	SeqListDestroy(&s);
}

int main()
{
	TestSeqList1();
	return 0;
}