数据结构：循环队列

最近练手谢了一些数据结构的实现。 贴在博客里边，方便以后查阅。

// CircleQueue.hpp 

 1 #ifndef __CIRCLE_QUEUE_HPP__
 2 #define __CIRCLE_QUEUE_HPP__
 3 
 4 template <class Type> class CircleQueue
 5 {
 6 public:
 7     const static size_t CIRCLE_QUEUE_INVALID_INDEX = -1;
 8     const static size_t CIRCLE_QUEUE_DEFAULT_CAPACITY = 5;
 9     const static size_t CIRCLE_QUEUE_INCREASE_CAPACITY = 3;
10 
11     CircleQueue(size_t capacity = CIRCLE_QUEUE_DEFAULT_CAPACITY) : m_elem_list(NULL), m_capacity(capacity), m_head(CIRCLE_QUEUE_INVALID_INDEX), m_tail(CIRCLE_QUEUE_INVALID_INDEX) 
12     {
13         if (capacity > 0)
14         {
15             m_elem_list = new Type[m_capacity];
16             m_head = m_tail = 0;
17         }
18     }
19 
20     CircleQueue(const CircleQueue &circle_queue) : m_elem_list(NULL), m_capacity(circle_queue.Capacity()), m_head(CIRCLE_QUEUE_INVALID_INDEX), m_tail(CIRCLE_QUEUE_INVALID_INDEX) 
21     {
22         m_elem_list = new Type[circle_queue.Capacity()];
23         if (NULL == m_elem_list) return;
24 
25         m_head = m_tail = 0;
26     }
27 
28     ~CircleQueue() { if (NULL != m_elem_list) delete m_elem_list; }
29 
30     bool Empty() { return m_head == m_tail || m_capacity <= 0; }
31 
32     size_t Capacity() { return m_capacity; }
33 
34     size_t Size() 
35     {
36         if (m_capacity <= 0) return 0;
37 
38         return (m_tail - m_head + m_capacity) % m_capacity; 
39     }
40 
41     bool EnQueue(Type elem)
42     {
43         if (m_capacity <= 0 || NULL == m_elem_list) return false;
44 
45         if ((m_tail + 1) % m_capacity == m_head)    // full
46         {
47             Type *tmp_elem_list = new Type[m_capacity + CIRCLE_QUEUE_INCREASE_CAPACITY];
48             if (NULL == tmp_elem_list) return false;
49 
50             size_t size = this->Size();
51             for (size_t i = 0; i < size; ++ i)
52             {
53                 size_t index = (m_head + i) % m_capacity;
54                 tmp_elem_list[i] = m_elem_list[index];
55             }
56 
57             delete m_elem_list; m_elem_list = tmp_elem_list;
58             m_head = 0; m_tail = size; m_capacity += CIRCLE_QUEUE_INCREASE_CAPACITY;
59         }
60 
61         m_elem_list[m_tail] = elem;
62         m_tail = (m_tail + 1) % m_capacity;
63         return true;
64     }
65 
66     bool DeQueue(Type &out_elem)
67     {
68         if (this->Empty()) return false;
69 
70         out_elem = m_elem_list[m_head];
71         m_head = (m_head + 1) % m_capacity;
72         return true;
73     }
74 
75 private:
76     Type *m_elem_list;
77     size_t m_capacity;
78     size_t m_head; 
79     size_t m_tail;
80 };
81 
82 #endif // __CIRCLE_QUEUE_HPP__

 

 // main.cpp 测试用的

 1 #include <iostream>
 2 #include "CircleQueue.hpp"
 3 
 4 int main()
 5 {
 6     CircleQueue<int> circle_queue;
 7 
 8     for (int i = 0; i < 100; ++ i)
 9     {
10         circle_queue.EnQueue(i);
11         if (0 == (i + 1) % 10)
12         {
13             int out_elem = -1;
14             circle_queue.DeQueue(out_elem);
15         }
16         
17     }
18 
19     std::cout << "size is " << circle_queue.Size() << std::endl;
20 
21     for (int i = 0; i < 100; ++ i)
22     {
23         int out_elem = -1;
24         if (circle_queue.DeQueue(out_elem))
25         {
26             std::cout << "dequeue success out_elem = " << out_elem << std::endl;
27         }
28         else
29         {
30             std::cout << "dequeue fail !" << std::endl;
31         }
32     }
33 }

View Code

 

 

 

转载于:https://www.cnblogs.com/xiaol-luo/p/3293606.html