数据结构初阶 ---- 顺序表的(C语言)实现

目录

一.动态顺序表的结构体定义

二.动态顺序表的函数接口

1.顺序表的初始化

 2.顺序表的销毁

3.打印结构体数组内的内容

4.检查数组容量(容量不够时，扩容）

5.顺序表的尾插

6.顺序表的尾删

 7.顺序表的头插

 8.顺序表的头删

9.顺序表的查找 （找到了，就返回x的下标，没有找到的话，就返回 -1）

10.顺序表在pos位置插入指定的数字x

 11.顺序表删除pos位置的值

三.源代码

1.SeqList.h

2.SeqList.c

3.Test.c

---

一.动态顺序表的结构体定义

（顺序表可以动态存储也可以静态存储，但是一般采用的都是动态存储，可以减少空间的浪费）。

typedef int SLDataType;

//动态顺序表
typedef struct SeqList
{
	SLDataType* a;
	int size;     //表示数组中存储了多少个有效的数据
	int capacity; //表示数组实际能存储的空间容量的大小
}SL;

这里把int 重定义(typedef)了一下,这样做的目的也是为了方便以后如果想更改这个顺序表中数组的数据类型时会很方便。

二.动态顺序表的函数接口

//接口函数
void SeqListInit(SL* ps);//初始化
void SeqListDestory(SL* ps);//销毁函数
void SeqListPrint(SL* ps);//打印结构体数组内的内容
void SeqListCheckCapacity(SL* ps);//检查容量的函数
void SeqListPushBack(SL* ps, SLDataType x);//尾插
void SeqListPopBack(SL* ps);//尾删
void SeqListPushFront(SL* ps, SLDataType x);//头插
void SeqListPopFront(SL* ps);//头删

//找到了，就返回x的下标，没有找到的话，就返回 -1
int SeqListFind(SL* ps, SLDataType x);//寻找某个值的位置的函数
//在pos下标位置进行插入
void SeqListInsert(SL* ps, int pos, SLDataType x);
//删除pos位置的数据
void SeqListErase(SL* ps, int pos);

1.顺序表的初始化

顺序表的初始化：就是对它的指针，数据个数，和容量进行了初始化

void SeqListInit(SL* ps)//初始化
{
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

 2.顺序表的销毁

顺序表的销毁：就是把它的指针释放销毁掉，然后置空；把它的数据个数和容量也都置为0

void SeqListDestory(SL* ps)//销毁函数
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

3.打印结构体数组内的内容

void SeqListPrint(SL* ps)//打印结构体数组内的内容
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

4.检查数组容量(容量不够时，扩容）

在进行扩容的时候，是有2种情况的，一种是这个数组还是一个空的数组的时候，我们需要给它开辟空间；另一种情况就是如果这个数组不是空的，而是容量满了需要扩容的话，我们就可以给它扩容，扩2倍。(这里为什么是扩2倍呢？主要就是为了不必频繁扩容）

void SeqListCheckCapacity(SL* ps)//检查容量的函数
{
	if (ps->size == ps->capacity)
	{
        // 这里用到了三目操作符
		int newcapacity = ps->capacity > 0 ? ps->capacity * 2 : 4;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
}

5.顺序表的尾插

只要是插入操作就要考虑空间是否够用，是否需要增容的问题，所以在插入之前要先检查一下空间容量。

尾插在检查好空间容量以后，就直接插入就可以了。

void SeqListCheckCapacity(SL* ps)//检查容量的函数
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity > 0 ? ps->capacity * 2 : 4;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
}

void SeqListPushBack(SL* ps, SLDataType x)//尾插
{
	SeqListCheckCapacity(ps);//检查容量的函数
	ps->a[ps->size] = x;
	ps->size++;
}

6.顺序表的尾删

删除操作，要考虑数组内是否还有元素，如果没有了就不能再进行删除操作了。

这里使用assert来进行断言，所以当数组内没有元素以后，程序就不会再继续向下执行删除操作了。

void SeqListPopBack(SL* ps)//尾删
{
	assert(ps->size > 0);
	ps->size--;
}

 7.顺序表的头插

只要是插入操作就要考虑空间是否够用，是否需要增容的问题，所以在插入之前要先检查一下空间容量。

头插，需要把数组内原有的所有元素 从后往前 依次向后挪动一位，然后再进行头插，把要插入的值放到数组下标为0的位置（数组的头）。

void SeqListCheckCapacity(SL* ps)//检查容量的函数
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity > 0 ? ps->capacity * 2 : 4;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
}

void SeqListPushFront(SL* ps, SLDataType x)//头插
{
	SeqListCheckCapacity(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++;
}

 8.顺序表的头删

删除操作，要考虑数组内是否还有元素，如果没有了就不能再进行删除操作了。

头删的操作，就是从正数第2个元素（下标为1的位置）开始，从前向后 依次向前挪动一位。

void SeqListPopFront(SL* ps)//头删
{
	assert(ps->size > 0);//不为空才能继续往下走，去进行删除的操作
	int i = 1;
	for (i = 1; i < ps->size; i++)
	{
		ps->a[i - 1] = ps->a[i];
	}
	ps->size--;
}

9.顺序表的查找 （找到了，就返回x的下标，没有找到的话，就返回 -1）

//找到了，就返回x的下标，没有找到的话，就返回 -1
int SeqListFind(SL* ps, SLDataType x)//寻找某个值的位置的函数
{
	int i = 0;
	while (i < ps->size)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
		i++;
	}
	return -1;
}

10.顺序表在pos位置插入指定的数字x

插入操作都是要先判断容量是否够用，是否需要扩容；然后再继续插入的操作。

//在pos下标位置进行插入
//pos是下标
void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SeqListCheckCapacity(ps);//检查容量的函数 
	int end = ps->size;
	while (end != pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

找到了就插入，没找到就不插入，这里的pos是数组下标的意思。

 11.顺序表删除pos位置的值

删除操作，要先判断数组是否为空，为空的话就不必执行删除操作了；不为空的话再继续执行删除操作。（这里的pos也是数组下标的意思）

//删除pos位置的数据
void SeqListErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos < ps->size);
	int begin = pos;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

三.源代码

1.SeqList.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include

typedef int SLDataType;

//动态顺序表
typedef struct SeqList
{
	SLDataType* a;
	int size;     //表示数组中存储了多少个有效的数据
	int capacity; //表示数组实际能存储的空间容量的大小
}SL;

//接口函数
void SeqListInit(SL* ps);//初始化
void SeqListDestory(SL* ps);//销毁函数
void SeqListPrint(SL* ps);//打印结构体数组内的内容
void SeqListCheckCapacity(SL* ps);//检查容量的函数
void SeqListPushBack(SL* ps, SLDataType x);//尾插
void SeqListPopBack(SL* ps);//尾删
void SeqListPushFront(SL* ps, SLDataType x);//头插
void SeqListPopFront(SL* ps);//头删

//找到了，就返回x的下标，没有找到的话，就返回 -1
int SeqListFind(SL* ps, SLDataType x);//寻找某个值的位置的函数
//在pos下标位置进行插入
void SeqListInsert(SL* ps, int pos, SLDataType x);
//删除pos位置的数据
void SeqListErase(SL* ps, int pos);

2.SeqList.c

#include"SeqList.h"


//接口函数
void SeqListInit(SL* ps)//初始化
{
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

void SeqListDestory(SL* ps)//销毁函数
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

void SeqListPrint(SL* ps)//打印结构体数组内的内容
{
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SeqListCheckCapacity(SL* ps)//检查容量的函数
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity > 0 ? ps->capacity * 2 : 4;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * newcapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
}

void SeqListPushBack(SL* ps, SLDataType x)//尾插
{
	SeqListCheckCapacity(ps);//检查容量的函数
	ps->a[ps->size] = x;
	ps->size++;
}

void SeqListPopBack(SL* ps)//尾删
{
	assert(ps->size > 0);
	ps->size--;
}

void SeqListPushFront(SL* ps, SLDataType x)//头插
{
	SeqListCheckCapacity(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 SeqListPopFront(SL* ps)//头删
{
	assert(ps->size > 0);//不为空才能继续往下走，去进行删除的操作
	int i = 1;
	for (i = 1; i < ps->size; i++)
	{
		ps->a[i - 1] = ps->a[i];
	}
	ps->size--;
}



//找到了，就返回x的下标，没有找到的话，就返回 -1
int SeqListFind(SL* ps, SLDataType x)//寻找某个值的位置的函数
{
	int i = 0;
	while (i < ps->size)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
		i++;
	}
	return -1;
}

//在pos下标位置进行插入
void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SeqListCheckCapacity(ps);//检查容量的函数
	int end = ps->size;
	while (end != pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

//删除pos位置的数据
void SeqListErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos < ps->size);
	int begin = pos;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

3.Test.c

#include"SeqList.h"
void TestSeqList1()
{
	SL s1;
	SeqListInit(&s1);//初始化
	SeqListPushBack(&s1, 1);//尾插
	SeqListPushBack(&s1, 2);//尾插
	SeqListPushBack(&s1, 3);//尾插
	SeqListPushBack(&s1, 4);//尾插
	SeqListPushBack(&s1, 5);//尾插
	SeqListPrint(&s1);//打印结构体数组内的内容

	SeqListPopBack(&s1);//尾删
	SeqListPopBack(&s1);//尾删
	SeqListPopBack(&s1);//尾删
	SeqListPopBack(&s1);//尾删
	SeqListPrint(&s1);//打印结构体数组内的内容

	SeqListDestory(&s1);//销毁函数
}

void TestSeqList2()
{
	SL s1;
	SeqListInit(&s1);//初始化
	SeqListPushBack(&s1, 1);//尾插
	SeqListPushBack(&s1, 2);//尾插
	SeqListPushBack(&s1, 3);//尾插
	SeqListPushBack(&s1, 4);//尾插
	SeqListPushBack(&s1, 5);//尾插
	SeqListPrint(&s1);//打印结构体数组内的内容

	SeqListPushFront(&s1, 10);//头插
	SeqListPushFront(&s1, 20);//头插
	SeqListPushFront(&s1, 30);//头插
	SeqListPushFront(&s1, 40);//头插
	SeqListPushFront(&s1, 50);//头插
	SeqListPrint(&s1);//打印结构体数组内的内容

	SeqListPopFront(&s1);//头删
	SeqListPopFront(&s1);//头删
	SeqListPopFront(&s1);//头删
	SeqListPrint(&s1);//打印结构体数组内的内容
	SeqListDestory(&s1);//销毁函数
}

void TestSeqList3()
{
	SL s1;
	SeqListInit(&s1);//初始化
	SeqListPushBack(&s1, 1);//尾插
	SeqListPushBack(&s1, 2);//尾插
	SeqListPushBack(&s1, 3);//尾插
	SeqListPushBack(&s1, 4);//尾插
	SeqListPushBack(&s1, 5);//尾插

	SeqListPushFront(&s1, 10);//头插
	SeqListPushFront(&s1, 20);//头插
	SeqListPushFront(&s1, 30);//头插
	SeqListPushFront(&s1, 40);//头插
	SeqListPushFront(&s1, 50);//头插
	SeqListPrint(&s1);//打印结构体数组内的内容

	int a = SeqListFind(&s1, 100);//寻找某个值的位置的函数
	int b = SeqListFind(&s1, 40);//寻找某个值的位置的函数
	printf("%d %d\n", a, b);

	SeqListInsert(&s1, 10, 60);//在pos下标位置进行插入
	SeqListPrint(&s1);//打印结构体数组内的内容
	SeqListInsert(&s1, 0, 60);//在pos下标位置进行插入
	SeqListPrint(&s1);//打印结构体数组内的内容
	SeqListInsert(&s1, 3, 60);//在pos下标位置进行插入
	SeqListPrint(&s1);//打印结构体数组内的内容

	SeqListDestory(&s1);//销毁函数
}

void TestSeqList4()
{
	SL s1;
	SeqListInit(&s1);//初始化
	SeqListPushBack(&s1, 1);//尾插
	SeqListPushBack(&s1, 2);//尾插
	SeqListPushBack(&s1, 3);//尾插
	SeqListPushBack(&s1, 4);//尾插
	SeqListPushBack(&s1, 5);//尾插

	SeqListPrint(&s1);//打印结构体数组内的内容

	SeqListErase(&s1, 0);//删除pos位置的数据
	SeqListPrint(&s1);//打印结构体数组内的内容
	SeqListErase(&s1, 2);//删除pos位置的数据
	SeqListPrint(&s1);//打印结构体数组内的内容
	SeqListErase(&s1, 2);//删除pos位置的数据
	SeqListPrint(&s1);//打印结构体数组内的内容

	int pos = SeqListFind(&s1, 3);
	if (pos != -1)
	{
		SeqListErase(&s1, pos);
	}
	SeqListPrint(&s1);//打印结构体数组内的内容

	SeqListDestory(&s1);//销毁函数
}

int main()
{
	//TestSeqList1();
	//TestSeqList2();
	//TestSeqList3();
	//TestSeqList4();
	return 0;
}