顺序表类：class SeqList

//顺序表，不是字符串没'\0'
//默认4个，增删6个，查找，打印，容量检测

#pragma once

#include <iostream>
#include <assert.h>
using namespace std;

typedef int DataType;

class SeqList
{
public:

	SeqList()
		:_arr(NULL)
		,_capacity(0)
		,_size(0)
	{}

	~SeqList()
	{
		Release();
	}
	
	//拷贝构造没有带参构造借用所以不能写现代写法
	SeqList(const SeqList& s)
	{	
		//不拷贝多余空间
		_arr = new DataType[s._size];	//开 s._size 个 DataType 类型的空间	
		memcpy(_arr, s._arr, s._size*sizeof(DataType));
		_size = _capacity = s._size;

	}

	SeqList& operator=(SeqList s)
	{
		swap(_arr, s._arr);
		swap(_size, s._size);
		swap(_capacity, s._capacity);
		return *this;
	}
	
	void Release()
	{
		if(_arr)
		{
			delete[] _arr;
			_size = _capacity = 0;
			_arr = NULL;
		}
	}
	
	void CheckCapacity();

	void PushBack(DataType x);
	void PushFront(DataType x);
	void Insert(size_t pos, DataType x);
	void PopBack();
	void PopFront();
	void Erase(size_t pos);
	
	void Print();
	size_t Find(DataType x);	//返回第一个下标

private:
	DataType* _arr;
	size_t _size;
	size_t _capacity;
};

void SeqList::CheckCapacity()
{
	if(_size == _capacity)
	{
		_capacity = _capacity*2+1;
		_arr = (DataType*)realloc(_arr, _capacity*sizeof(DataType));
		
	}
}

void SeqList::Print()
{
	size_t i = 0;
	for(i=0; i<_size; i++)
	{
		cout<<_arr[i]<<" ";
	}
	cout<<endl;
}

void SeqList::Insert(size_t pos, DataType x)
{
	assert(pos <= _size);
	CheckCapacity();
	int end = _size - 1;	//防止_size为0时候end是最大正数
	while(end >= (int)pos)
	{
		_arr[end+1] = _arr[end];
		--end;
	}
	_arr[pos] = x;
	++_size;
}

void SeqList::PushBack(DataType x)
{
	Insert(_size, x);
}

void SeqList::PushFront(DataType x)
{
	Insert(0, x);
}

void SeqList::Erase(size_t pos)
{
	assert(pos < _size); //pos为正数，附带检查了_size不为0
	//尽量别挪pos，因为如果动了以后可能会用到的时候就找不到了
	for(size_t i = pos; i<_size; i++)
	{
		_arr[i] = _arr[i+1];
	}
	--_size;
}

void SeqList::PopBack()
{
	Erase(_size-1);
}

void SeqList::PopFront()
{
	Erase(0);
}

size_t SeqList::Find(DataType x)
{
	for(size_t i=0; i<_size; i++)
	{
		if(_arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}