数据结构-基本队列的实现

灰太狼 2023-06-01 05:53 83阅读 0赞

基于实现二次封装数组https://blog.csdn.net/qq_39313596/article/details/101630245来实现

github 地址:https://github.com/heng1234/data-structure

队列接口

  1. package com.company.Queue;
  2. /**
  3. * Queue
  4. * 队列接口
  5. * @author heng
  6. **/
  7. public interface Queue<E>{
  8. /**
  9. * 存入队列中
  10. * @param e
  11. */
  12. void enqueue(E e);
  13. /**
  14. * 从队列中取出一个元素 出队
  15. * @return
  16. */
  17. E dequeue();
  18. /**
  19. * 拿到队首
  20. * @return
  21. */
  22. E getFront();
  23. /**
  24. * 大小
  25. * @return
  26. */
  27. int getSize();
  28. /**
  29. * 是否为空
  30. * @return
  31. */
  32. boolean isEmpty();
  33. }

实现类

  1. package com.company.Queue;
  2. import com.company.Array.Array;
  3. /**
  4. * ArrayQueue
  5. * 队列的实现
  6. * @author heng
  7. * @date 2019/10/1
  8. **/
  9. public class ArrayQueue<E> implements Queue<E> {
  10. /**
  11. * 初始化容器
  12. */
  13. private Array<E> array;
  14. /**
  15. * 初始化大小
  16. * @param capacity
  17. */
  18. public ArrayQueue(int capacity){
  19. array = new Array<>(capacity);
  20. }
  21. /**
  22. * 没有传入则默认大小
  23. */
  24. public ArrayQueue(){
  25. array = new Array<>();
  26. }
  27. /**
  28. * 存入队列中
  29. * @param e
  30. */
  31. @Override
  32. public void enqueue(E e) {
  33. array.addLast(e);
  34. }
  35. /**
  36. * 从队列中取出一个元素 出队
  37. * @return
  38. */
  39. @Override
  40. public E dequeue() {
  41. return array.removeFirst();
  42. }
  43. /**
  44. * 拿到队首
  45. * @return
  46. */
  47. @Override
  48. public E getFront() {
  49. return array.getFirst();
  50. }
  51. /**
  52. * 大小
  53. * @return
  54. */
  55. @Override
  56. public int getSize() {
  57. return array.getSize();
  58. }
  59. /**
  60. * 是否为空
  61. * @return
  62. */
  63. @Override
  64. public boolean isEmpty() {
  65. return array.isEmpty();
  66. }
  67. /**
  68. * 查看有多少容积
  69. * @return
  70. */
  71. public int getCapacity(){
  72. return array.getCapacaity();
  73. }
  74. @Override
  75. public String toString(){
  76. StringBuilder builder = new StringBuilder();
  77. builder.append("Queue: front [");
  78. for (int i = 0; i < array.getSize(); i++) {
  79. builder.append(array.get(i));
  80. if (i != array.getSize()-1){
  81. builder.append(" , ");
  82. }
  83. }
  84. builder.append("] tail");
  85. return builder.toString();
  86. }
  87. }

测试:

  1. public static void main(String[] args) {
  2. ArrayQueue<Integer> queue = new ArrayQueue<>();
  3. for (int i = 0; i < 10; i++) {
  4. queue.enqueue(i);
  5. System.out.println(queue);
  6. if (i % 3 == 2){
  7. queue.dequeue();
  8. System.out.println(queue);
  9. }
  10. }
  11. }

发表评论

表情:
评论列表 (有 0 条评论,83人围观)

还没有评论,来说两句吧...

相关阅读

    相关 基本操作 数据结构

    队列(queue)也是线性表的一种特殊情况,其所有的插入均限定在表的一端进行,而所有的删除则限定在表的另一端进行。允许插入的一端称队尾(rear),允许删除的一端称队头(fro

    相关 数据结构系列-基本操作

    队列(Queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表。允许插入的端是队尾,允许删除的端是队头。 所以说队列是一个先进先出的线性表,相应的也有顺序存储和