双向循环链表

 

/**************************************************
* 文 件 名：   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