数据结构 线性结构之顺序表..

1.什么是线性结构？
简单说就是连续的一条直线.但是在物理结构上并不一定是连续的,
2. 线性结构的特点？
(1)存在唯一的一个被称作第一个的数据元素
(2)存在唯一的一个被称作最后一个的数据元素
(3)除第一个之外,集合中的每一个元素均只有一个前驱
(4)除最后一个元素外,集合中的每一个元素均只有一个后继
3. 什么是顺序表？顺序表的分类？
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储.在数组上完成数据的增删改查.
顺序表一般分为:
(1)静态顺序表:使用定长数组存储
(2)动态顺序表:使用动态开辟的数组存储
4. 完成动态顺序表的以下操作：
// 动态的顺序表
typedef int DataType;
typedef struct SeqList
{
DataType* _array;
int _capacity; // 顺序表的总大小
int _size; // 顺序表中有效元素的个数
}SeqList, *PSeq;

//typedef struct SeqList SeqList;
//typedef struct SeqList* PSeqList;

// 顺序表的初始化
void SeqListInit(PSeq ps, int capacity);

// 在顺序表的尾部插入值为data的元素
void SeqListPushBack(PSeq ps, DataType data);

// 删除顺序表最后一个元素
void SeqListPopBack(PSeq ps);

// 在顺序表的头部插入值为data的元素
void SeqListPushFront(PSeq ps, DataType data);

// 删除顺序表头部的元素
void SeqListPopFront(PSeq ps);

// 在顺序表pos位置插入值为data的元素
void SeqListInsert(PSeq ps, int pos, DataType data);

// 删除顺序表中pos位置上的元素
void SeqListErase(PSeq ps, int pos);

// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的下标，否则返回-1
int SeqListFind(PSeq ps, DataType data);

// 检测顺序表是否为空，如果为空返回非0值，非空返回0
int SeqListEmpty(PSeq ps);

// 返回顺序表中有效元素的个数
int SeqListSize(PSeq ps);

// 返回顺序表的容量大小
int SeqListCapacity(PSeq ps);

// 将顺序表中的元素清空
void SeqListClear(PSeq ps);

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

// 销毁顺序表
void SeqListDestroy(PSeq ps);

// 顺序表的扩容
void CheckCapacity(PSeq ps);

#pragma once

//顺序表结构:
//静态顺序表
#if 0
typedef int DataType;
#define MAX_SIZE 100

struct SeqList
{
	DataType _array[MAX_SIZE];  //用来存储顺序表中的元素
	int size;     //顺序表中有效元素的个数
};
#endif

//动态顺序表
typedef int DataType;
typedef struct SeqList
{
	DataType* _array;  
	int _capacity;     //顺序表总大小
	int _size;      //顺序表中有效元素的个数
}Seq,*PSeq;

void SeqInit(PSeq ps, int capacity);
void SeqPushBack(PSeq ps,DataType data);

int SeqEmpty(PSeq ps);
void SeqPopBack(PSeq ps);
void SeqPushFront(PSeq ps,DataType data);
void SeqPopFront(PSeq ps);
void SeqInsert(PSeq ps,int pos,DataType data);
void SeqErase(PSeq ps,int pos);
int SeqFind(PSeq ps, DataType data);
int SeqSize(PSeq ps);
int SeqCapacity(PSeq ps);
int SeqClear(PSeq ps);
void SeqRemove(PSeq ps, DataType data);
void SeqDestory(PSeq ps);
void CheckCapacity(PSeq ps);

#include "SeqList.h"
#include <malloc.h>
#include <stdio.h>
#include <assert.h>

void SeqInit(PSeq ps, int capacity)
{
	ps->_array = (DataType*)malloc(sizeof(DataType) * capacity);
	if (ps->_array == NULL) 
	{
		assert(0);
		return;
	}
	ps->_capacity = capacity;
	ps->_size = 0;
}

void SeqPushBack(PSeq ps, DataType data)
{
	assert(ps);
	//有可能顺序表已满CheckCapacity(ps)
	CheckCapacity(ps);
	ps->_array[ps->_size] = data;
	++ps->_size;
	 
}

int SeqEmpty(PSeq ps)
{
	assert(ps);
	return  0 == ps->_size;
}

void SeqPopBack(PSeq ps)
{
	assert(ps); 
	if (SeqEmpty(ps))
		return;
	--ps->_size;
}

void SeqPushFront(PSeq ps, DataType data)
{
	assert(ps);
	CheckCapacity(ps);
	//将顺序表中所有的元素向后移
	for (int i = ps->_size; i > 0; --i)
	{
		ps->_array[i] = ps->_array[i-1];
	}
	//插入元素
	ps->_array[0] = data;
	++ps->_size;
}

void SeqPopFront(PSeq ps)
{
	assert(ps);
	if (SeqEmpty(ps))
		return;
	for (int i = 1; i < ps->_size; ++i)
	{
		ps->_array[i - 1] = ps->_array[i];
	}
	--ps->_size;
}

void SeqInsert(PSeq ps,int pos, DataType data)
{
	assert(ps);
	CheckCapacity(ps);
	if (pos<0 || pos>ps->_size)
		return;
	for (int i = ps->_size - 1; i >= pos; --i)
		ps->_array[i + 1] = ps->_array[i];
	ps->_array[pos] = data;
	++ps->_size;
}

void SeqErase(PSeq ps,int pos)
{
	assert(ps);
	if (pos<0||pos>ps->_size)
		return;
	for (int i = pos; i < ps->_size; ++i)
	{
		ps->_array[i - 1] = ps->_array[i];
	}
	--ps->_size;
}

int SeqFind(PSeq ps, DataType data)
{
	assert(ps);
	for (int i = 0; i < ps->_size - 1; ++i)
	{
		if (ps->_array[i] == data)
			return i;
	}
	return -1;
}

int SeqSize(PSeq ps)
{
	assert(ps);
	return ps->_size;
}

int SeqCapacity(PSeq ps)
{
	assert(ps);
	return ps->_capacity;
}

int SeqClear(PSeq ps)
{
	assert(ps);
	return ps->_size == 0;
}

void SeqRemove(PSeq ps, DataType data)
{
	SeqErase(ps, SeqFind(ps, data));
} 
	

void SeqDestory(PSeq ps)
{
	if (ps->_array)
	{
		free(ps->_array);
		ps->_array = NULL;
		ps->_capacity = 0;
		ps->_size = 0;
	}
}

void CheckCapacity(PSeq ps)
{
	assert(ps);
	if (ps->_size == ps->_capacity)
	{
		//顺序表中已经没有空间
		int newCapacity = ps->_capacity * 2;
		//申请新空间
		int* pTmp = (DataType*)malloc(sizeof(DataType) * newCapacity);
		if (pTmp == NULL)
		{
			assert(0);
			return;
		}
		//拷贝元素
		for (int i = 0; i < ps->_size; ++i)
		{
			pTmp[i] = ps->_array[i];
		}
		//释放旧空间
		free(ps->_array);
		//更新元素
		ps->_array = pTmp;
		ps->_capacity = newCapacity;
	}

}