/**************************************************
* 文 件 名: list.cpp
* 文件描述: 双循环队列的定义
* 创 建 人: 刘基伟
* 创建日期: 2007年 5月 5日
* 版 本 号: 1.0
* 修改纪录: 暂无
*************************************************/
#include "list.h"
#include <iostream>
using namespace std;
/*=======================================================
* 函 数 名: _List(int , int )
* 参数说明: iCount连续插入相同值的个数
iValue插入的数值
* 功能描述: 用几个相同的数值来初始化_List
* 返 回 值: 无
=======================================================*/
_List::_List(int iCount, int iValue)
{
_M_empty_initialize();
link_node _pM_insert_node = _pM_head_node;
for(int i = 0; i < iCount; i++)
{
_pM_insert_node = _Insert_initialize(_pM_insert_node, iValue);
}
}
/*=======================================================
* 函 数 名: _List(_List_iterator &, _List_iterator &)
* 参 数: Begin插入的起始位置
End插入的结束位置
* 功能描述: 用一个区间来初始化_List
* 返 回 值: 无
=======================================================*/
_List::_List(_List_iterator &Begin, _List_iterator &End)
{
_M_empty_initialize();
_List_iterator _First = Begin;
_List_iterator _Last = End;
while(_First != _Last)
{
_Erase(_First);
++_First;
}
}
/*=======================================================
* 函 数 名: _Erase(_List_iterator &, _List_iterator &)
* 参 数: First删除的起始位置
Last删除的结束位置
* 功能描述: 删除一个连续的区间
* 返 回 值: _List_iterator
=======================================================*/
_List_iterator _List::_Erase(_List_iterator &First, _List_iterator &Last)
{
while (First != Last)
_Erase(First++);
return Last;
}
/*=======================================================
* 函 数 名: _Remove(const int )
* 参 数: Value
* 功能描述: 移除为Value的元素
* 返 回 值: void
=======================================================*/
void _List::_Remove(const int Value)
{
_List_iterator _First = Begin();
_List_iterator _Last = End();
while (_First != _Last)
{
_List_iterator _Next = _First;
++_Next;
if (*_First == Value)
_Erase(_First);
_First = _Next;
}
}
/*=======================================================
* 函 数 名: _Clear()
* 参 数: 无
* 功能描述: 将_List清空
* 返 回 值: void
=======================================================*/
void _List::_Clear()
{
_List_iterator _First = Begin();
_List_iterator _Last = End();
while(_First != _Last)
{
_Erase(_First, _Last);
}
}
/*=======================================================
* 函 数 名: _List_show() const
* 参 数: 无
* 功能描述: 将_List从头到尾打印出来
* 返 回 值: void
=======================================================*/
void _List::_List_show() const
{
link_node _pM_show_node = _pM_head_node;
_pM_show_node = _pM_show_node->_pM_next;
while(_pM_show_node != _pM_head_node)
{
cout<<_pM_show_node->_iM_data<<endl;
_pM_show_node = _pM_show_node->_pM_next;
}
}
/*=======================================================
* 函 数 名: _Erase(_List_iterator &)
* 参 数: Position为要删除的位置
* 功能描述: 删除Position位置的元素
* 返 回 值: _List_iterator
=======================================================*/
_List_iterator _List::_Erase(_List_iterator &Position)
{
_List_node* __next_node = Position._pM_node->_pM_next;
_List_node* __prev_node = Position._pM_node->_pM_prev;
if(iSize > 0)
{
_List_node* _pM_delete_node = (_List_node*) Position._pM_node;
__prev_node->_pM_next = __next_node;
__next_node->_pM_prev = __prev_node;
--iSize;
delete _pM_delete_node;
}
return _List_iterator((_List_node*)__next_node);
}
/*=======================================================
* 函 数 名: _Insert_initialize(_List_node* , int )
* 参 数: Position为插入的位置
iValue为插入的元素
* 功能描述: 在Position位置插入iValue
* 返 回 值: _List_node*
=======================================================*/
_List_node* _List::_Insert_initialize(_List_node* Position, int iValue)
{
_List_node* _Node_temp = new _List_node(iValue);
Position->_pM_next = _Node_temp;
_Node_temp->_pM_next = _pM_head_node;
_pM_head_node->_pM_prev = _Node_temp;
_Node_temp->_pM_prev = Position;
++iSize;
return _Node_temp;
}
/*=======================================================
* 函 数 名: Unique()
* 参 数: 无
* 功能描述: 剔除重复的元素
* 返 回 值: void
=======================================================*/
void _List::_Unique()
{
_List_iterator _First = Begin();
_List_iterator _Last = End();
if (_First == _Last)
return;
_List_iterator _Next = _First;
while (++_Next != _Last)
{
if (*_First == *_Next)
_Erase(_Next);
else
_First = _Next;
_Next = _First;
}
}
/*=======================================================
* 函 数 名: _Transfer(_List_iterator,
_List_iterator,
_List_iterator)
* 参 数: Position为要插入的位置
First为区间的头指针
Last为区间的尾指针
* 功能描述: 将一个连续区间插入特定位置
* 返 回 值: void
=======================================================*/
void _List::_Transfer(_List_iterator Position,
_List_iterator First,
_List_iterator Last)
{
if (Position != Last)
{
Last._pM_node->_pM_prev->_pM_next = Position._pM_node;
First._pM_node->_pM_prev->_pM_next = Last._pM_node;
Position._pM_node->_pM_prev->_pM_next = First._pM_node;
_List_node* _Temp = Position._pM_node->_pM_prev;
Position._pM_node->_pM_prev = Last._pM_node->_pM_prev;
Last._pM_node->_pM_prev = First._pM_node->_pM_prev;
First._pM_node->_pM_prev = _Temp;
}
}
/*=======================================================
* 函 数 名: _Splice(_List_iterator, _List &)
* 参 数: Position为要插入的位置
refList为另一个_List
* 功能描述: 将一个_List插入另一个_List的指定位置
* 返 回 值: void
=======================================================*/
void _List::_Splice(_List_iterator Position, _List & refList)
{
if (!refList._Empty())
this->_Transfer(Position, refList.Begin(), refList.End());
}
/*=======================================================
* 函 数 名: _Splice(_List_iterator,
_List &,
_List_iterator)
* 参 数: Position为要插入的位置
refList为另一个_List(也可以为同一个)
Last为指定的最后面的位置
* 功能描述: 将Last之前的元素插入Position
* 返 回 值: void
=======================================================*/
void _List::_Splice(_List_iterator Position,
_List &refList,
_List_iterator Last)
{
_List_iterator _Prev = Last;
++_Prev;
if (Position == Last || Position == _Prev)
return;
this->_Transfer(Position, Last, _Prev);
}
/*=======================================================
* 函 数 名: _Splice(_List_iterator,
_List &,
_List_iterator
_List_iterator)
* 参 数: Position为要插入的位置
refList为另一个_List(也可以为同一个)
First为指定的最前面的位置
Last为指定的最后面的位置
* 功能描述: 将[First,Last)之间的元素插入Position
* 返 回 值: void
=======================================================*/
void _List::_Splice(_List_iterator Position,
_List & refList,
_List_iterator First,
_List_iterator Last)
{
if (First != Last)
this->_Transfer(Position, First, Last);
}
/*=======================================================
* 函 数 名: _Merge(_List & )
* 参 数: refList为一个有序的_List
* 功能描述: 将两个有序的_List的合二为一
而且合并后依然有序
* 返 回 值: void
=======================================================*/
void _List::_Merge(_List & refList)
{
_List_iterator _First1 = Begin();
_List_iterator _Last1 = End();
_List_iterator _First2 = refList.Begin();
_List_iterator _Last2 = refList.End();
while (_First1 != _Last1 && _First2 != _Last2)
if (*_First2 < *_First1)
{
_List_iterator _Next = _First2;
_Transfer(_First1, _First2, ++_Next);
_First2 = _Next;
}
else
++_First1;
if (_First2 != _Last2)
_Transfer(_Last1, _First2, _Last2);
}
int main()
{
_List iList(2,7);
iList._Push_front(111);
iList._Push_front(333);
iList._Push_back(999);
iList._Push_back(777);
iList._Unique();
_List_iterator it = iList.Begin();
for(; it != iList.End(); it++)
cout<<*it<<endl;
return 0;
}
/**************************************************
* 文 件 名: list.h
* 文件描述: _List的声明
* 创 建 人: 刘基伟
* 创建日期: 2007年 5月 5日
* 版 本 号: 1.0
* 修改纪录: 暂无
*************************************************/
#include <iostream>
using namespace std;
#ifndef __LJW_STL_LIST_H
#define __LJW_STL_LIST_H
#define NULL 0
/*=======================================================
*函数名: _List_node
*功能描述:构造_List_node成为链式关系
=======================================================*/
struct _List_node
{
int _iM_data;
_List_node *_pM_next;
_List_node *_pM_prev;
_List_node(int iM_data,
_List_node *pM_next = NULL,
_List_node *pM_prev = NULL)
{
_iM_data = iM_data;
_pM_next = pM_next;
_pM_prev = pM_prev;
}
};
/*=======================================================
*函数名: _List_iterator
*功能描述:构造指向_List的指针
=======================================================*/
struct _List_iterator
{
_List_node *_pM_node;
_List_iterator()
{}
_List_iterator(_List_node *pList_node)
: _pM_node(pList_node)
{}
_List_iterator(const _List_iterator &refList_node)
: _pM_node(refList_node._pM_node)
{}
bool operator==(const _List_iterator& refList_iterator) const
{
return _pM_node == refList_iterator._pM_node;
}
bool operator!=(const _List_iterator& refList_iterator) const
{
return _pM_node != refList_iterator._pM_node;
}
int& operator*() const
{
return (*_pM_node)._iM_data;
}
//int* operator->() const
//{
// return &(operator*());
//}
_List_iterator& operator++()
{
_pM_node = _pM_node->_pM_next;
return *this;
}
_List_iterator operator++(int)
{
_List_iterator Iterator_temp = *this;
++*this;
return Iterator_temp;
}
_List_iterator& operator--()
{
_pM_node = _pM_node->_pM_prev;
return *this;
}
_List_iterator operator--(int)
{
_List_iterator Iterator_temp = *this;
--*this;
return Iterator_temp;
}
};
/*=======================================================
*函数名: _List
*功能描述:构造_List,进行一系列操作
=======================================================*/
class _List
{
private:
typedef _List_node* link_node;
int iSize;
link_node _pM_head_node;
/*=======================================================
* 函 数 名: _M_empty_initialize()
* 参 数: 无
* 功能描述: 创建头节点
* 返 回 值: void
=======================================================*/
void _M_empty_initialize()
{
iSize = 0;
_pM_head_node = new _List_node(888888);
_pM_head_node->_pM_next = _pM_head_node;
_pM_head_node->_pM_prev = _pM_head_node;
}
public:
_List()
{
_M_empty_initialize();
}
_List(int iCount, int iValue);
_List(_List_iterator &Begin, _List_iterator &end);
_List(const _List & List_copy);
_List_iterator Begin()
{
return (_List_node*)(_pM_head_node->_pM_next);
}
_List_iterator End()
{
return (_List_node*)(_pM_head_node);
}
int _Front()
{
return *Begin();
}
int _Back()
{
return *--End();
}
int _Size() const
{
return iSize;
}
bool _Empty()const
{
return iSize == 0;
}
void _Pop_front(_List_iterator Position)
{
_Erase(Begin());
}
void _Pop_back()
{
_Erase(--End());
}
void _Push_front(const int iValue)
{
_List_node* _pM_New_head = new _List_node(iValue);
_pM_New_head->_pM_next = _pM_head_node->_pM_next;
_pM_New_head->_pM_prev = _pM_head_node;
_pM_head_node->_pM_next = _pM_New_head;
_pM_head_node->_pM_next->_pM_prev = _pM_New_head;
++iSize;
}
void _Push_back(const int iValue)
{
_List_node* _pM_New_back = new _List_node(iValue);
_pM_New_back->_pM_next = _pM_head_node;
_pM_New_back->_pM_prev = _pM_head_node->_pM_prev;
_pM_head_node->_pM_prev->_pM_next = _pM_New_back;
_pM_head_node->_pM_prev = _pM_New_back;
++iSize;
}
void _Clear();
void _Unique();
void _List_show() const;
void _Remove(const int Value);
void _Merge(_List &);
void _Splice(_List_iterator, _List &);
void _Splice(_List_iterator, _List &, _List_iterator);
void _Splice(_List_iterator, _List &, _List_iterator, _List_iterator);
void _Transfer(_List_iterator , _List_iterator , _List_iterator );
_List_iterator _Erase(_List_iterator &Position);
_List_node* _Insert_initialize(_List_node* Position, int iValue);
_List_iterator _Erase(_List_iterator &First, _List_iterator &Last);
};
#endif __LJW_STL_LIST_H