java数据结构之双端队列

博客强调理解数据结构原理并实践验证。以Java代码展示双端队列的实现,包括节点初始化、添加元素到前后端、从前后端删除元素等操作,还给出了测试代码,演示了双端队列的使用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

//其实数据结构我们首先要去理解其原理,然后通过实践来验证自己的想法,是一个很不错的选择
//如果你们看到了我前期链表的设计
//再来理解双端队列其实也是很简单的,
/*
 *主要是要注意到,在Node初始化时

就对Node的prev或next进行了指定
 *这也是理解双端队列的关键
 */

public class DQueue<E> {

    public DQueue() {
        firstNode = null ;
        lastNode = null ;
        size = 0 ;
    }
    private class Node{
        public E e ;
        public Node prev ;
        public Node next ;
        public Node(E e , Node prev ,Node next) {
            this.e = e ;
            this.prev = prev ;
            this.next = next ;
        }
    }
    
    private int size ;
    private Node firstNode ;
    private Node lastNode ;
    
    public void addToFront(E e) {
        Node newNode =new Node(e , null , firstNode) ;
        if(firstNode == null) {
            firstNode = newNode ;
            lastNode = newNode ;
        } else {
            firstNode.prev = newNode ;
            firstNode = newNode ;
        }
        size ++ ;
    }
    
    public void addToBack(E e) {
        Node newNode = new Node(e , lastNode , null) ;
        if(lastNode == null) {
            lastNode = newNode ;
            firstNode = newNode ;
        } else {
            lastNode.next = newNode  ;
            lastNode = newNode ;
        }
        size ++ ;
    }
    
    //从前端删除元素
    public E removeFront() {
        if(isEmpty()) {
            throw new IllegalArgumentException("空异常") ;
        }
        Node retNode = firstNode ;
        if(size == 1) {
            firstNode = lastNode = null ;
            size -- ;
        } else {
            firstNode = firstNode.next ;
            size -- ;
        }
        return retNode.e ;
    }

    //从后端删除元素
    public E removeLast() {
        if(isEmpty()) {
            throw new IllegalArgumentException("空异常") ;
        }
        Node retNode = lastNode ;
        if(size == 1) {
            firstNode = lastNode = null ;
            size -- ;
        } else {
            lastNode = lastNode.prev ;
            size -- ;
        }
        return retNode.e ;
    }    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public int getSize() {
        return size ;
    }
    
    public void clear() {
        firstNode = lastNode = null ; 
        size = 0 ;
    }
    
    public E getFront() {
        return firstNode.e ;
    }
    
    public E getLast() {
        return lastNode.e ;
    }
    
    public static void main(String[] args) {
        DQueue<Integer> dqueue = new DQueue<>() ;
        dqueue.addToFront(1);//1
        dqueue.addToFront(2);//21
        dqueue.addToFront(3);//321
        dqueue.addToFront(4);//4321
        dqueue.addToFront(5);//54321
        dqueue.addToBack(6);//543216
        dqueue.addToBack(7);//5432167
        
        System.out.println("获取第一个元素:");
        System.out.println(dqueue.getFront());
        System.out.println("获取最后一个元素");
        System.out.println(dqueue.getLast());
        System.out.println("输出数组大小");
        System.out.println(dqueue.getSize());
        int n = dqueue.getSize() ;
        for(int i =0 ; i < n ; i ++) {
            System.out.println("删除第1个元素:" + dqueue.removeFront());
        }
        System.out.println("分割线=============================分割线");
        dqueue.addToFront(1);
        dqueue.addToFront(2);
        dqueue.addToFront(3);
        dqueue.addToFront(4);
        dqueue.addToFront(5);
        dqueue.addToBack(6);
        dqueue.addToBack(7);
        /**
         * 删除第一个元素的结果为:5432167
         * 删除最后一个元素的结果为:7612345
         */
        for(int i =0 ; i < n ; i ++) {
            System.out.println("删除最后1个元素" + dqueue.removeLast());
        }

    }
}

 

/* * 基于双向链表实现双端队列结构 */ 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
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值