线性表

具有相同数据类型的n个数据元素的有限序列
数据元素可以仅仅是数组，也可以是自定义数据类型

线性表可以分两类：

顺序表

地址连续，类似数组，拥有下标，插入和删除元素时需要移动数据元素。
前驱，后继：当前元素的前一个和后一个元素，有且仅有一个

class List
{
public:
	List(int size);	//创建线性表
	~List();		//析构清除指针
	void ClearList();	//清空线性表
	bool ListEmpty();	//判空
	int ListLength();	//表长度
	bool GetElem(int i, int *e);	//获取特定值元素
	int LocateElem(int *e); 		//定位元素
	bool PriorElem(int *currentElem, int *preElem); 	//前驱元素
	bool NextElem(int *currentElem, int *nextElem); 	//后继元素
	void ListTraverse(); 			//遍历
	bool ListInsert(int i, int *e);		//插入
	bool ListDelete(int i, int *e);		//删除
private:
	int *m_pList;//更改类型来存储不同数据类型，也可使用模板类
	int m_iSize;
	int m_iLength;
};

List::List(int size){
	m_iSize = size;
	m_pList = new int[m_iSize];
	m_iLength = 0;
}

List::~List(){
	delete[]m_pList;
	m_pList = NULL;
}

void List::ClearList(){
	m_iLength = 0;
}

bool List::ListEmpty(){		//C语言没有bool类型，大写的BOOL是人为的宏定义
	if (m_iLength == 0)
		return true;
	else
		return false;
	//return m_iLength==0? true:false
}

int List::ListLength(){
	return m_iLength;
}

bool List::GetElem(int i, int *e){
	if (i < 0 || i >= m_iLength)
	{
		return false;
	}
	*e = m_pList[i];
	return true;
}

int List::LocateElem(int *e){
	for (int i = 0; i < m_iLength; i++){
		if (m_pList[i] == *e)
			return i;
	}
	return -1; 		//不存在
}

bool List::PriorElem(int *currentElem, int *preElem){
	int temp = LocateElem(currentElem);
	if (temp == -1)
		return false;
	else if(temp==0)//当前为第一个元素，无前驱
		return false;
	else{
		*preElem=m_pList[temp - 1];
		return true;
	}
}

bool List::NextElem(int *currentElem, int *nextElem){
	int temp = LocateElem(currentElem);
	if (temp == -1)
		return false;
	else if (temp == m_iLength-1)//当前为最后一个元素，无后继
		return false;
	else{
		*nextElem = m_pList[temp + 1];
		return true;
	}
}

void List::ListTraverse(){
	for (int i = 0; i < m_iLength; i++){
		cout<<m_pList[i]<<" ";
		//m_pList[i].printCoordinate();
	}
}

bool List::ListInsert(int i, int *e)
{
	if (i < 0 || i >m_iLength) 	//=的情况允许，视为插入最后一个元素
		return false;
	for (int k=m_iLength-1; k>=i; k--){		//依次向后赋值，从最后开始，避免覆盖
		m_pList[k + 1] = m_pList[k];
	}
	m_pList[i] = *e;
	m_iLength++;
	return true;
}

bool List::ListDelete(int i, int *e){
	if (i<0 || i>=m_iLength){ 	//无=情况，没有下一个元素
		return false;
	}
	*e = m_pList[i];
	for (int k = i + 1; k < m_iLength; k++){	//依次向前赋值，从最前开始
		m_pList[k - 1] = m_pList[k];
	}
	m_iLength--;
	return true;
}

链表

不需要地址连续的存储单元，通过链建立元素之间的逻辑关系，插入删除操作不需要移动数据元素。有单链表，循环链表，双向链表。