经典算法题每日演练——第十九题 双端队列

     话说大学的时候老师说妹子比工作重要~,工作可以再换,妹子这个。。。所以。。。这两个月也就一直忙着Fall in love,嗨,慢慢调整心态吧,

这篇就选一个简单的数据结构聊一聊,话说有很多数据结构都在玩组合拳,比如说:块状链表,块状数组,当然还有本篇的双端队列,是的,它就是

栈和队列的组合体。

一:概念

     我们知道普通队列是限制级的一端进,另一端出的FIFO形式,栈是一端进出的LIFO形式,而双端队列就没有这样的限制级,也就是我们可以在

队列两端进行插入或者删除操作。

二:编码

1:定义结构体

    通常情况下,队列的内部都是采用数组来实现,而且带有两个指针head和tail来指向数组的区间段,为了充分利用数组空间,我们也会用%来实

现逻辑上的循环数组,如下图。

 1     public class MyQueue
 2     {
 3         public int head;
 4 
 5         public int tail;
 6 
 7         public int maxSize;
 8 
 9         public int size;
10 
11         public T[] list;
12 
13         public MyQueue()
14         {
15             head = tail = size = 0;
16             maxSize = 3;
17             list = new T[maxSize];
18         }
19     }

这里有一个注意的细节就是“size字段“,它是为了方便统计队列是否为满或者队列是否为空。

2:队尾入队

    刚才也说了,双端队列是可以在队列的两端进行插入和删除的,要注意的是我们用head和tail指针的时候,tail指针是指向元素的下一个位置,

而head指针是指向当前元素,所以我们可以从tail端push数据的时候只要”顺时针“下移一个位置即可。

 1     /// <summary>
 2     /// 队尾入队
 3     /// </summary>
 4     /// <param name="t"></param>
 5     /// <returns></returns>
 6     public bool Push_Tail(T t)
 7     {
 8         //判断队列是否已满
 9         if (myQueue.size == myQueue.list.Length)
10             return false;
11 
12         myQueue.list[myQueue.tail] = t;
13 
14         //顺时针旋转
15         myQueue.tail = (myQueue.tail + 1) % myQueue.maxSize;
16 
17         myQueue.size++;
18 
19         return true;
20     }


3:队尾出队

    和队尾入队一样,我们只要将tail指针”逆时针“下移一个位置,当然有一个细节需要注意,就是tail指针有存在负值的情况,毕竟我们是做”--操作“的,

所以需要tail+maxSize,即:myQueue.tail = (--myQueue.tail + myQueue.maxSize) % myQueue.maxSize;

 1     /// <summary>
 2     /// 队尾出队
 3     /// </summary>
 4     /// <param name="edges"></param>
 5     /// <param name="t"></param>
 6     public T Pop_Tail()
 7     {
 8         //判断队列是否已空
 9         if (myQueue.size == 0)
10             return default(T);
11 
12         //逆时针旋转(防止负数)
13         myQueue.tail = (--myQueue.tail + myQueue.maxSize) % myQueue.maxSize;
14 
15         var temp = myQueue.list[myQueue.tail];
16 
17         //赋予空值
18         myQueue.list[myQueue.tail] = default(T);
19 
20         myQueue.size--;
21 
22         return temp;
23     }

4:队首入队

    从head端来说,我们push数据的时候是head指针“逆时针”旋转,要注意的是同样要防止负数的产生,并且head指针是指向当前元素。

 1     /// <summary>
 2     /// 队首入队
 3     /// </summary>
 4     /// <param name="t"></param>
 5     /// <returns></returns>
 6     public bool Push_Head(T t)
 7     {
 8         //判断队列是否已满
 9         if (myQueue.size == myQueue.list.Length)
10             return false;
11 
12         //逆时针旋转(防止负数产生)
13         myQueue.head = (--myQueue.head + myQueue.maxSize) % myQueue.maxSize;
14 
15         //赋予元素
16         myQueue.list[myQueue.head] = t;
17 
18         myQueue.size++;
19 
20         return true;
21     }

5:队首出队

    说到这个方法,我想大家应该都懂了双端队列的大概流程了,这个方法我也不用赘叙了。

 1     /// <summary>
 2     /// 队首出队
 3     /// </summary>
 4     /// <param name="edges"></param>
 5     /// <param name="t"></param>
 6     public T Pop_Head()
 7     {
 8         //判断队列是否已空
 9         if (myQueue.size == 0)
10             return default(T);
11 
12         //获取队首元素
13         var temp = myQueue.list[myQueue.head];
14 
15         //原来单位的值赋默认值
16         myQueue.list[myQueue.head] = default(T);
17 
18         //顺时针旋转
19         myQueue.head = (myQueue.head + 1) % myQueue.maxSize;
20 
21         myQueue.size--;
22 
23         return temp;
24     }


从上面的四个方法可以看出:

当我们只使用Push_Tail和Pop_Tail的话,那它就是栈。

当我们只使用Push_Tail和Pop_Head的话,那它就是队列。

最后是全部代码:

View Code
  1 using System.Net;
  2 using System;
  3 using System.IO;
  4 using System.Collections.Generic;
  5 using System.Text;
  6 using System.Drawing;
  7 using System.Drawing.Imaging;
  8 
  9 class Program
 10 {
 11     static void Main(string[] args)
 12     {
 13         DoubleQueue<int> queue = new DoubleQueue<int>();
 14 
 15         queue.Push_Tail(10);
 16         queue.Push_Tail(20);
 17         queue.Push_Tail(30);
 18 
 19         queue.Pop_Tail();
 20         queue.Pop_Tail();
 21         queue.Pop_Tail();
 22 
 23         queue.Push_Tail(10);
 24         queue.Push_Head(20);
 25         queue.Push_Head(30);
 26         queue.Push_Head(30);
 27 
 28         queue.Pop_Tail();
 29         queue.Pop_Tail();
 30         queue.Pop_Head();
 31 
 32         queue.Push_Head(40);
 33         queue.Push_Tail(50);
 34         queue.Push_Tail(60);
 35     }
 36 }
 37 
 38 /// <summary>
 39 /// 双端队列
 40 /// </summary>
 41 public class DoubleQueue<T>
 42 {
 43     public class MyQueue
 44     {
 45         public int head;
 46 
 47         public int tail;
 48 
 49         public int maxSize;
 50 
 51         public int size;
 52 
 53         public T[] list;
 54 
 55         public MyQueue()
 56         {
 57             head = tail = size = 0;
 58             maxSize = 3;
 59             list = new T[maxSize];
 60         }
 61     }
 62 
 63     MyQueue myQueue = new MyQueue();
 64 
 65     /// <summary>
 66     /// 队尾入队
 67     /// </summary>
 68     /// <param name="t"></param>
 69     /// <returns></returns>
 70     public bool Push_Tail(T t)
 71     {
 72         //判断队列是否已满
 73         if (myQueue.size == myQueue.list.Length)
 74             return false;
 75 
 76         myQueue.list[myQueue.tail] = t;
 77 
 78         //顺时针旋转
 79         myQueue.tail = (myQueue.tail + 1) % myQueue.maxSize;
 80 
 81         myQueue.size++;
 82 
 83         return true;
 84     }
 85 
 86     /// <summary>
 87     /// 队尾出队
 88     /// </summary>
 89     /// <param name="edges"></param>
 90     /// <param name="t"></param>
 91     public T Pop_Tail()
 92     {
 93         //判断队列是否已空
 94         if (myQueue.size == 0)
 95             return default(T);
 96 
 97         //逆时针旋转(防止负数)
 98         myQueue.tail = (--myQueue.tail + myQueue.maxSize) % myQueue.maxSize;
 99 
100         var temp = myQueue.list[myQueue.tail];
101 
102         //赋予空值
103         myQueue.list[myQueue.tail] = default(T);
104 
105         myQueue.size--;
106 
107         return temp;
108     }
109 
110     /// <summary>
111     /// 队首入队
112     /// </summary>
113     /// <param name="t"></param>
114     /// <returns></returns>
115     public bool Push_Head(T t)
116     {
117         //判断队列是否已满
118         if (myQueue.size == myQueue.list.Length)
119             return false;
120 
121         //逆时针旋转(防止负数产生)
122         myQueue.head = (--myQueue.head + myQueue.maxSize) % myQueue.maxSize;
123 
124         //赋予元素
125         myQueue.list[myQueue.head] = t;
126 
127         myQueue.size++;
128 
129         return true;
130     }
131 
132     /// <summary>
133     /// 队首出队
134     /// </summary>
135     /// <param name="edges"></param>
136     /// <param name="t"></param>
137     public T Pop_Head()
138     {
139         //判断队列是否已空
140         if (myQueue.size == 0)
141             return default(T);
142 
143         //获取队首元素
144         var temp = myQueue.list[myQueue.head];
145 
146         //原来单位的值赋默认值
147         myQueue.list[myQueue.head] = default(T);
148 
149         //顺时针旋转
150         myQueue.head = (myQueue.head + 1) % myQueue.maxSize;
151 
152         myQueue.size--;
153 
154         return temp;
155     }
156 }

 

posted @ 2013-03-20 18:09  一线码农  阅读(6483)  评论(10编辑  收藏  举报