#include<iostream>
#include<assert.h>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
typedef int DataType;
class SeqList
{
friend ostream& operator<<(ostream&, const SeqList&);
public:
// 默认构造函数
SeqList() :pdata(new DataType[1]), size(0), capacity(1) {}
// 构造函数:用于另一个数组的拷贝初始化
SeqList(DataType* p, int size) :pdata(new DataType[size]), size(size), capacity(size)
{
copy(p, p + size, pdata);
//for (size_t i = 0; i != size; ++i)
// pData[i] = p[i];
}
SeqList(initializer_list<DataType> ls)
{
auto sz = ls.end() - ls.begin();
pdata = new DataType[sz];
size_t index = 0;
for (auto i = ls.begin(); i != ls.end(); ++i)
pdata[index++] = *i;
size = capacity = sz;
}
// 拷贝构造函数
SeqList(const SeqList& sl)
{
size_t sz = sl.Size();
pdata = new DataType[sz];
copy(sl.pdata, sl.pdata + sz, pdata);
//for (size_t i = 0; i != sz; ++i)
// pdata[i] = sl.pdata[i];
size = capacity = sz;
}
SeqList& operator= (const SeqList& sl)
{
auto sz = sl.Size();
DataType* newdata = new DataType[sz];
for (size_t i = 0; i != sz; ++i)
newdata[i] = sl.pdata[i];
free();
pdata = newdata;
size = capacity = sz;
return *this;
}
~SeqList()
{
free();
}
public:
void print()const;
void push_back(const DataType& data);
void pop_back();
void push_front(const DataType& data);
void pop_front();
void insert(int pos, const DataType&);
int find(const DataType&)const;
void erase(int pos);
void sort();
void clean();
bool empty()const { return !size; }
size_t Size()const { return size; }
size_t Capacity()const { return capacity; }
DataType& operator[](int index) { assert(index >= 0 && index <= size - 1); return pdata[index]; }
const DataType& operator[](int index)const { assert(index >= 0 && index <= size - 1); return pdata[index]; }
DataType& Front() { assert(size > 0); return pdata[0]; }
const DataType& Front()const { assert(size > 0); return pdata[0]; }
DataType& Back() { assert(size > 0); return pdata[size - 1]; }
const DataType& Back()const { assert(size > 0); return pdata[size - 1]; }
private:
DataType* pdata;
int size;
int capacity;
void CheckCapacity();
void free()
{
delete[] pdata;
size = capacity = 0;
}
};
inline void SeqList::clean() // 清空顺序表
{
size = 0;
}
inline void SeqList::CheckCapacity()
{
if (size == capacity)
{
DataType* newdata = new DataType[size ? size * 2 : 1];
copy(pdata, pdata + size, newdata);
delete[] pdata;
pdata = newdata;
capacity = size ? size * 2 : 1;
cout << "增容成功" << endl;
}
}
inline void SeqList::print()const
{
if (size > 0)
{
for (size_t i = 0; i != size; ++i)
{
cout << pdata[i] << " ";
}
cout << endl;
}
else
cout << "顺序表为空" << endl;
}
inline void SeqList::push_back(const DataType& data)
{
CheckCapacity();
pdata[size] = data;
size++;
}
inline void SeqList::push_front(const DataType& data)
{
CheckCapacity();
for (int i = size - 1; i >= 0; --i)
{
pdata[i + 1] = pdata[i];
}
pdata[0] = data;
++size;
}
inline void SeqList::pop_back()
{
assert(size >= 1);
--size;
}
inline void SeqList::pop_front()
{
assert(size >= 1);
for (int i = 0; i < size - 1; ++i)
pdata[i] = pdata[i + 1];
--size;
}
inline void SeqList::insert(int index, const DataType& data)
{
assert(index >= 0 && index <= size);
CheckCapacity();
for (int i = size - 1; i >= index; --i)
pdata[i + 1] = pdata[i];
pdata[index] = data;
++size;
}
int SeqList::find(const DataType& data)const
{
assert(size > 0);
for (size_t i = 0; i != size; i++)
{
if (pdata[i] == data)
return i;
}
return -1;
}
void SeqList::erase(int pos)
{
assert(size && pos >= 0 && pos <= size - 1);
for (int i = pos; i < size - 1; ++i)
pdata[i] = pdata[i + 1];
--size;
}
void SeqList::sort()
{
for (int i = 0; i < size - 1; ++i)
{
int flag = 0;
for (int j = 0; j < size - i - 1; ++j)
{
if (pdata[j] > pdata[j + 1])
{
flag = 1;
DataType tmp = pdata[j];
pdata[j] = pdata[j + 1];
pdata[j + 1] = tmp;
}
}
if (!flag)
break;
}
}
ostream& operator<<(ostream& os, const SeqList& sl)
{
for (size_t i = 0; i != sl.size; ++i)
os << sl.pdata[i] << " ";
return os;
}
int main()
{
SeqList s;
s.push_back(1);
s.push_back(2);
s.push_back(3);
s.push_back(4);
s.push_back(5);
s.print();
s.pop_front();
s.pop_back();
cout << s[1];
s.print();
s.push_front(6);
s.push_front(7);
s.sort();
s.print();
s.erase(s.find(6));
s.print();
SeqList s2(s);
s2.push_back(0);
s2.print();
s.print();
s = s2;
s.print();
return 0;
}
写在前面,看一看。
1.线性表
线性表(linear list)是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构,常见的线性表:顺序表、链表、栈、队列、字符串...
线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的, 线性表在物理上存储时,通常以数组和链式结构的形式存储。
静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了,空间开多了浪费,开少了不够用。所以现实中基本都是使用动态顺序表,根据需要动态的分配空间大小。
顺序表的优缺点
1. 中间/头部的插入删除,由于物理存储为内存中连续存储,所以需要移动数据。时间复杂度为O(N),:即在头部或中间添加数据效率低下。
2. 增容需要申请新空间,拷贝数据,释放旧空间。会有不小的消耗。 (性能消耗)
3. 增容一般是呈2倍的增长,势必会有一定的空间浪费。例如当前容量为128,满了以后增容到 256,我们再继续插入了5个数据,后面没有数据插入了,那么就浪费了123个数据空间。
由上述三点,也就引出了线性表中的链表结构
顺序表的优点在于随机访问,即上方代码中的operator[],在一些算法中这一特点非常重要。