用C++实现顺序表

SeqList.h

 

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

typedef int DataType;
class SeqList
{
public:
	SeqList();//普通版构造函数
	SeqList(DataType* array, size_t size);//数组版构造函数
	SeqList(const SeqList& s);//普通版拷贝构造函数
	SeqList& operator=(const SeqList& s);//普通版的赋值运算符重载
	//SeqList& SeqList::operator=(SeqList s);//简洁版的赋值运算符重载
	~SeqList();//析构函数

	void PushBack(int data);//尾插
	void PopBack();//尾删
	int Find(const DataType& data);//查找
	void Insert(size_t pos, DataType data);//指定位置插入
	void Erase(size_t pos);//删除pos位的元素
	size_t Size()const;//返回size的大小
	size_t Capacity()const;//返回最大容量的大小
	bool Empty()const;//判断顺序表是否为空


	DataType& operator[](size_t index);//[]运算符重载
	const DataType& operator[](size_t index)const;
	DataType& Front();// 返回顺序表中的第一个元素 
	const DataType& Front()const;
	DataType& Back();// 返回顺序表中最后一个元素 
	const DataType& Back()const;
	void Clear();// 清空顺序表中的所有元素
	// 将顺序表中元素个数改变到newSize 
	void ReSize(size_t newSize, const DataType& data);
	friend ostream& operator<<(ostream& _cout, const SeqList& s);
	void diplay();
private:
	void CheckCapacity()
	{
		assert(_array);
		if (_capacity <= _size)
		{
			DataType* newarray = new DataType[2 * _capacity];//开辟二倍大的新空间
			for (size_t i = 0; i < _size; i++)//拷贝
			{
				newarray[i] = _array[i];
			}
			delete[]_array;
			_array = NULL;
			_array = newarray;
			_capacity = 2 * _capacity;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};

SeqList.cpp

#include "SeqList.h"

//普通版构造函数
SeqList::SeqList()
: _array(new DataType[3])
, _capacity(3)
, _size(0)
{}

//数组版构造函数
SeqList::SeqList(DataType* array, size_t size)
: _array(new DataType[size])
, _capacity(size)
, _size(size)
{
	for (size_t i = 0; i < size; ++i)
		_array[i] = array[i];
}

//普通版拷贝构造函数
SeqList::SeqList(const SeqList& s)
:_array(new DataType[s._capacity])
, _capacity(s._size)
, _size(s._size)
{
	size_t i = 0;
	for (i = 0; i < _size; i++)
	{
		_array[i] = s._array[i];
	}
}
/*
//简洁版拷贝构造函数
SeqList::SeqList(const SeqList& s)
:_array(NULL)
, _capacity(0)
, _size(0)
{
SeqList tmp(s._array, s._capacity);
tmp._size = s._size;
swap(tmp, *this);
}
*/

//普通版的赋值运算符重载
SeqList& SeqList::operator=(const SeqList& s)
{
	if (this != &s)
	{
		DataType* tmp = _array;//保存旧空间
		_array = new DataType[s._capacity];//开辟新空间
		_size = s._size;
		_capacity = s._capacity;
		delete[] tmp;//释放旧空间
		for (size_t i = 0; i < _size; i++)//拷贝
		{
			_array[i] = s._array[i];
		}
	}
	return *this;
}

/*
//简洁版的赋值运算符重载
SeqList& SeqList::operator=(SeqList s)
{
swap(s, *this);
return *this;
}
*/
//析构函数
SeqList::~SeqList()
{
	if (_array)
	{
		delete[] _array;
		_size = 0;
		_capacity = 0;
	}
}


//尾插
void SeqList::PushBack(int data)
{
	assert(_array);
	CheckCapacity();
	_array[_size] = data;
	_size++;
}

//尾删
void SeqList:: PopBack()
{
	assert(_array);
	if (_array == NULL)
	{
		return;
	}
	_size--;
}

int SeqList::Find(const DataType& data)
{
	for (size_t i = 0; i < _size; i++)
	{
		if (_array[i] == data)
			return 1;
	}
	return -1;
}

//指定位置插入(在pos之后插入data)
void SeqList::Insert(size_t pos, DataType data)
{
	assert(pos >= 0 && pos < _size);
	CheckCapacity();
	for (size_t i = _size; i >pos;i--)
	{
		_array[i] = _array[i - 1];
	}
	_array[pos] = data;
	_size++;
}

//删除pos位的元素
void SeqList::Erase(size_t pos)
{
	assert(pos >= 0 && pos < _size);
	if (_size == 0)
	{
		return;
	}
	for (size_t i = pos - 1; i<_size; i++)
	{
		_array[i] = _array[i + 1];
	}
	_size--;
}

//返回size的大小
size_t SeqList::Size()const
{
	return _size;
}

//返回capacity的大小
size_t SeqList::Capacity()const
{
	return _capacity;
}

//判断顺序表是否为空
bool SeqList::Empty()const
{
	return _size == 0;
}

//[]运算符重载
DataType& SeqList::operator[](size_t index)
{
	return _array[index];
}
const DataType& SeqList::operator[](size_t index)const 
{
	return _array[index];
}

// 返回顺序表中的第一个元素 
DataType& SeqList::Front()
{
	assert(_size > 0);
	return _array[0];
}
const DataType& SeqList::Front()const
{
	assert(_size > 0);
	return _array[0];
}

// 返回顺序表中最后一个元素 
DataType& SeqList::Back()
{
	assert(_size > 0);
	return _array[_size - 1];
}
const DataType& SeqList::Back()const 
{
	assert(_size > 0);
	return _array[_size - 1];
}

// 清空顺序表中的所有元素
void SeqList::Clear()
{
	if (NULL != _array)
	{
		delete []_array;
		_size = 0;
		_capacity = 0;
	}
}

// 将顺序表中元素个数改变到newSize
void SeqList::ReSize(size_t newSize, const DataType& data)
{
	if (newSize > _size)
	{
		int tmp = _size;
		_size = newSize;
		CheckCapacity();
		for (size_t i = tmp; i < newSize; i++)
		{
			_array[i] = data;
		}
	}
	if (newSize>_size)
	{
		_size = newSize;
	}
}

//输出运算符重载
ostream& operator<<(ostream& _cout, const SeqList& s)
{
	for (size_t i = 0; i < s._size; i++)
	{
		_cout << s._array[i] << "->";
	}
	_cout << "end";
	return _cout;
}

void SeqList::diplay()
{
	for (size_t i = 0; i < _size; i++)
	{
		cout << _array[i]<<"-->";
	}
	cout << "end" << endl;
}

test.cpp

 

 

#include "SeqList.h"

void FunTest()
{
	SeqList s1;
	s1.PushBack(1);//尾插
	s1.PushBack(2);
	s1.PushBack(3);
	s1.PushBack(4);
	s1.PushBack(5);
	s1.PushBack(6);
	s1.diplay();//打印

	s1.PopBack();//尾删
	s1.diplay();//打印

	s1.Insert(1, 1);//在第一位后面插入1
	s1.diplay();

	s1.Erase(3);//删除第三位元素
	s1.diplay();

	int a =s1.Find(9);
	if (a == 1)
	{
		cout << "找到了！" << endl;
	}
	else
	{
		cout << "没有找到！" << endl;
	}

	int b = s1.Size();
	cout << "Size= "<< b << endl;

	int c = s1.Capacity();
	cout << "Capacity= " << c << endl;

	int d = s1.Empty();
	if (d == 0)
	{
		cout << "顺序表不为空！"<<endl;
	}

	DataType e = s1.Front();
	s1.diplay();
	cout <<"顺序表中第一个元素为"<< e << endl;
	
	DataType f = s1.Back();
	s1.diplay();
	cout << "顺序表中第一个元素为" << f << endl;

	//s1.Clear();//清空
	//s1.diplay();

	s1.ReSize(7,1);
	int b1 = s1.Size();
	cout << "Size= " << b1 << endl;

}
int main()
{
	FunTest();
	system("pause:");
	return 0;
}