C++线性表之顺序表和单链表

//顺序线性表的头文件
#include<iostream>

const int MaxSize = 100;
//定义顺序表SeqList的模板类
template<class DataType>
class SeqList {
public:
//顺序表无参构造器（创建一个空的顺序表）
SeqList() { length = 0 }
//顺序表有参构造器（创建一个长度为n的顺序表）
SeqList(DataType array[], int n);
//顺序表析构函数
~SeqList() {}
//求顺序表的长度
int GetLength() { return length; }
//顺序表按位查找，返回i位置的元素
DataType GetElement(int i);
//顺序表按值查找，返回该元素所在的位置
int GetLocal(DataType x);
//顺序表在指定的位置插入指定的元素
void Insert(int i, DataType x);
//顺序表删除元素，返回删除的元素
DataType Delete(int i);
//输出顺序表中的元素
void PrintSeqList();
private:
//一维数组，存放数据元素
DataType data[MaxSize];
//顺序表的长度
int length;
};

//实现单链表的头文件内容

template<class DataType>
struct Node
{
//数据域，存放该结点的数据
DataType data;
//指针域，指向下一个结点
Node<DataType> *next;
};

template<class DataType>
class LinkedList {
public:
//单链表无参构造器
LinkedList();
//单链表有参构造器
LinkedList(DataType array[], int n);
LinkedList(int n, DataType array[]);
//单链表析构函数
~LinkedList();
//获取单链表的长度
int GetLength();
//查找单链表指定元素的序号
int GetLocal(DataType x);
//获取单链表指序号的元素
DataType GetElement(int index);
//单链表中在指定位置插入指定的元素
void Insert(int index, DataType x);
//在单链表中删除指定位置的元素
DataType Delete(int index);
//按序号输出单链表中的元素
void PrintLinkedList();

private:
//声明单链表的头指针
Node<DataType> *first;
};

#include "SeqList.h";
#include<iostream>
using namespace std;

//实现顺序表有参构造器
template<class DataType>
SeqList<DataType>::SeqList(DataType array[], int n)
{
if (n > MaxSize)
{
throw "传入的顺序表长度过长";
}
//给顺序表的存储元素的数组赋值
for (int i = 0; i < n; i++)
{
data[i] = array[i];
}
//给顺序表的长度赋值
length = n;
}

//实现顺序表按位查找
template<class DataType>
DataType SeqList<DataType>::GetElement(int i)
{
//判断是定的位置是否合理
if (i < 1 || i >length)
{
throw "位置有误";
}
else
{
//返回指定位置的元素
return data[i - 1];
}
}

//实现顺序表按值查找,返回该元素所在的位置
template<class DataType>
int SeqList<DataType>::GetLocal(DataType x)
{
//遍历顺序表的元素
for (int i = 0; i < length; i++)
{
//判断指定的元素是否在顺序表中
if (data[i] == x)
{
//返回指定元素在顺序表中的位置
return (i + 1);
}
}
//如果指定的元素不在顺序表中，则返回位置为0
return 0;
}

//实现顺序表插入元素
template<class DataType>
void SeqList<DataType>::Insert(int index, DataType x)
{
//判断插入的位置是否合理
if (length >= MaxSize)
{
throw "顺序表已存放满";
}
if (index<1 || index>length + 1)
{
throw "插入元素的位置有误";
}
//如何插入的位置合理，则把顺序表中从最后位置到指定插位置的元素整体向后移动一个位置
for (int j = length; j >= index; j--)
{
data[j] = data[j - 1];
}
//给插入的位置放入指定的元素
data[index - 1] = x;
length++;
}

//实现顺序表删除指定位置的元素
template<class DataType>
DataType SeqList<DataType>::Delete(int index)
{
//声明要取出的元素
DataType x;
//判断要删除的位置是否合理
if (index<1 || index>length)
{
throw "删除的位置有误";
}
else
{
//取出指定位置的元素
x = data[index - 1];
//将指定位置后的元素全部都向前移动一个位置
for (int i = index; i < length; i++)
{
data[i - 1] = data[i];
}
//删除顺序表中的元素后，其长度减1
length--;
}
return x;
}

//顺序输出顺序表中的元素
template<class DataType>
void SeqList<DataType>::PrintSeqList()
{
if (length < 1)
{
throw "顺序表中没有元素";
}
else
{
//顺序输出顺序表元素
for (int i = 0; i < length; i++)
{
cout << data[i] << " ";
}
cout << endl;
}
}

//实现单链表的程序

template<class DataType>
LinkedList<DataType>::LinkedList()
{
first = new Node<DataType>;
first->next = NULL;
}

//头插法建立单链表
template<class DataType>
LinkedList<DataType>::LinkedList(int n, DataType array[])
{
//初始化一个空链表
first = new Node<DataType>;
first->next = NULL;
for (int i = 0; i < n; i++)
{
//为每一个数组元素都申请新结点
Node<DataType> *s = new Node<DataType>;
//数组元素赋值给结点数据域
s->data = array[i];
//将结点插入到头结点之前
s->next = first->next;
first->next = s;

}
}

//尾插法建立单链表
template<class DataType>
LinkedList<DataType>::LinkedList(DataType array[], int n)
{
//生成头结点
first = new Node<DataType>;
//定义尾结点
Node<DataType> *r = first;
for (int i = 0; i < n; i++)
{
//为每一个数组元素申请一个结点
Node<DataType> *s = new Node<DataType>;
//把数组元素赋值给结点的数据域
s->data = array[i];
//将每一个结点追加到终端结点之后
r->next = s;
r = s;
}
//尾结点尾NULL
r->next = NULL;
}

//实现单链表的析构函数
template<class DataType>
LinkedList<DataType>::~LinkedList()
{
//声明工作指针
Node<DataType> *q;
while (first != NULL)
{
//暂存被释放的结点
q = first;
//让头指针指向要释放结点的下一个结点
first = first->next;
delete q;
}
}

//实现单链表插入:在指定的位置插入指定的元素
template<class DataType>
void LinkedList<DataType>::Insert(int index, DataType x)
{
//定义工作指针
Node<DataType> *p = first->next;
//定义计数器，初始值为0
int count = 0;
while (p != NULL &&count < index - 1)
{
//工作指针后移
p = p->next;
count++;
}
//找到 index-1 的位置
if (p == NULL)
{
throw "插入的位置有误";
}
else
{
//申请一个新结点
Node<DataType> *s;
s = new Node<DataType>;
//其数据域为 x
s->data = x;
//在新结点的指针域存放工作指针p的指针域
s->next = p->next;
//将结点s插入到p结点之后
p->next = s;
}
}

//实现单链表的按值查找，返回指定元素在单链表中的序号（如不存在，则返回0）
template<class DataType>
int LinkedList<DataType>::GetLocal(DataType x)
{
//定义工作指针
Node<DataType> *p = first->next;
//定义计数器，初始值是1
int count = 1;
//查找序号所对应的位置
while (p != NULL)
{
if (p->data == x)
{
return count;
}
//工作指针后移
p = p->next;
//计数器加1
count++;
}
//如果找不到该元素，则返回0
return 0;
}

//实现单链表按位查找，返回指定位置的元素
template<class DataType>
DataType LinkedList<DataType>::GetElement(int index)
{
//定义工作指针
Node<DataType> *p = first->next;
//定义计数器，初始值是1
int count = 1;
//查找序号所对应的位置
while (p != NULL&&count < index)
{
//工作指针后移
p = p->next;
//计数器加1
count++;
}
//如果找到单链表的末尾，还找不到指定的位置，则抛出异常
if (p == NULL)
{
throw "查找的位置有误";
}
else
{
//当找到合适的位置时，返回该位置上的元素
return p->data;
}

}

//实现获取单链表的长度
template<class DataType>
int LinkedList<DataType>::GetLength()
{
//定义计数器，用来计算单链表的长度
int count = 0;
//定义工作指针
Node<DataType> *p = first->next;
while (p != NULL)
{
p = p->next;
count++;
}
return count;

}

//实现单链表的按序号输出元素
template<class DataType>
void LinkedList<DataType>::PrintLinkedList()
{
//声明工作指针
Node<DataType> *p;
//初始化工作指针
p = first->next;
while (p != NULL)
{
cout << p->data << " ";
//工作指针向后移动
p = p->next;
}
cout << endl;
}

//实现单链表的删除
template<class DataType>
DataType LinkedList<DataType>::Delete(int index)
{
Node<DataType> *p = first->next;
int count = 0;
//查找第 index-1 位置结点
while (p != NULL&&count < index - 1)
{
p = p->next;
count++;
}
//如果能找到
if (p == NULL || p->next == NULL)
{
throw "删除的位置有误";
}
else
{
Node<DataType> *q = p->next;
DataType x = q->data;
p->next = q->next;
delete q;
return x;
}
}

#include<iostream>
#include"SeqList.cpp"
using namespace std;
void show()
{
cout << "---------------------------------------" << endl;
}
int main()
{
int array[10] = { 1,3,4,2,5,6,8,7,9,10 };
SeqList<int> seqList = SeqList<int>(array, 10);
cout << "顺序表为：" << endl;
seqList.PrintSeqList();
show();
cout << "顺序表的长度为：" << seqList.GetLength() << endl;
cout << "第三个位置的元素是：" << seqList.GetElement(3) << endl;
cout << "元素3的位置是：" << seqList.GetLocal(3) << endl;
show();
cout << "在第5个位置插入元素22" << endl;
seqList.Insert(5, 22);
cout << "顺序表为：" << endl;
seqList.PrintSeqList();
cout << "顺序表的长度为：" << seqList.GetLength() << endl;
show();
cout << "删除第5个位置的元素" << endl;
seqList.Delete(5);
cout << "顺序表为：" << endl;
seqList.PrintSeqList();
cout << "顺序表的长度为：" << seqList.GetLength() << endl;
show();

//单链表测试

LinkedList<int> linkedList = LinkedList<int>(10, array);
cout << "输出单链表：" << endl;
linked
9f56
List.PrintLinkedList();
show();
cout << "单链表的长度:" << linkedList.GetLength() << endl;
cout << "单链表中第5个元素是：" << linkedList.GetElement(5) << endl;
cout << "单链表中元素5的位置是：" << linkedList.GetLocal(5) << endl;
show();
cout << "在单链表的第5个位置上插入元素22" << endl;
linkedList.Insert(5, 22);
cout << "输出单链表：" << endl;
linkedList.PrintLinkedList();
cout << "单链表的长度:" << linkedList.GetLength() << endl;
show();
cout << "删除第5位置的元素" << endl;
linkedList.Delete(5);
cout << "输出单链表：" << endl;
linkedList.PrintLinkedList();
cout << "单链表的长度:" << linkedList.GetLength() << endl;
show();
return 0;
}