【数据结构】线性表中的顺序表

线性表中的顺序表

线性表

线性表是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物
理上存储时，通常以数组和链式结构的形式存储。
上图：

顺序表

概念：顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组
上完成数据的增删查改。
顺序表的优缺点：
优点:
1.空间l连续，利用率高。（局部性原理，连续存放，命中率高）
2.支持随机访问（通过下标进行查找，时间复杂度为O(1)
缺点：
1.中间或前面部分的插入删除时较为复杂，插入或者删除一个元素时，整个表需要遍历移动元素来重新排一次顺序。
2.当空间不够时，使用增容来解决此问题，可能导致元素个数远少于分配的空间大小，空间浪费巨大。
顺序表的结构和基本操作：

1. 静态顺序表：使用定长数组存储。

静态顺序表
#define maxsize 9
struct SeqList
{
	DataType array[MAXSIZE]; // 保存顺序表中有序元素 
	int size; // 顺序表中有效元素的个数 
};

静态顺序表，空间大小固定，提前规定空间大小，代码实际运行中才知道其元素个数，当其元素个数大于空间最大容量时，存在问题
2. 动态顺序表：使用动态开辟的数组存储。

typedef int DataType;

typedef struct SeqList
{
	DataType* _array; // 保存顺序表中有效元素个数 
	int _capacity; // 空间总大小 
	int _size; // 有效元素个数 
}SeqList, *PSeqList;

根据其元素个数动态开辟内存大小，内存不够则进行增容。
基本操作
1.首先实现顺序表的初始化，主要完成数组空间的申请，容量置成LISTMAX，数组中元素个数置空，代码如下：

////初始化
#define LISTMAX 3
void SeqListInit(PSeqList ps)
{
	assert(ps);  断言ps指针是否存在
	//申请动态内存的空间
	ps->_array = (DataType*)malloc(LISTMAX * sizeof(DataType));
	//判断内存空间是否申请成功
	if (ps->_array == NULL)
	{
		return;
	}
	ps->_capacity = LISTMAX;
	ps->_size = 0;
}

2.增容函数，当数组中元素个数size和容量capacity相等时，进行增容。
若使用malloc增容，则要：
①先申请新空间
②将旧空间元素拷入新空间
③释放旧空间，将数组重新指向新空间，重置capacity的值
也可使用realloc增容，则更加简单，代码如下：

void SeqListNEWCapacity(PSeqList ps)
{
	assert(ps);
	if (ps->_size == ps->_capacity)//内存已满
	{
		DataType* str = (DataType*)malloc(LISTMAX * sizeof(DataType)* 2);
		if (str != NULL)
		{
			memcpy(str, ps->_array, LISTMAX * sizeof(DataType));
			free(ps->_array);
			ps->_array = str;
			str = NULL;
			ps->_capacity  *= 2;
			printf("增容成功\n");
		}
		else
		{
			printf("增容失败\n");
			return;
		}
	}
}

3.尾插，尾删则比较简单，尾插则ps->_array[ps->_size] = data;然后ps->size++，尾删则ps->size–就可。代码可查看博客最后面附的完整代码。
4.头插，头删数据则需要进行移动，也是顺序表的麻烦之处，如图

头删如图：

代码如下：

//头插
void SeqListPushFront(PSeqList ps, DataType data)
{
	assert(ps);
	SeqListNEWCapacity(ps);
	int i = ps->_size ;
	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);
	for (int i = 1; i < ps->_size; i++)
	{
		ps->_array[i - 1] = ps->_array[i];
	}
	(ps->_size)--;
}

任意位置插入删除，原理和头插头删基本相似，循环起始位置不同，代码如下：

//在任意位置插入
void SeqListInsert(PSeqList ps, int pos, DataType data)
{
	assert(ps);
	int i = ps->_size;
	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)
{
	int i = pos + 1;
	for (i = pos + 1 ; i < ps->_size; i++)
	{
		ps->_array[i - 1] = ps->_array[i];
	}
	(ps->_size)--;
}

以上便是顺序表的基本操作.，还有一些简单操作就不一一说明了。
完整代码附下：
SeqList.h

#define _CRT_SECURE_NO_WARNINGS
#define LISTMAX 3 
#include<assert.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
/* 静态顺序表
struct SeqList
{
	DataType array[MAXSIZE]; // 保存顺序表中有序元素 
	int size; // 顺序表中有效元素的个数 
};
*/
typedef int DataType;

typedef struct SeqList
{
	DataType* _array; // 保存顺序表中有效元素个数 
	int _capacity; // 空间总大小 
	int _size; // 有效元素个数 
}SeqList, *PSeqList;

//typedef struct SeqList SeqList; 
//PSeqList 结构体指针ps
//DataType data 加入元素的数据类型
void SeqListInit(PSeqList ps);
void SeqListDestroy(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);

// 检测data释放在顺序表中 
int SeqListFind(PSeqList ps, DataType data);

// 移除顺序表中第一个值为data的元素 
void SeqListRemove(PSeqList ps, DataType data);

// 移除顺序表中所有值为data的元素 
void SeqListRemoveAll(PSeqList ps, DataType data);

// 获取顺序表有效元素个数 
int SeqListSize(PSeqList ps);
//顺序表增容
void SeqListNEWCapacity(PSeqList ps);

// 获取顺序表的容量 
int SeqListCapacity(PSeqList ps);

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

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

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

SeqList.c

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"
////初始化
void SeqListInit(PSeqList ps)
{
	assert(ps);
	//申请动态内存的空间
	ps->_array = (DataType*)malloc(LISTMAX * sizeof(DataType));
	//判断内存空间是否申请成功
	if (ps->_array == NULL)
	{
		return;
	}
	ps->_capacity = LISTMAX;
	ps->_size = 0;
}
void SeqListDestroy(PSeqList ps)//销毁使用过的内存空间
{
	assert(ps);
	free(ps->_array);
	ps->_array = NULL;
	ps->_capacity  = 0;
	ps->_size = 0;
	
}
// 尾插 
//size为有效元素的个数
void SeqListPushBack(PSeqList ps, DataType data)
{
	assert(ps);
	SeqListNEWCapacity(ps);
	ps->_array[ps->_size] = data;
	(ps->_size)++;
}
// 尾删 
void SeqListPopBack(PSeqList ps)
{
	assert(ps);
	(ps->_size)--;
}
//头插
void SeqListPushFront(PSeqList ps, DataType data)
{
	assert(ps);
	SeqListNEWCapacity(ps);
	int i = ps->_size ;
	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);
	for (int i = 1; i < ps->_size; i++)
	{
		ps->_array[i - 1] = ps->_array[i];
	}
	(ps->_size)--;
}
//打印函数
void PrintSeqList(PSeqList ps)
{
	int i = 0;
	for (i = 0; i < ps->_size; i++)
	{
		printf("%d ", ps->_array[i]);
	}
	printf("\n");
}
//在任意位置插入
void SeqListInsert(PSeqList ps, int pos, DataType data)
{
	assert(ps);
	int i = ps->_size;
	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)
{
	int i = pos + 1;
	for (i = pos + 1 ; i < ps->_size; i++)
	{
		ps->_array[i - 1] = ps->_array[i];
	}
	(ps->_size)--;
}
//顺序表增容
void SeqListNEWCapacity(PSeqList ps)
{
	assert(ps);
	if (ps->_size == ps->_capacity)//内存已满
	{
		DataType* str = (DataType*)malloc(LISTMAX * sizeof(DataType)* 2);
		if (str != NULL)
		{
			memcpy(str, ps->_array, LISTMAX * sizeof(DataType));
			free(ps->_array);
			ps->_array = str;
			str = NULL;
			ps->_capacity  *= 2;
			printf("增容成功\n");
		}
		else
		{
			printf("增容失败\n");
			return;
		}
	}

}
// 检测data释放在顺序表中 
int SeqListFind(PSeqList ps, DataType data)
{
	int i = 0;
	for (i = 0; i < ps->_size; i++)
	{
		if (ps->_array[i] == data)
		{
			return i;
		}
	}
}
// 获取顺序表的容量 
int SeqListCapacity(PSeqList ps)
{
	return ps->_capacity;
}

// 检测顺序表是否为空 
int SeqListEmpty(PSeqList ps)
{
	if (0 == ps->_size)
	{
		return NULL;
	}
	return;
}
// 获取顺序表中第一个元素 
DataType SeqListFront(PSeqList ps)
{
	return ps->_array[0];
}

// 获取顺序表中最后一个元素 
DataType SeqListBack(PSeqList ps)
{
	return ps->_array[ps->_size-1];
}
// 移除顺序表中第一个值为data的元素 
void SeqListRemove(PSeqList ps, DataType data)
{
	int i = 0;
	for (; i < ps->_size; i++)
	{
		if (ps->_array[i] == data)
		{
			for (int j = i + 1; j <= ps->_size; j++)
			{
				ps->_array[j - 1] = ps->_array[j];
			}
		}
	}
	(ps->_size)--;
}
// 移除顺序表中所有值为data的元素 
void SeqListRemoveAll(PSeqList ps, DataType data)
{

	int i = 0; int count = 0;
	for (; i < ps->_size; i++)
	{
		if (ps->_array[i] == data)
		{
			count++;
		}
		else
			ps->_array[i - count] = ps->_array[i];
	}
	ps->_size -= count;
}
// 获取顺序表有效元素个数 
int SeqListSize(PSeqList ps)
{
	assert(ps);
	int count = 0;
	for (int i = 0; i < ps->_size; i++)
	{
		count++;
	}
	return count;
}

main.c

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"
void test()
{
	SeqList s;
	SeqListInit(&s);
	////顺序表增容
	//SeqListNEWCapacity(&s);
	// 尾插
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 5);
	SeqListPushBack(&s, 8);
	PrintSeqList(&s);
	// 尾删 
	SeqListPopBack(&s);
	PrintSeqList(&s);
	//头插
	SeqListPushFront(&s, 2);
	PrintSeqList(&s);
 //   头删
	SeqListPopFront(&s);
	PrintSeqList(&s);
	//所存在元素个数
	printf("%d \n", SeqListSize(&s));
	//任意位置插入
	SeqListInsert(&s, 2, 3);
	PrintSeqList(&s);
	//任意位置删除
	SeqListErase(&s,2);
	PrintSeqList(&s);
	//查找元素
	printf("寻找到的元素下标为%d \n",SeqListFind(&s, 5));
	// 获取顺序表的容量 
	SeqListCapacity(&s);
	printf("顺序表的容量%d \n", SeqListCapacity(&s));
	// 检测顺序表是否为空 
	SeqListEmpty(&s);
	// 获取顺序表中第一个元素 
	printf("顺序表中第一个元素%d \n", SeqListFront(&s));
	// 获取顺序表中最后一个元素 
	printf("顺序表中最后一个元素%d \n", SeqListBack(&s));
	//移除顺序表中的第一个data
	SeqListRemove(&s, 5);
	PrintSeqList(&s);
	// 移除顺序表中所有值为data的元素 
	SeqListRemoveAll(&s, 5);
	PrintSeqList(&s);
	SeqListDestroy(&s);
}
int main()
{
	test();
	system("pause");
	return 0;
}