C++实现顺序表
2016-08-31 10:54
232 查看
#pragma once
#include<assert.h>
typedef int DataType;
class SeqList
{
public:
//传统写法调用的构造函数
SeqList()
:_array( NULL)
,_size(0)
,_capacity(0)
{}
//现代写法调用的构造函数
SeqList( DataType* array ,size_t size)
:_array( new DataType [size])
, _size( size)
, _capacity( size)
{
memcpy(_array, array, sizeof (DataType)* size);
}
~SeqList()
{
if (_array)
{
delete[] _array;
}
}
//深拷贝传统写法
/*SeqList(const SeqList& s)
:_array(new DataType[s._size])
, _capacity(s._size)
, _size(s._size)
{
memcpy(_array, s._array, sizeof(DataType)*_size);
}
SeqList& operator=(const SeqList&s)
{
if (this != &s)
{
DataType* tmp = new DataType[s._size];
delete[] _array;
_array = tmp;
_size = s._size;
_capacity = s._size;
memcpy(_array, s._array, sizeof(DataType)*s._size);
}
return *this;
}*/
//现代写法
//按size拷贝构造
SeqList( const SeqList & s)
:_array( NULL)
{
SeqList tmp(s ._array, s._size);
swap(_array, tmp._array);
_size = s._size; //s._size赋值给_size
_capacity = s._size;//所以把s._size赋值给新的_capacity
}
//赋值运算符的重载
SeqList& operator=(SeqList s) //无const 无引用
{
swap( s._array,_array);
_size = s._size;
_capacity = s._capacity;
return *this ;
}
public:
void PushBack(DataType x)
{
CheckCapacity();
_array[_size++] = x;
}
void PopBack()
{
if (--_capacity )
{
_array[_size--];
}
if (_size == 0)
cout << "NULL";
}
void PushFront(DataType x)
{
CheckCapacity();
_size++;
for (int i =_size-1; i >=0; i--) //_size-1 i>=0
{
_array[i + 1] = _array[i];
}
_array[0] = x;
}
void PopFront()
{
if (_size <= 0)
{
cout << "NULL";
return;
}
else
{
for (int i = 0; i <_size; i++ )
{
_array[i] = _array[i + 1];
}
_size--;
}
}
void Insert(size_t pos, DataType x )
{
if (pos == 0)
{
PushFront( x);
}
else
{
_size++;
for (int i = _size - 1; i >= pos; i--)
{
_array[i] = _array[i - 1];
}
_array[ pos] = x ;
}
}
//attention
void Erase(size_t x)
{
int count = 0;
for (int i = 0; i <= _size; ++i)
{
if (_array[i] == x )
{
count++;
}
else
{
_array[i - count] = _array[i];
}
}
//放在循环外面
_size -= count;
}
int Find(DataType x)
{
for (int i = 0; i < _size; i++)
{
if (x == _array[i])
{
return i;
}
}
}
void PrintList()
{
for (int i = 0; i < _size; ++i)
{
//if (_array[i])
cout << _array[i] << "->";
}
cout << "NULL"<<endl;
}
private:
void CheckCapacity()
{
if (_size >= _capacity)
{
_capacity = 2 * _capacity + 3;
_array =( DataType*) realloc(_array, (sizeof(DataType ))*_capacity);
//realloc后将指针赋给新的空间
//sizeof(DataType)*_capacity
}
}
private:
DataType* _array;
size_t _size;
size_t _capacity;
};
void Test1()
{
SeqList s1; //先定义一各变量
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.PushBack(5);
s1.PrintList();
/* SeqList s2(s1);
s2.PrintList();*/
s1.PopBack();
s1.PopBack();
s1.PopBack();
s1.PopBack();
s1.PrintList();
}
//PushFront()
void Test2()
{
SeqList s1;
s1.PushFront(1);
s1.PushFront(2);
s1.PushFront(3);
s1.PushFront(4);
s1.PushFront(5);
s1.PrintList();
s1.PopFront();
s1.PopFront();
s1.PopFront();
s1.PrintList();
}
//pushback Insert
void Test3()
{
SeqList s1; //先定义一各变量
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.PushBack(5);
s1.PrintList();
s1.Insert(0, 0);
s1.Insert(1, 6);
s1.Insert(7, 5);
s1.PrintList();
}
void Test4()
{
SeqList s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.PushBack(5);
s1.PushBack(5);
s1.PushBack(5);
s1.PrintList();
s1.Erase(5);
s1.PrintList();
}
void Test5()
{
SeqList s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.PushBack(5);
s1.PrintList();
//s1.Erase(5);
int ret5 = s1.Find(5);
int ret4 = s1.Find(4);
int ret3 = s1.Find(3);
int ret2 = s1.Find(2);
int ret1 = s1.Find(1);
cout << ret5 << ret4 << ret3 << ret2 << ret1 << endl;
}
void TestSeqList6()
{
SeqList s1;
s1.PushBack(2);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(2);
s1.PushBack(4);
s1.PushBack(2);
s1.PushBack(5);
s1.PushBack(2);
s1.Erase(2);
s1.PrintList();
}
#include<assert.h>
typedef int DataType;
class SeqList
{
public:
//传统写法调用的构造函数
SeqList()
:_array( NULL)
,_size(0)
,_capacity(0)
{}
//现代写法调用的构造函数
SeqList( DataType* array ,size_t size)
:_array( new DataType [size])
, _size( size)
, _capacity( size)
{
memcpy(_array, array, sizeof (DataType)* size);
}
~SeqList()
{
if (_array)
{
delete[] _array;
}
}
//深拷贝传统写法
/*SeqList(const SeqList& s)
:_array(new DataType[s._size])
, _capacity(s._size)
, _size(s._size)
{
memcpy(_array, s._array, sizeof(DataType)*_size);
}
SeqList& operator=(const SeqList&s)
{
if (this != &s)
{
DataType* tmp = new DataType[s._size];
delete[] _array;
_array = tmp;
_size = s._size;
_capacity = s._size;
memcpy(_array, s._array, sizeof(DataType)*s._size);
}
return *this;
}*/
//现代写法
//按size拷贝构造
SeqList( const SeqList & s)
:_array( NULL)
{
SeqList tmp(s ._array, s._size);
swap(_array, tmp._array);
_size = s._size; //s._size赋值给_size
_capacity = s._size;//所以把s._size赋值给新的_capacity
}
//赋值运算符的重载
SeqList& operator=(SeqList s) //无const 无引用
{
swap( s._array,_array);
_size = s._size;
_capacity = s._capacity;
return *this ;
}
public:
void PushBack(DataType x)
{
CheckCapacity();
_array[_size++] = x;
}
void PopBack()
{
if (--_capacity )
{
_array[_size--];
}
if (_size == 0)
cout << "NULL";
}
void PushFront(DataType x)
{
CheckCapacity();
_size++;
for (int i =_size-1; i >=0; i--) //_size-1 i>=0
{
_array[i + 1] = _array[i];
}
_array[0] = x;
}
void PopFront()
{
if (_size <= 0)
{
cout << "NULL";
return;
}
else
{
for (int i = 0; i <_size; i++ )
{
_array[i] = _array[i + 1];
}
_size--;
}
}
void Insert(size_t pos, DataType x )
{
if (pos == 0)
{
PushFront( x);
}
else
{
_size++;
for (int i = _size - 1; i >= pos; i--)
{
_array[i] = _array[i - 1];
}
_array[ pos] = x ;
}
}
//attention
void Erase(size_t x)
{
int count = 0;
for (int i = 0; i <= _size; ++i)
{
if (_array[i] == x )
{
count++;
}
else
{
_array[i - count] = _array[i];
}
}
//放在循环外面
_size -= count;
}
int Find(DataType x)
{
for (int i = 0; i < _size; i++)
{
if (x == _array[i])
{
return i;
}
}
}
void PrintList()
{
for (int i = 0; i < _size; ++i)
{
//if (_array[i])
cout << _array[i] << "->";
}
cout << "NULL"<<endl;
}
private:
void CheckCapacity()
{
if (_size >= _capacity)
{
_capacity = 2 * _capacity + 3;
_array =( DataType*) realloc(_array, (sizeof(DataType ))*_capacity);
//realloc后将指针赋给新的空间
//sizeof(DataType)*_capacity
}
}
private:
DataType* _array;
size_t _size;
size_t _capacity;
};
void Test1()
{
SeqList s1; //先定义一各变量
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.PushBack(5);
s1.PrintList();
/* SeqList s2(s1);
s2.PrintList();*/
s1.PopBack();
s1.PopBack();
s1.PopBack();
s1.PopBack();
s1.PrintList();
}
//PushFront()
void Test2()
{
SeqList s1;
s1.PushFront(1);
s1.PushFront(2);
s1.PushFront(3);
s1.PushFront(4);
s1.PushFront(5);
s1.PrintList();
s1.PopFront();
s1.PopFront();
s1.PopFront();
s1.PrintList();
}
//pushback Insert
void Test3()
{
SeqList s1; //先定义一各变量
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.PushBack(5);
s1.PrintList();
s1.Insert(0, 0);
s1.Insert(1, 6);
s1.Insert(7, 5);
s1.PrintList();
}
void Test4()
{
SeqList s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.PushBack(5);
s1.PushBack(5);
s1.PushBack(5);
s1.PrintList();
s1.Erase(5);
s1.PrintList();
}
void Test5()
{
SeqList s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.PushBack(5);
s1.PrintList();
//s1.Erase(5);
int ret5 = s1.Find(5);
int ret4 = s1.Find(4);
int ret3 = s1.Find(3);
int ret2 = s1.Find(2);
int ret1 = s1.Find(1);
cout << ret5 << ret4 << ret3 << ret2 << ret1 << endl;
}
void TestSeqList6()
{
SeqList s1;
s1.PushBack(2);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(2);
s1.PushBack(4);
s1.PushBack(2);
s1.PushBack(5);
s1.PushBack(2);
s1.Erase(2);
s1.PrintList();
}
相关文章推荐
- 【C++】队列——顺序表实现V1.0(源码提供)
- 算法与数据结构课程中的c++实现的顺序表和链表
- 【C++】模版类实现普通类静态顺序表
- c++中的顺序表写法,主要实现(增删查改,构造函数,运算符重载)
- 线性表的两种实现 -- 顺序表和链表(C++)
- 可变长度 顺序表 C++实现
- C++用模板实现顺序表和栈
- c++中的顺序表写法,主要实现(增删查改,构造函数,运算符重载)
- C++数据结构: 顺序表 详细实现
- 【C++】类型萃取技术实现静态顺序表
- C++实现数据结构一 顺序表
- 常见数据结构的C++实现(一)——顺序表SqList
- c++实现顺序表
- 用C++实现顺序表
- C++实现顺序表
- 【C++】栈——顺序表实现V1.0(源码提供)
- 用C++实现简单的顺序表
- c++实现动态顺序表
- C++实现动态顺序表
- C++实现动态顺序表