算法新手模块学习之单链表实现队列，栈 双链表实现双端队列

最新推荐文章于 2022-09-13 09:00:45 发布
最新推荐文章于 2022-09-13 09:00:45 发布
阅读量127 收藏 1
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45541247/article/details/115355581
版权

单链表实现队列，栈

首先定义一个单链表Node

    static class Node<V> {
        Node next;
        V value;

        public Node(V value) {
            this.value = value;
        }
    }

单链表实现队列，遵循先进先出，后进后出
简单画图说一下解法思路，这里拿inPutTail方法为例（我觉得链表问题画画图就好理解好多了）
第一次插入的时候，因为是从尾巴插入的，所以判断尾巴为空的话就将head和tail指向当前值node（图中的圆圈就是当前值node）
在这里插入图片描述
第二次插入的时候，尾巴不为空，所以将尾巴的下一个节点指向当前值node,尾巴指向当前值
在这里插入图片描述
也就是在这里插入图片描述
以此类推

 static class MyQueue<V> {
     Node<V> head;
     Node<V> tail;
     int size ;

     public MyQueue() {
         head = null;
         tail = null;
         size = 0;
     }

     public void inPutTail(V value) {
         Node node = new Node(value);
         if (tail == null) {
             head = node;
             tail = node;
         } else {
             tail.next = node;
             tail = node;
         }
         size++;
     }

     public V outPutHead() {
         if (head==null){
             return null;
         }
         V value = head.value;
         head = head.next;
         size--;
         if (head==null){
             tail =null;
         }
         return value;
     }

     public V peekHead() {
         if (head==null){
             return null;
         }
         V value = head.value;
         return value;
     }

     public Integer getSize() {
         return size;
     }

     public boolean isEmpty() {
         return size == 0;
     }

 }

单链表实现栈，遵循先进后出，后进先出
inPutHead方法为例
第一次插入的时候，因为是从头插入的，所以判断头为空的话就将head指向当前值node
在这里插入图片描述
第二次插入的时候，头不为空，当前值的下一个节点指向老头，老头指向当前值成为新头
在这里插入图片描述
也就是
在这里插入图片描述
以此类推

   static class Mystack<V>{
       Node<V> head ;
       int size;

       public Mystack() {
           head = null;
           size = 0 ;
       }

       public void inPutHead(V value){
           Node<V> node = new Node<>(value);
           if (head==null){
               head = node;
           }else {
               node.next = head;
               head = node;
           }
           size++;
       }
       public V outPutHead(){
           if (head==null){
               return null;
           }
           V value = head.value;
           head = head.next;
           size--;
           return value;
       }
       public V peekHead(){
           return head == null?null:head.value;
       }
       public Integer getSize() {
           return size;
       }

       public boolean isEmpty() {
           return size == 0;
       }
   }

写个对数器来检验写的队列和栈是否正确，其实就是利用queue队列和随机数检验

 public static void testQueue() {
     MyQueue<Integer> myQueue = new MyQueue<>();
     Queue<Integer> test = new LinkedList<>();
     int testTime = 5000000;
     int maxValue = 200000000;
     System.out.println("开始！");
     for (int i = 0; i < testTime; i++) {
         if (myQueue.isEmpty() != test.isEmpty()) {
             System.out.println("错了1!");
         }
         if (myQueue.getSize() != test.size()) {
             System.out.println("错了2!");
         }
         double decide = Math.random();
         if (decide < 0.33) {
             int num = (int) (Math.random() * maxValue);
             myQueue.inPutTail(num);
             test.offer(num);
         } else if (decide < 0.66) {
             if (!myQueue.isEmpty()) {
                 int num1 = myQueue.outPutHead();
                 int num2 = test.poll();
                 if (num1 != num2) {
                     System.out.println("错了3!");
                 }
             }
         } else {
             if (!myQueue.isEmpty()) {
                 int num1 = myQueue.peekHead();
                 int num2 = test.peek();
                 if (num1 != num2) {
                     System.out.println("错了4!");
                 }
             }
         }
     }
     if (myQueue.getSize() != test.size()) {
         System.out.println("错了5!");
     }
     while (!myQueue.isEmpty()) {
         int num1 = myQueue.outPutHead();
         int num2 = test.poll();
         if (num1 != num2) {
             System.out.println("错了6!");
         }
     }
     System.out.println("结束！");
 }

 public static void testStack() {
     Mystack<Integer> myStack = new Mystack<>();
     Stack<Integer> test = new Stack<>();
     int testTime = 5000000;
     int maxValue = 200000000;
     System.out.println("开始！");
     for (int i = 0; i < testTime; i++) {
         if (myStack.isEmpty() != test.isEmpty()) {
             System.out.println("错了1!");
         }
         if (myStack.getSize()!= test.size()) {
             System.out.println("错了2!");
         }
         double decide = Math.random();
         if (decide < 0.33) {
             int num = (int) (Math.random() * maxValue);
             myStack.inPutHead(num);
             test.push(num);
         } else if (decide < 0.66) {
             if (!myStack.isEmpty()) {
                 int num1 = myStack.outPutHead();
                 int num2 = test.pop();
                 if (num1 != num2) {
                     System.out.println("错了3!");
                 }
             }
         } else {
             if (!myStack.isEmpty()) {
                 int num1 = myStack.peekHead();
                 int num2 = test.peek();
                 if (num1 != num2) {
                     System.out.println("错了4!");
                 }
             }
         }
     }
     if (myStack.getSize() != test.size()) {
         System.out.println("错了5!");
     }
     while (!myStack.isEmpty()) {
         int num1 = myStack.outPutHead();
         int num2 = test.pop();
         if (num1 != num2) {
             System.out.println("错了6!");
         }
     }
     System.out.println("结束！");
 }

双链表实现双端队列
首先定义一个双链表

static class Node<V> {
       Node next;
       Node last;
       V value;

       public Node(V value) {
           this.value = value;
       }
   }

双链表实现双端队列，实现弹出头，弹出尾，插入头，插入尾等
这里拿inPutHead画图简单解释一下
第一次插入头，头尾都指向当前值node
在这里插入图片描述
第二次插入头，老头的上一节点指向当前值，当前值的下一节点指向老头，老头指向当前值成为新头
在这里插入图片描述
即
在这里插入图片描述
以此类推

 static class MyDequeue<V> {
        Node<V> head;
        Node<V> tail;
        int size;

        public MyDequeue() {
            head = null;
            tail = null;
            size = 0;
        }

        public void inPutHead(V value) {
            Node<V> node = new Node<>(value);
            if (head == null) {
                head = node;
                tail = node;
            } else {
                head.last = node;
                node.next = head;
                head = node;
            }
            size++;
        }

        public void inPutTail(V value) {
            Node<V> node = new Node<>(value);
            if (tail == null) {
                tail = node;
                head = node;
            } else {
                tail.next = node;
                node.last = tail;
                tail = node;
            }
            size++;
        }

        public V outPutHead() {
            if (head == null) {
                return null;
            }
            V ans = head.value;
            if (head.next != null) {
                head = head.next;
                head.last = null;

            } else {
                head = tail = null;
            }
            size--;
            return ans;
        }

        public V outPutTail() {
            if (tail == null) {
                return null;
            }
            V ans = tail.value;
            if (tail.last != null) {
                tail = tail.last;
                tail.next = null;

            } else {
                head = tail = null;
            }
            size--;
            return ans;
        }

        public V peekHead() {
            V ans = null;
            if (head != null) {
                ans = head.value;
            }
            return ans;
        }

        public V peekTail() {
            V ans = null;
            if (tail != null) {
                ans = tail.value;
            }
            return ans;
        }

        public Integer getSize() {
            return size;
        }

        public boolean isEmpty() {
            return size == 0;
        }

    }

对数器检验是否正确，其实就是利用deque双端队列和随机数检验

 public static void testDeque() {
        MyDequeue<Integer> myDeque = new MyDequeue<>();
        Deque<Integer> test = new LinkedList<>();
        int testTime = 5000000;
        int maxValue = 200000000;
        System.out.println("开始！");
        for (int i = 0; i < testTime; i++) {
            if (myDeque.isEmpty() != test.isEmpty()) {
                System.out.println("错了1!");
            }
            if (myDeque.getSize() != test.size()) {
                System.out.println("错了2!");
            }
            double decide = Math.random();
            if (decide < 0.33) {
                int num = (int) (Math.random() * maxValue);
                if (Math.random() < 0.5) {
                    myDeque.inPutHead(num);
                    test.addFirst(num);
                } else {
                    myDeque.inPutTail(num);
                    test.addLast(num);
                }
            } else if (decide < 0.66) {
                if (!myDeque.isEmpty()) {
                    int num1 = 0;
                    int num2 = 0;
                    if (Math.random() < 0.5) {
                        num1 = myDeque.outPutHead();
                        num2 = test.pollFirst();
                    } else {
                        num1 = myDeque.outPutTail();
                        num2 = test.pollLast();
                    }
                    if (num1 != num2) {
                        System.out.println("错了3!");
                    }
                }
            } else {
                if (!myDeque.isEmpty()) {
                    int num1 = 0;
                    int num2 = 0;
                    if (Math.random() < 0.5) {
                        num1 = myDeque.peekHead();
                        num2 = test.peekFirst();
                    } else {
                        num1 = myDeque.peekTail();
                        num2 = test.peekLast();
                    }
                    if (num1 != num2) {
                        System.out.println("错了4!");
                    }
                }
            }
        }
        if (myDeque.getSize() != test.size()) {
            System.out.println("错了5!");
        }
        while (!myDeque.isEmpty()) {
            int num1 = myDeque.outPutHead();
            int num2 = test.pollFirst();
            if (num1 != num2) {
                System.out.println("错了6!");
            }
        }
        System.out.println("结束！");
    }
大头虾！！
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双端队列的实现
愿君出走半生，归来时仍是少年
06-03 1425
原题：试采用一维数组实现循环的双端队列，即可以在任意一端入队列与出队列，并实现以下公操作：初始化、判空、求元素个数、入队列与出队列。分析：用tag(=1、2)来标识对哪一端操作，tag==1时对front端操作，tag==2时对rear端操作。 #include #include typedef enum{FALSE,TRUE,OK,ERROR,OVER_FLOW}Status; #d
Java基于双向链表实现双端队列结构(算法源码)
01-21
/* * 基于双向链表实现双端队列结构 */ package dsa; public class Deque_DLNode implements Deque { protected DLNode header;//指向头节点（哨兵） protected DLNode trailer;//指向尾节点（哨兵） protected int size;//队列中元素的数目 //构造函数 public Deque_DLNode() { header = new DLNode(); trailer = new DLNode(); header.setNext(trailer); trailer.setPrev(header); size = 0; } //返回队列中元素数目 public int getSize() { return size; } //判断队列是否为空 public boolean isEmpty() { return (0 == size) ? true : false; } //取首元素（但不删除） public Object first() throws ExceptionQueueEmpty { if (isEmpty()) throw new ExceptionQueueEmpty("意外：双端队列为空"); return header.getNext().getElem(); } //取末元素（但不删除） public Object last() throws ExceptionQueueEmpty { if (isEmpty()) throw new ExceptionQueueEmpty("意外：双端队列为空"); return trailer.getPrev().getElem(); } //在队列前端插入新节点 public void insertFirst(Object obj) { DLNode second = header.getNext(); DLNode first = new DLNode(obj, header, second); second.setPrev(first); header.setNext(first); size++; } //在队列后端插入新节点 public void insertLast(Object obj) { DLNode second = trailer.getPrev(); DLNode first = new DLNode(obj, second, trailer); second.setNext(first); trailer.setPrev(first); size++; } //删除首节点 public Object removeFirst() throws ExceptionQueueEmpty { if (isEmpty()) throw new ExceptionQueueEmpty("意外：双端队列为空"); DLNode first = header.getNext(); DLNode second = first.getNext(); Object obj = first.getElem(); header.setNext(second); second.setPrev(header); size--; return(obj); } //删除末节点 public Object removeLast() throws ExceptionQueueEmpty { if (isEmpty()) throw new ExceptionQueueEmpty("意外：双端队列为空"); DLNode first = trailer.getPrev(); DLNode second = first.getPrev(); Object obj = first.getElem(); trailer.setPrev(second); second.setNext(trailer); size--; return(obj); } //遍历 public void Traversal() { DLNode p = header.getNext(); while (p != trailer) { System.out.print(p.getElem()+" "); p = p.getNex
单链表与双链表队列
xiezhihua261的博客
11-12 349
一，链表分类：单链表与双向链表；     二，链表定义：数据域(data)与指针域(node)的下一个节点(next)，头节点(head),上一个节点(pre);     三，定义类；          (1)Node类：传值与重写get,set方法；          (2)LinkNodeList类；将对数据的增删差改的基本操作方法或属性；          (3)main();主函
数据结构与算法分析 3.26 — 双端队列的实现
aqjh9999的博客
10-05 591
一、题目 编写支持双端队列的例程，插入与弹出操作均花费 O(1)时间 二、解答 双端队列（deque，全名double-ended queue）是一种具有队列和栈性质的数据结构。 双端队列中的元素可以从两端弹出，插入和删除操作限定在队列的两边进行。 基本操作：在双端队列两端插入与删除。 ADT术语： ...
Python使用单向链表来实现栈、队列、双端队列
NEW_TIM的博客
03-20 485
Python使用单向链表来实现栈、队列、双端队列 首先是单向链表相关函数的构造 dan_1.py #代码实现单向链表by Fan class Node(object): # 节点,数据区加链接区 def __init__(self,elem): self.elem = elem self.next = None class SingleLinkList(object): #单向链表，定义头 def __init__(self,node = N
Python实现的数据结构与算法之双端队列详解
12-25
本文实例讲述了Python实现的数据结构与算法之双端队列。分享给大家供大家参考。具体分析如下： 一、概述 双端队列（deque，全名double-ended queue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队...
Python编程实现双链表，栈，队列及二叉树的方法示例
12-24
本文实例讲述了Python编程实现双链表，栈，队列及二叉树的方法。分享给大家供大家参考，具体如下： 1.双链表 class Node(object): def __init__(self, value=None): self._prev = None self.data = value self....
C++数据结构与算法之双缓存队列实现方法详解
08-29
主要介绍了C++数据结构与算法之双缓存队列实现方法,结合实例形式分析了双缓存队列的原理、实现方法与相关注意事项,需要的朋友可以参考下
用双向链表实现双端队列
任意门的博客
11-08 363
/** * 用双向链表实现双端队列 * 双端队列 可以从头进 也可以从尾进，可以从头出，也可以从尾出 */ public class Code03_DoubleLinkedListToDeque { public static class Node<V>{ public V value; public Node<V> last; public Node<V> next; public Nod
python 数据结构与算法-队列的实现与双端队列
zuyuhuo6777的博客
12-11 179
  1、队列的实现 code: # -*- coding: utf-8 -*- """ Created on Tue Dec 11 16:45:47 2018 @author: Xavier """ class Queue(object): #取的那一端是队头，插入的那一端是队尾 #队列 def __init__(self): #构造函数胡 ...
Python数据结构与算法之 队列与双端队列的实现
xxs8457800的博客
03-02 146
和栈一样， 队列可以用顺序表和链表实现。 添加数据用的多，取数据用得少， 使用self.__list.append(item) # -*- coding: UTF-8 -*- class Quene(object): #构造函数 # 顺序表实现队列 def __init__(self): self.__list = [] def enqueue(s...
双端队列 C 实现
you-know-who的博客
03-31 4603
双端队列可以前插后插前删后删，通过数组实现，这里给出基本功能： 头文件如下：#ifndef _Double_Queue_H #define _Double_Queue_H struct PtrToNode; typedef struct PtrToNode *double_Queue; typedef int Item; double_Queue initial(void); int isE
【算法导论】10.1-5单数组实现双端队列
苦咖啡的自留地
01-02 2139
算法导论习题，单数组实现双端队列，欢迎拍砖！
数据结构与算法—5、双端队列的实现
qq_46645079的博客
01-14 139
数据结构与算法—双端队列的实现接口代码 接口 Dequeue接口 package p1.接口; public interface Dequeue<E> extends Queue<E> { public void addFirst(E element); public void addLast(E element); public E removeFirst(); public E reomveLast(); public E getFirs
java数据结构与算法-双端链表实现队列
zhizhuodewo6的博客
08-15 289
一、使用双端链表实现队列代码如下： import android.util.Log; /** * Created by Xi on 2017/8/1. * 使用链表实现队列的队列 */ public class QueueLink { private LinkListQueue theList; public QueueLink(){ theList=n
如何实现一个双端队列？
小K算法
09-13 443
关注下方公众号，分享硬核知识作者 | 小K出品 | 公众号：小K算法 （ID：xiaok365）01故事起源队列是一种先进先出的数据结构。一般通过数组实现。还需要定义2个指针，头指针和尾指针。02插入和删除2.1插入从队尾tail处插入，再将tail指针后移。2.2删除从队首head处取出元素，再将head指针后移。但数组是定长的，如果多次插入删除，tail指针就会超出数组范围，而前面其实还是有空...
栈+队列+双端队列的代码实现+排序算法的稳定性+冒泡排序+选择排序+插入算法
weixin_51589123的博客
04-21 247
栈 实质上就是一种容器，可以存放数据元素、访问元素、删除元素 栈数据结构只允许在一端进行操作，按照后进先出（LIFO）的原理操作。 栈描述的数据如何操作，而顺序表描述的是数据如何存储 #压栈 class Stack(object): def __init__(self): self.__list = [] def push(self, item): ''' 添加一个新元素，item到栈顶''' self.__list.app
算法课程-双端队列随机队列-作业
xiexie1357的专栏
01-13 228
题意理解 实现一个双端队列，实现一个随机队列，其中，随机队列是每次出元素是随机从队列中取出一个元素。 问题分析 双端队列利用链表实现，随机队列利用数组实现。 实现迭代器支持循环遍历。 java参数值的获取方法。 其他 链接 /* ****************************************************************************...
队列算法可以用链表实现吗
最新发布
06-01
是的，队列算法可以用链表实现，这种实现方式被称为链式队列（Linked Queue）。 链式队列使用链表来存储元素，不需要预先指定队列的容量，因此可以动态地增加或减少元素。链式队列有两个指针，一个指向队头，一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值