【数据结构之顺序表】

一、顺序表

顺序表是一种线性结构，是用一段物理地址连续的存储单元依次存储数据元素。在数组上完成数据的增加、删除，查找、和修改。
顺序表一般可分为：
静态顺序表： 使用固定长度的数组存储。
动态顺序表： 使用动态开辟的数组存储。

1.静态顺序表

静态顺序表只适用于知道需要存储多少数据的场景。静态顺序表的定长数组导致N很大，空间浪费比较大，开小了不够。所以很少使用。

#define N 1024
#include <stdio.h>
typedef int SLDataType;
typedef struct SeqList
{
	SLDataType array[N];  // 定长数组
	size_t size;          // 有效数据的个数
}SeqList;

2.动态顺序表

（1）代码实现定义

typedef int	SLDataTye;
typedef struct SeqList{
	SLDataTye* arr;   //指向动态开辟的数组
	size_t size;      //有效数据个数
	size_t capicity;  //容量空间大小
}SeqList;

（2）初始化顺序表

void SLinit(SeqList* sl)
{
	sl->arr = NULL;
	sl->capicity = 0;
	sl->size = 0;
}

（3）销毁顺序表

void SLDestroy(SeqList* sl)
{
	assert(sl);
		if (sl->arr)
		{
			free(sl->arr);
			sl->arr = NULL;
			sl->capicity = sl->size = 0;
		}
}

（4）打印顺序表

void SLPrint(SeqList* sl)
{
    assert(sl);
	for (int i = 0; i < sl->size; ++i)
	{
		printf("%d ", sl->arr[i]);
	}
	printf("\n");
}

（5）删除指定的位置数据

void SLErase(SeqList* sl, int pos)
{
	assert(sl);
	if (sl == NULL||sl->size==0)
	{
		return;
	}
	if (pos >= 0 && pos <= sl->size)
	{
		int end = sl->size;
		int start = pos+1;
		while (start < end)
		{
			sl->arr[start-1] = sl->arr[start];
			++start;
		}
		sl->size--;
	}
}

（6）检查顺序表容量

void SLCheckCapicity(SeqList* sl)
{
	assert(sl);
	if (sl == NULL)
	{
		return;
	}
	if (sl->capicity == sl->size)
	{
		int newCapicity = sl->capicity == 0 ? 1 : 2 * sl->capicity;
		SLDataTye* tmp = (SLDataTye*)malloc(sizeof(SLDataTye)*newCapicity);
		memcpy(tmp, sl->arr, sizeof(SLDataTye)*sl->size);
		free(sl->arr);
		sl->arr = tmp;
		sl->capicity = newCapicity;
		
	}
}

（7）顺序表尾插

void SLPushBack(SeqList* sl, SLDataTye val)
{
	SLCheckCapicity(sl);
	sl->arr[sl->size] = val;
	sl->size++;
}

（8）顺序表尾删

void SLPopBack(SeqList* sl)
{
	if (sl == NULL)
	{
		return;
	}
	if (sl->size > 0)
	{
		sl->size--;
	}
	else
	printf("删除失败");
}

（9）顺序表的头插

void SLPushFront(SeqList* sl, SLDataTye val)
{
	if (sl == NULL)
	{
		return;
	}
	SLCheckCapicity(sl);
	for (int end = sl->size; end > 0; --end)
	{
		sl->arr[end] = sl->arr[end-1];
	}
	sl->arr[0] = val;
	sl->size++;
}

（10）顺序表的头删

void SLPopFront(SeqList* sl)
{
	if (sl == NULL)
	{
		return;
	}
	for (int start = 1; start < sl->size; ++start)
	{
		sl->arr[start - 1] = sl->arr[start];
	}
	sl->size--;
}

（11）顺序表的指定位置插入

void SLInsert(SeqList* sl, int pos, SLDataTye val)
{
	if (sl == NULL)
	{
		return;
	}
	if (pos >= 0 && pos <= sl->size)
	{
		SLCheckCapicity(sl);
		int start = pos;
		int end = sl->size;
		while (start < end)
		{
			sl->arr[end] = sl->arr[end - 1];
			--end;
		}
		sl->arr[pos] = val;
		sl->size++;
	}
}

（12）顺序表的查找

int SLFindIdx(SeqList* sl,SLDataTye val)
{
	for (int i = 0; i < sl->size; i++)
	{
		if (val == sl->arr[i])
		{
			return i;
		}
	}
	return -1;
}

二、附录

下面是完整代码板块：
1.头文件

typedef int	SLDataTye;
typedef struct SeqList{
	SLDataTye* arr;   //指向动态开辟的数组
	size_t size;      //有效数据个数
	size_t capicity;  //容量空间大小
}SeqList;

void SLInit(SeqList* sl);
void SLDestroySeqList(SeqList* sl);
void SLErase(SeqList* sl ,int pos);
void SLPrintSeqList(SeqList* sl);
void SLCheckCapicity(SeqList* sl);
void SLPushBack(SeqList* sl, SLDataTye val);
void SLPopBack(SeqList* sl);
void SLPushFront(SeqList* sl, SLDataTye val);
void SLPopFront(SeqList* sl);
void SLInsert(SeqList* sl, int pos, SLDataTye val);
int SLFindIdx(SeqList* sl, SLDataTye val);

2.源文件

typedef int	SLDataTye;
typedef struct SeqList{
	SLDataTye* arr;   //指向动态开辟的数组
	size_t size;      //有效数据个数
	size_t capicity;  //容量空间大小
}SeqList;
void SLinit(SeqList* sl)
{
	sl->arr = NULL;
	sl->capicity = 0;
	sl->size = 0;
}
void SLDestroy(SeqList* sl)
{
	assert(sl);
		if (sl->arr)
		{
			free(sl->arr);
			sl->arr = NULL;
			sl->capicity = sl->size = 0;
		}
}
void SLPrint(SeqList* sl)
{
    assert(sl);
	for (int i = 0; i < sl->size; ++i)
	{
		printf("%d ", sl->arr[i]);
	}
	printf("\n");
}

void SLErase(SeqList* sl, int pos)
{
	assert(sl);
	if (sl == NULL||sl->size==0)
	{
		return;
	}
	if (pos >= 0 && pos <= sl->size)
	{
		int end = sl->size;
		int start = pos+1;
		while (start < end)
		{
			sl->arr[start-1] = sl->arr[start];
			++start;
		}
		sl->size--;
	}
}

void SLCheckCapicity(SeqList* sl)
{
	assert(sl);
	if (sl == NULL)
	{
		return;
	}
	if (sl->capicity == sl->size)
	{
		int newCapicity = sl->capicity == 0 ? 1 : 2 * sl->capicity;
		SLDataTye* tmp = (SLDataTye*)malloc(sizeof(SLDataTye)*newCapicity);
		memcpy(tmp, sl->arr, sizeof(SLDataTye)*sl->size);
		free(sl->arr);
		sl->arr = tmp;
		sl->capicity = newCapicity;
		
	}
}

void SLPushBack(SeqList* sl, SLDataTye val)
{
	SLCheckCapicity(sl);
	sl->arr[sl->size] = val;
	sl->size++;
}

void SLPopBack(SeqList* sl)
{
	if (sl == NULL)
	{
		return;
	}
	if (sl->size > 0)
	{
		sl->size--;
	}
	else
	printf("删除失败");
}

void SLPushFront(SeqList* sl, SLDataTye val)
{
	if (sl == NULL)
	{
		return;
	}
	SLCheckCapicity(sl);
	for (int end = sl->size; end > 0; --end)
	{
		sl->arr[end] = sl->arr[end-1];
	}
	sl->arr[0] = val;
	sl->size++;
}

void SLPopFront(SeqList* sl)
{
	if (sl == NULL)
	{
		return;
	}
	for (int start = 1; start < sl->size; ++start)
	{
		sl->arr[start - 1] = sl->arr[start];
	}
	sl->size--;
}

void SLInsert(SeqList* sl, int pos, SLDataTye val)
{
	if (sl == NULL)
	{
		return;
	}
	if (pos >= 0 && pos <= sl->size)
	{
		SLCheckCapicity(sl);
		int start = pos;
		int end = sl->size;
		while (start < end)
		{
			sl->arr[end] = sl->arr[end - 1];
			--end;
		}
		sl->arr[pos] = val;
		sl->size++;
	}
}

int SLFindIdx(SeqList* sl,SLDataTye val)
{
	for (int i = 0; i < sl->size; i++)
	{
		if (val == sl->arr[i])
		{
			return i;
		}
	}
	return -1;
}

以上就是关于数据结构之顺序表的全部内容，欢迎各位小伙伴提出建议，后期，博主会继续分享关于关于数据结构和编程的其他相关知识。