顺序表的理解与实现

1. 顺序表的概念。

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

2. 顺序表的分类；静态顺序表和动态顺序表的区别。

顺序表一般可以分为静态顺序表和动态顺序表。静态顺序表显然就是里面的内存是一定的，不能改变的，而动态顺序表则是动态分配内存空间，在现实中我们也更加常用动态顺序表。。

3.顺序表的优缺点。

 优点：
     （1）空间利用率高，数据是连续存放，命中率比较高 
     （2）存取速度高效，通过下标来直接访问。
 缺点：
     （1）插入和删除比较慢，在插入或者删除一个元素的时候，需要遍历整个顺序表移动前后的数据
     （2）需要预先分配足够大的空间，估计的过大，会导致顺序表后的大量空间被闲置；但是估计的过小，又会造成溢出。

下面就来实现动态顺序表吧。首先是头文件部分

#pragma once

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


typedef int DataType;

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


//创建顺序表
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 datda); 

// 任意位置删除 
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); 

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

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

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

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

接下来是各个函数的实现部分

#include"test.h"


//创建顺序表
void SeqListInit(PSeqList ps)
{
	assert(ps);
	ps->_capacity = 20;
	ps->_array = (DataType*)malloc(sizeof(SeqList)*ps->_capacity);
	ps->_size = 0;

}

//销毁顺序表
void SeqListDestroy(PSeqList ps)
{
	assert(ps);
	assert(ps->_array);
	free(ps->_array);
	ps->_array = NULL;
	ps->_size = 0;
	ps->_capacity = 0;

}

// 尾插 
void SeqListPushBack(PSeqList ps, DataType data)
{
	assert(ps);
	ps->_array[ps->_size] = data;
	ps->_size++;
}
// 尾删 
void SeqListPopBack(PSeqList ps)
{
	assert(ps);
	ps->_size--;	
}

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

// 任意位置删除 
void SeqListErase(PSeqList ps, int pos)
{
	assert(ps);
	for (int i = pos; i < ps->_size-1; i++)
	{
		ps->_array[i] = ps->_array[i + 1];
	}
	ps->_size--;
}

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

// 移除顺序表中第一个值为data的元素 
void SeqListRemove(PSeqList ps, DataType data)
{
	assert(ps);
	int pos = SeqListFind(ps, data);
	if (pos != -1)
	{
		SeqListErase(ps,pos);
	}
}

// 移除顺序表中所有值为data的元素 
void SeqListRemoveAll(PSeqList ps, DataType data)
{
	assert(ps);
	int j = 0;
	for (int i = 0; i < ps->_size; i++)
	{
		if (ps->_array[i] != data)
		{
			ps->_array[j] = ps->_array[i];
			j++;
		}
	}
	ps->_size = j;
}

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

// 获取顺序表的容量 
int SeqListCapacity(PSeqList ps)
{
	int i = sizeof(ps->_array) / sizeof(SeqList);
	return i;
}

// 检测顺序表是否为空 
int SeqListEmpty(PSeqList ps)
{
	if (ps->_size == 0)
	{
		return 1;
	}
	return -1;
}

// 获取顺序表中第一个元素 
DataType SeqListFront(PSeqList ps)
{
	assert(ps);
	return ps->_array[0];
}
// 获取顺序表中最后一个元素 
DataType SeqListBack(PSeqList ps)
{
	assert(ps);
	return ps->_array[ps->_size - 1];
}