码迷，mamicode.com
首页 > 编程语言 > 详细

java 实现数据结构之队列

时间：2014-10-06 01:29:19      阅读：331      评论：0      收藏：0      [点我收藏+]

标签：blog   http   io   os   ar   java   for   数据   sp   

转自：http://zengzhaoshuai.iteye.com/blog/1171716

————————————————————————————————————————————

队列是一种特殊的线性表，它只允许在表的前端(front)进行删除操作，只允许在表的后端（rear）进行插入操作。 
1.队列的顺序存储结构及实现 

Java代码  bubuko.com,布布扣
  1. public class SequenceQueue<T>  
  2. {  
  3.     private int DEFAULT_SIZE = 10;  
  4.     //保存数组的长度。  
  5.     private int capacity;  
  6.     //定义一个数组用于保存顺序队列的元素  
  7.     private Object[] elementData;  
  8.     //保存顺序队列中元素的当前个数  
  9.     private int front = 0;  
  10.     private int rear = 0;  
  11.     //以默认数组长度创建空顺序队列  
  12.     public SequenceQueue()  
  13.     {  
  14.         capacity = DEFAULT_SIZE;  
  15.         elementData = new Object[capacity];  
  16.     }  
  17.     //以一个初始化元素来创建顺序队列  
  18.     public SequenceQueue(T element)  
  19.     {  
  20.         this();  
  21.         elementData[0] = element;  
  22.         rear++;  
  23.     }  
  24.     /** 
  25.      * 以指定长度的数组来创建顺序队列 
  26.      * @param element 指定顺序队列中第一个元素 
  27.      * @param initSize 指定顺序队列底层数组的长度 
  28.      */  
  29.     public SequenceQueue(T element , int initSize)  
  30.     {  
  31.         this.capacity = initSize;  
  32.         elementData = new Object[capacity];  
  33.         elementData[0] = element;  
  34.         rear++;  
  35.     }  
  36.     //获取顺序队列的大小  
  37.     public int length()  
  38.     {  
  39.         return rear - front;  
  40.     }  
  41.     //插入队列  
  42.     public void add(T element)  
  43.     {  
  44.         if (rear > capacity - 1)  
  45.         {  
  46.             throw new IndexOutOfBoundsException("队列已满的异常");  
  47.         }  
  48.         elementData[rear++] = element;  
  49.     }  
  50.     //移除队列  
  51.     public T remove()  
  52.     {  
  53.         if (empty())  
  54.         {  
  55.             throw new IndexOutOfBoundsException("空队列异常");  
  56.         }  
  57.         //保留队列的rear端的元素的值  
  58.         T oldValue = (T)elementData[front];  
  59.         //释放队列的rear端的元素  
  60.         elementData[front++] = null;   
  61.         return oldValue;  
  62.     }  
  63.     //返回队列顶元素，但不删除队列顶元素  
  64.     public T element()  
  65.     {  
  66.         if (empty())  
  67.         {  
  68.             throw new IndexOutOfBoundsException("空队列异常");  
  69.         }  
  70.         return (T)elementData[front];  
  71.     }  
  72.     //判断顺序队列是否为空队列  
  73.     public boolean empty()  
  74.     {  
  75.         return rear == front;  
  76.     }  
  77.     //清空顺序队列  
  78.     public void clear()  
  79.     {  
  80.         //将底层数组所有元素赋为null  
  81.         Arrays.fill(elementData , null);  
  82.         front = 0;  
  83.         rear = 0;  
  84.     }  
  85.     public String toString()  
  86.     {  
  87.         if (empty())  
  88.         {  
  89.             return "[]";  
  90.         }  
  91.         else  
  92.         {  
  93.             StringBuilder sb = new StringBuilder("[");  
  94.             for (int i = front  ; i < rear ; i++ )  
  95.             {  
  96.                 sb.append(elementData[i].toString() + ", ");  
  97.             }  
  98.             int len = sb.length();  
  99.             return sb.delete(len - 2 , len).append("]").toString();  
  100.         }  
  101.     }  
  102. }  


2.循环队列（顺序结构存储实现） 

Java代码  bubuko.com,布布扣
  1. import java.util.Arrays;  
  2. public class LoopQueue<T>  
  3. {  
  4.     private int DEFAULT_SIZE = 10;  
  5.     //保存数组的长度。  
  6.     private int capacity;  
  7.     //定义一个数组用于保存循环队列的元素  
  8.     private Object[] elementData;  
  9.     //保存循环队列中元素的当前个数  
  10.     private int front = 0;  
  11.     private int rear = 0;  
  12.     //以默认数组长度创建空循环队列  
  13.     public LoopQueue()  
  14.     {  
  15.         capacity = DEFAULT_SIZE;  
  16.         elementData = new Object[capacity];  
  17.     }  
  18.     //以一个初始化元素来创建循环队列  
  19.     public LoopQueue(T element)  
  20.     {  
  21.         this();  
  22.         elementData[0] = element;  
  23.         rear++;  
  24.     }  
  25.     /** 
  26.      * 以指定长度的数组来创建循环队列 
  27.      * @param element 指定循环队列中第一个元素 
  28.      * @param initSize 指定循环队列底层数组的长度 
  29.      */  
  30.     public LoopQueue(T element , int initSize)  
  31.     {  
  32.         this.capacity = initSize;  
  33.         elementData = new Object[capacity];  
  34.         elementData[0] = element;  
  35.         rear++;  
  36.     }  
  37.     //获取循环队列的大小  
  38.     public int length()  
  39.     {  
  40.         if (empty())  
  41.         {  
  42.             return 0;  
  43.         }  
  44.         return rear > front ? rear - front   
  45.             : capacity - (front - rear);  
  46.     }  
  47.     //插入队列  
  48.     public void add(T element)  
  49.     {  
  50.         if (rear == front   
  51.             && elementData[front] != null)  
  52.         {  
  53.             throw new IndexOutOfBoundsException("队列已满的异常");  
  54.         }  
  55.         elementData[rear++] = element;  
  56.         //如果rear已经到头，那就转头  
  57.         rear = rear == capacity ? 0 : rear;  
  58.     }  
  59.     //移除队列  
  60.     public T remove()  
  61.     {  
  62.         if (empty())  
  63.         {  
  64.             throw new IndexOutOfBoundsException("空队列异常");  
  65.         }  
  66.         //保留队列的rear端的元素的值  
  67.         T oldValue = (T)elementData[front];  
  68.         //释放队列的rear端的元素  
  69.         elementData[front++] = null;   
  70.         //如果front已经到头，那就转头  
  71.         front = front == capacity ? 0 : front;  
  72.         return oldValue;  
  73.     }  
  74.     //返回队列顶元素，但不删除队列顶元素  
  75.     public T element()  
  76.     {  
  77.         if (empty())  
  78.         {  
  79.             throw new IndexOutOfBoundsException("空队列异常");  
  80.         }  
  81.         return (T)elementData[front];  
  82.     }  
  83.     //判断循环队列是否为空队列  
  84.     public boolean empty()  
  85.     {  
  86.         //rear==front且rear处的元素为null  
  87.         return rear == front   
  88.             && elementData[rear] == null;  
  89.     }  
  90.     //清空循环队列  
  91.     public void clear()  
  92.     {  
  93.         //将底层数组所有元素赋为null  
  94.         Arrays.fill(elementData , null);  
  95.         front = 0;  
  96.         rear = 0;  
  97.     }  
  98.     public String toString()  
  99.     {  
  100.         if (empty())  
  101.         {  
  102.             return "[]";  
  103.         }  
  104.         else  
  105.         {  
  106.             //如果front < rear，有效元素就是front到rear之间的元素  
  107.             if (front < rear)  
  108.             {  
  109.                 StringBuilder sb = new StringBuilder("[");  
  110.                 for (int i = front  ; i < rear ; i++ )  
  111.                 {  
  112.                     sb.append(elementData[i].toString() + ", ");  
  113.                 }  
  114.                 int len = sb.length();  
  115.                 return sb.delete(len - 2 , len).append("]").toString();  
  116.             }  
  117.             //如果front >= rear，有效元素为front->capacity之间、0->front之间的  
  118.             else  
  119.             {  
  120.                 StringBuilder sb = new StringBuilder("[");  
  121.                 for (int i = front  ; i < capacity ; i++ )  
  122.                 {  
  123.                     sb.append(elementData[i].toString() + ", ");  
  124.                 }  
  125.                 for (int i = 0 ; i < rear ; i++)  
  126.                 {  
  127.                     sb.append(elementData[i].toString() + ", ");  
  128.                 }  
  129.                 int len = sb.length();  
  130.                 return sb.delete(len - 2 , len).append("]").toString();  
  131.             }  
  132.         }  
  133.     }  
  134. }  


3.队列的链式存储结构及实现 

Java代码  bubuko.com,布布扣
    1. public class LinkQueue<T>  
    2. {  
    3.     //定义一个内部类Node，Node实例代表链队列的节点。  
    4.     private class Node  
    5.     {  
    6.         //保存节点的数据  
    7.         private T data;  
    8.         //指向下个节点的引用  
    9.         private Node next;  
    10.         //无参数的构造器  
    11.         public Node()  
    12.         {  
    13.         }  
    14.         //初始化全部属性的构造器  
    15.         public Node(T data ,  Node next)  
    16.         {  
    17.             this.data = data;  
    18.             this.next = next;  
    19.         }  
    20.     }  
    21.     //保存该链队列的头节点  
    22.     private Node front;  
    23.     //保存该链队列的尾节点  
    24.     private Node rear;  
    25.     //保存该链队列中已包含的节点数  
    26.     private int size;  
    27.     //创建空链队列  
    28.     public LinkQueue()  
    29.     {  
    30.         //空链队列，front和rear都是null  
    31.         front = null;  
    32.         rear = null;  
    33.     }  
    34.     //以指定数据元素来创建链队列，该链队列只有一个元素  
    35.     public LinkQueue(T element)  
    36.     {  
    37.         front = new Node(element , null);  
    38.         //只有一个节点，front、rear都指向该节点  
    39.         rear = front;  
    40.         size++;  
    41.     }  
    42.     //返回链队列的长度    
    43.     public int length()  
    44.     {  
    45.         return size;  
    46.     }  
    47.     //将新元素加入队列  
    48.     public void add(T element)  
    49.     {  
    50.         //如果该链队列还是空链队列  
    51.         if (front == null)  
    52.         {  
    53.             front = new Node(element , null);  
    54.             //只有一个节点，front、rear都指向该节点  
    55.             rear = front;  
    56.         }  
    57.         else  
    58.         {  
    59.             //创建新节点  
    60.             Node newNode = new Node(element , null);  
    61.             //让尾节点的next指向新增的节点  
    62.             rear.next = newNode;  
    63.             //以新节点作为新的尾节点  
    64.             rear = newNode;  
    65.         }  
    66.         size++;  
    67.     }  
    68.     //删除队列front端的元素  
    69.     public T remove()  
    70.     {  
    71.         Node oldFront = front;  
    72.         front = front.next;  
    73.         oldFront.next = null;  
    74.         size--;  
    75.         return oldFront.data;  
    76.     }  
    77.     //访问链式队列中最后一个元素  
    78.     public T element()  
    79.     {  
    80.         return rear.data;  
    81.     }  
    82.     //判断链式队列是否为空队列  
    83.     public boolean empty()  
    84.     {  
    85.         return size == 0;  
    86.     }  
    87.     //清空链队列  
    88.     public void clear()  
    89.     {  
    90.         //将front、rear两个节点赋为null  
    91.         front = null;  
    92.         rear = null;  
    93.         size = 0;  
    94.     }  
    95.     public String toString()  
    96.     {  
    97.         //链队列为空链队列时  
    98.         if (empty())  
    99.         {  
    100.             return "[]";  
    101.         }  
    102.         else  
    103.         {  
    104.             StringBuilder sb = new StringBuilder("[");  
    105.             for (Node current = front ; current != null  
    106.                 ; current = current.next )  
    107.             {  
    108.                 sb.append(current.data.toString() + ", ");  
    109.             }  
    110.             int len = sb.length();  
    111.             return sb.delete(len - 2 , len).append("]").toString();  
    112.         }  
    113.     }  
    114. }  

java 实现数据结构之队列

标签：blog   http   io   os   ar   java   for   数据   sp   

原文地址：http://www.cnblogs.com/kaikailele/p/4007851.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！