循环队列与链式队列的实现

我们了解一下队列：是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端front进行插入，而在另一端rear进行删除。
   队首(front) ：允许进行删除的一端称为队首。
   队尾(rear) ：允许进行插入的一端称为队尾。

我用两种方式实现了队列，一种是数组存储，一种是单链表。如下，有入队，出队操作，还有判空，求队首元素，队尾元素及队列元素个数。详细如下：

一、循环队列



//循环队列
template<class T,size_t N=4>
class Queue
{
public:
  Queue()
    :_front(0)
    , _back(0)
    , _count(0)
  {
    for (size_t i = 0; i < N; i++)
    {
      _arr[i] = 0;
    }
  }
  void PushBack(int data)
  {
    if (_count == N)
      return;
    _arr[_back] = data;
    _back++;
    _count++;
    if (N == _back)
      _back = 0;
  }
  void Pop()
  {
    if (_count == 0)
      return;
    _front++;
    _count--;
    if (_front == N)
      _front = 0;
  }
  T& Front()
  {
    return _arr[_front];
  }
  const T& Front()const
  {
    return _arr[_front];
  }
  T& Back()
  {
    return _arr[(_front + _count - 1) % N];
  }
  const T& Back()const
  {
    return _arr[(_front + _count - 1) % N];
  }
  size_t size()
  {
    return _count;
  }
  bool Empty()
  {
    return _front == ((_front+_count-1)%N);
  }
private:
  T _arr[N];
  int _front;
  int _back;
  size_t _count;     //计数器
};

测试如下：

int main()
{
  Queue<int> q;
  q.PushBack(1);
  q.PushBack(2);
  q.PushBack(3);
  q.PushBack(4);

  cout << q.Empty() << endl;
  cout << q.Back() << endl;
  cout << q.Front() << endl;
  cout << q.size() << endl;
  q.PushBack(5);
  cout << q.size() << endl;

  q.Pop();
  cout << q.size() << endl;

  system("pause");
  return 0;
}

循环队列与链式队列的实现_链式队列


可以看出，5入队前后队列的元素个数都是4，这是因为队列容量为4，5入队时失败。

二、链式队列

与单链表相似，代码为无头单链表，我们需要建立节点。代码如下：

//链式队列
typedef int TypeData;
typedef struct Node
{
    Node(const TypeData& data)
    :_data(data)
    ,_pNext(NULL)
    {}
    TypeData _data;
    Node *_pNext;
}*pNode;

class Queue
{
public:
    Queue()
    {
        _front = NULL;
        _back = NULL;
    }
    void PushBack(TypeData data)
    {
        pNode newNode = new Node(data);
        if (_front == NULL)
        {
            _front = newNode;
            _back = newNode;
        }
        _back->_pNext = newNode;
        newNode->_pNext = NULL;
        _back = newNode;
    }
    void Pop()
    {
        if (_back == _front)
        {
            delete _back;
            _front = NULL;
            _back = _front;
        }
        pNode tmp = _front->_pNext;
        delete _front;
        _front = tmp;
    }
    size_t size()
    {
        size_t count = 0;
        pNode tmp = _front;
        while (tmp->_pNext != NULL)
        {
            count++;
            tmp = tmp->_pNext;
        }
        count++;
        return count;
    }
    TypeData Front()
    {
        if (_front == NULL)
            return 0;
        return _front->_data;
    }
    const TypeData Front()const
    {
        if (_front == NULL)
            return 0;
        return _front->_data;
    }
    TypeData Back()
    {
        if (_back == NULL)
            return 0;
        return _back->_data;
    }
    const TypeData Back()const
    {
        if(_back == NULL)
            return 0;
        return _back->_data;
    }
    bool Empty()
    {
        return _front == NULL;
    }
private:
    pNode _front;     //对头指针
    pNode _back;      //队尾指针
};

测试：

int main()
{
  Queue q;
  q.PushBack(1);
  q.PushBack(2);
  q.PushBack(3);
  q.PushBack(4);

  cout << q.Empty() << endl;
  cout << q.Back() << endl;
  cout << q.Front() << endl;

  q.PushBack(5);
  cout << q.size() << endl;

  q.Pop();
  cout << q.size() << endl;

  system("pause");
  return 0;
}

循环队列与链式队列的实现_循环队列_02