c++数据结构：线性表的存储结构——顺序表

顺序表，表示线性表的存储结构为顺序存储，其在使用时会向内存中申请一段连续的存储单元，用单元的下标作为标记位置。其中，数据的类型由于不确定带来一定的数据类型定义需求，所以我们采用c++的模板来实现。

类模板的定义及相关函数的实现：

#pragma once
#include<iostream>
using namespace std;

const int Maxsize = 100;       //定义顺序表结构的长度

template<typename T>
class seqList
{
public:
seqList();     //构造函数
seqList(T a[],int n);     //构造函数
~seqList();    //析构函数
int seqLength() { return length; }     //求当前数组的长度
T seqGet(int n);     //按位查找,查找指定位置的元素
int seqLocate(T value);   //按值查找，查找指定值的序号
bool seqInsert(T value,int a);      //插入操作，在线性表中第i个位置插入值为x的元素
bool seqDelete(int a);      //删除操作，删除第i个元素
void seqTraverse();    //遍历操作
bool seqEmpty();        //判空
bool seqFull();      //判满
void  seqyuesefu( int m);   //约瑟夫问题
private:
T iArray[Maxsize];      //待指定类型的长度固定的数组
int length;                   //当前数组已存放元素的长度

};
template<typename T>
seqList<T>::seqList()         //无参的构造函数
{
length = 0;
}
template<typename T>
seqList<T>::seqList(T a[], int n)     /*带参的构造函数*/
{

for (int i = 0; i < n; i++)
{
iArray[i] = a[i];
}
length = n;
}
template<typename T>      /*析构函数*/
seqList<T>::~seqList()
{

}
template<typename T>
T seqList<T>::seqGet(int n)    /*按位查找，接收位置变量a，返回该元素为该下标的元素*/
{
return iArray
;
}
template<typename T>
int seqList<T>::seqLocate(T value)  /*按值查找，接收外部输入的值a，然后遍历该顺序表，若找到某一个匹配的值，则返回该元素的位置，缺点：若该表中有多个匹配的值，则之后返回第一个匹配值的位置，日后有需要可进一步优化*/
{
for (int i = 0; i < length; i++)
{
if (value == iArray[i])
{
return i+1;
}
}
cout << "未找到所输入的值" << endl;
}
template<typename T>
bool seqList<T>::seqInsert(T value, int a)    /*插入函数，接收外部变量（要插入的数的值，插入的位置），然后将要插入的位置以后的元素（包括该位置）向后移位，然后覆盖该位置的元素（此时该位置的元素已经依次后移），长度加一*/
{
if (seqFull())
{
return false;
}
if (a > Maxsize || a < 0)
{
return false;
}
for (int i =length; i > a-1; i--)
{
iArray[i] = iArray[i-1];
}
iArray[a-1] = value;
length++;
return true;
}
template<typename T>
bool seqList<T>::seqDelete(int a)     /*删除函数，输入某位置的元素，函数一次循环遍历，并将该位置上的元素覆盖，然后元素长度减一*/
{
if (seqEmpty())
{
return false;
}
if (a>Maxsize||a<1)
{
return false;
}
for (int i = a-1; i < length; i++)
{
iArray[i] = iArray[i+1];
}
length--;
return true;
}
template<typename T>
void seqList<T>::seqTraverse() /*遍历函数，依次循环顺序表中的元素，并将他们输出*/
{
for (int i = 0; i < length; i++)
{
cout << iArray[i] << ",";
}
}
template<typename T>           //判空队列，判断当前队列是否为空队列（没有存储元素）
bool seqList<T>::seqEmpty()
{
return length == 0 ? true : false;
}
template<typename T>        //判满队列，判断队列中的元素个数是否已达最大值
bool seqList<T>::seqFull()
{
return length == Maxsize ? true : false;
}
template<typename T>
void  seqList<T>::seqyuesefu(int m)       /*约瑟夫环问题，用顺序表解决约瑟夫问题*/
{
int out;
int b = 0;
cout << "原队列的数组顺序为" << endl;
seqTraverse();
cout << "出队顺序为：" << endl;
while (length>0)
{
if (length < m)
{
out = m%length - b;
while (out <= 0)
{
out += length;
}
cout << iArray[out - 1]<<",";
b = length - out;
seqDelete(out);
}
else if (length>=m)
{
if (b >= m)
{
out = length - b + m;
}
else if (b < m)
{
out = m-b;
}
cout << iArray[out - 1] << ",";
b = length - out;
seqDelete(out);
}
}
}

实例调用：

#include<iostream>
#include"seqList.h"
using namespace std;
int main()
{
int a[5] = {1,2,3,4,5};
seqList<int> iArra(a, 5);
iArra.seqInsert(2, 4);                   //插入函数成功
iArra.seqTraverse();                     //遍历函数测试成功
iArra.seqDelete(4);                      //删除函数
cout << endl;
iArra.seqTraverse();
cout<<endl<<iArra.seqLocate(4);               /*查找函数测试成功*/
cout << endl << "当前长度为：" << iArra.seqLength();       //返回长度函数调用成功
iArra.seqyuesefu(100);
return 0;
}

特点分析：按位查找时：时间复杂度是o(1);其余查找，插入，删除操作皆为0(n)

注意点：表中元素的长度的元素位置和下标并不是相等的，在写成员函数的时候需要特别注意，（第一位元素的下标为0）

关于顺序表暂时写这么多，有错误欢迎指正（及时改正），日后有则补充。