精华内容
下载资源
问答
  • java链式队列

    2015-12-17 22:01:36
    下面来讨论队列的链式存储,即链队列。 链队列的定义: 队列的链式存储结构简称为链队列。它是限制仅在表头删除和表尾插入的单链表。 链队列的数据存储形式: ... * 链式队列 * Title: LinkedQueue

    下面来讨论队列的链式存储,即链队列。


    链队列的定义:

    队列的链式存储结构简称为链队列。它是限制仅在表头删除和表尾插入的单链表。


    链队列的数据存储形式:


     链队列基本运算的实现:


    /**
     * 
     */
    package unit5Queue.linked;
    
    /**
     * 链式队列
     * <p>Title: LinkedQueue</p>
     * <p>Description: </p>
     * <p>Company: </p>
     * @author 夏 杰
     * @param <T>
     * @date 2015年12月16日 下午11:12:31
     * @vesion 1.0
    */
    public class LinkedQueue<T> {
    	
    	//队列头指针
    	public QueueNode<T> font;
    	//队列头指针
    	public QueueNode<T> rear;
    	//队列数据长度
    	public int size = 0;
    	
    	/**
    	 * 初始化队列
    	 * @param rear
    	 */
    	public LinkedQueue() {
    		QueueNode<T> node = new QueueNode<T>(null,null);
    		node.next = null;
    		font=rear=node;
    		
    	}
    	
    	/**
    	 * 入队列
    	 * @param data
    	 */
    	public  void push(T data){
    		//创建一个新的节点
    		QueueNode<T> node = new QueueNode<T>(data,null);
    		//将新的节点插入队尾(通过rear.next=node 这样连起来)
    		rear.next = node;
    		rear = node;
    		size++;
    	}
    	
    	/**
    	 * 出队列
    	 */
    	public T pop(){
    		
    		if(rear == font){
    			
    			try {
    				throw new Exception("队列为空");
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    			return null;	
    		}else{
    			//node是将要出队列的节点
    			//注意font节点是不存储数据的
    			QueueNode<T> node = font.next;
    			T data = node.data;
    			font.next = node.next;
    			//将要出队列的节点删除掉
    			node = null;
    			size--;
    			return data;
    		}
    		
    	}
    	
    	public boolean isEmpty(){
    		if(font==rear){
    			return true;
    		}
    		return false;
    	}
    	
    	  /** 
         * 队列长队 
         * @return 
         * @author WWX 
         */  
        public int size(){  
            return size;  
        }  
    	
    	public String toString(){
    		if(isEmpty()){
    			return "[]";
    		}else{
    			StringBuilder sb = new StringBuilder("["); 
    			for(QueueNode<T> current = font.next;current!=null;current = current.next){
    				sb.append(current.data.toString() + ",");
    			}
    			int len = sb.length();
    			return sb.delete(len - 2, len).append("]").toString();
    		}
    	}
    	
    	
    	public static void main(String[] args) {
    		LinkedQueue<Integer> queue = new LinkedQueue<Integer>();
    		queue.push(1);
    		queue.push(7);
    		queue.push(6);
    		queue.push(34);
    		queue.push(4);
    		queue.push(33);
    		System.out.println(queue); 
    	    System.out.println("出队:"+queue.pop());  
    	    System.out.println("队列长度="+queue.size());  
    	    System.out.println(queue); 
    	}
    	
    }
    


    展开全文
  • java实现链式队列。。。比较简单package datastruct;public class QueueLink implements Queue {// 定义一个节点内部类class Node {private Object data;private Node next;public Node(Object obj) {this.data = ...

    java实现链式队列。。。比较简单

    package datastruct;

    public class QueueLink implements Queue {

    // 定义一个节点内部类

    class Node {

    private Object data;

    private Node next;

    public Node(Object obj) {

    this.data = obj;

    }

    public Node() {

    }

    }

    // 定义链式队列的一些属性

    private Node head; // 头指针(引用)

    private Node rear; // 尾指针(引用)

    private int length; // 队列的长度,开始为1

    private Node temp; // 临时指针(引用)

    // 初始化队列,空头指针

    public QueueLink() {

    head = new Node();

    rear = head;

    length = 1;

    }

    // 初始化队列,有数据头指针

    public QueueLink(Object obj) {

    head = new Node(obj);

    rear = head;

    length = 1;

    }

    public boolean clear() {

    // TODO Auto-generated method stub

    if(this.length==1){

    return true;

    }else if(length==2){

    head.next=null;

    //没有引用的节点java会自动回收内存

    }else {

    while(head.next.next!=null){

    head.next=head.next.next;

    }

    head.next=null;

    return true;

    }

    return false;

    }

    // 判空

    public boolean isEmpty() {

    // TODO Auto-generated method stub

    if (this.length() == 1) {

    return true;

    } else {

    return false;

    }

    }

    // 获得队列的长度

    public int length() {

    // TODO Auto-generated method stub

    return this.length;

    }

    // 添加一个节点

    public void offer(Object x) {

    this.temp = new Node(x);

    // 队列使用尾插法

    rear.next = temp;

    rear = temp;

    this.length++;

    // TODO Auto-generated method stub

    }

    // 查看第一个节点

    public Node peek() {

    // TODO Auto-generated method stub

    if (length == 1) {

    temp=null;

    } else {

    temp= head.next;

    }

    return temp;

    }

    //删除第一个节点

    public Node poll() {

    // TODO Auto-generated method stub

    if(length==1){

    //无法删除

    temp=null;

    }else

    if(length==2){

    this.temp= head.next;

    //置空下一个节点就可以了

    head.next=null;

    length--;

    }else{

    this.temp= head.next;

    this.head.next=this.head.next.next;

    length--;

    }

    return temp;

    }

    //test

    public static void main(String[] args) {

    QueueLink linkQueue = new QueueLink();

    System.out.println("队列是否为空:"+linkQueue.isEmpty());

    System.out.println("连续入队-------------------------------");

    for(int i=0;i<5;i++){

    linkQueue.offer((char)(97+i));

    }

    System.out.println("队列长度为:"+linkQueue.length());

    System.out.println("队首元素为:"+linkQueue.peek().data);

    //出队

    System.out.println("连续出队-------------------------------");

    for(int i=0;i<4;i++){

    Object data=linkQueue.poll();

    }

    System.out.println("队列长度为:"+linkQueue.length());

    }

    }

    结果为:

    队列是否为空:true

    连续入队-------------------------------

    队列长度为:6

    队首元素为:a

    连续出队-------------------------------

    队列长度为:2

    展开全文
  • 本文通过编码实现链式队列类,并模拟一个有趣的应用,能够帮助我们对链式队列有更深度的理解。基本概念结点每个元素,除了存储其本身的信息(数据域)之外,还需存储一个指示其直接后继存放位置的指针。这两部分信息...

    背景

    队列[Queue]:是一种限定仅在表头进行删除操作,仅在表尾进行插入操作的线性表;即先进先出(FIFO-first in first out):最先插入的元素最先出来。

    本文通过编码实现链式队列类,并模拟一个有趣的应用,能够帮助我们对链式队列有更深度的理解。

    基本概念

    结点

    每个元素,除了存储其本身的信息(数据域)之外,还需存储一个指示其直接后继存放位置的指针。这两部分信息组成数据元素的存储映像,称为结点(Node)。

    1f07357a7135002d1f83584ab9d2c042.png

    代码实现

    /**

    * 结点类

    * * @author zhuhuix

    * @date 2020-05-29

    */

    public class Node {

    // 数据域

    private T data;

    // 指向下一个元素的指针

    private Node next;

    Node(T t, Node n) {

    this.data = t;

    this.next = n;

    }

    public T getData() {

    return data;

    }

    public Node getNext() {

    return next;

    }

    public void setNext(Node next) {

    this.next = next;

    }

    }

    链式队列

    链式队列是由N个结点组成的;

    每个队列有且只有一个队头及队尾;

    入队的结点排在队尾;

    出队的结点只能是队头的结点。

    59be2d520f4310f9e65d020686c0f28f.png

    代码实现

    入队:public void enQueue(T t)

    出队:public T deQueue()

    /**

    * 链队的实现

    *

    * @author zhuhuix

    * @date 2020-05-29

    */

    public class LinkQueue {

    // 队头元素

    private Node front;

    // 队尾元素

    private Node rear;

    // 队列长度

    private Integer length;

    // 构造方法

    public LinkQueue() {

    this.front = this.rear = null;

    this.length = 0;

    }

    // 入队enQueue

    public void enQueue(T t) {

    Node n = new Node<>(t, null);

    if (this.rear != null) {

    this.rear.setNext(n);

    }

    this.rear = n;

    if (this.front==null){

    this.front=n;

    }

    this.length++;

    }

    // 出队deQueue

    public T deQueue() {

    if (this.length == 0) {

    return null;

    }

    T data = this.front.getData();

    this.front = this.front.getNext();

    this.length--;

    return data;

    }

    // 查看队头元素

    public T peek() {

    if (this.length == 0) {

    return null;

    }

    T data = this.front.getData();

    return data;

    }

    //销毁队列

    public void destroy() {

    this.front = null;

    this.rear = null;

    this.length = 0;

    }

    public Integer getLength() {

    return length;

    }

    }

    链式队列的应用

    在java开发中,我们经常会遇到需要处理批量任务的时候,如果是用户提交的发送邮件任务,就会形成一个先进先出的邮件队列。我们接下来编写一个Java程序模拟邮件的批量处理。

    /**

    * 链队应用--邮件类

    *

    * @author zhuhuix

    * @date 2020-05-29

    */

    public class Mail {

    // 发件人

    private String from;

    // 收件人

    private String to;

    // 邮件主题

    private String subject;

    // 邮件内容

    private String content;

    // 邮件大小,单位为K

    private int size;

    public Mail(String from, String to, String subject, String content, int size) {

    this.from = from;

    this.to = to;

    this.subject = subject;

    this.content = content;

    this.size = size;

    }

    public String getFrom() {

    return from;

    }

    public void setFrom(String from) {

    this.from = from;

    }

    public String getTo() {

    return to;

    }

    public void setTo(String to) {

    this.to = to;

    }

    public String getSubject() {

    return subject;

    }

    public void setSubject(String subject) {

    this.subject = subject;

    }

    public String getContent() {

    return content;

    }

    public void setContent(String content) {

    this.content = content;

    }

    public int getSize() {

    return size;

    }

    public void setSize(int size) {

    this.size = size;

    }

    }

    /**

    * 链队的应用--模拟批量邮件发送任务

    *

    * @author zhuhuix

    * @date 2020-05-29

    */

    public class LinkQueueTest {

    public static Long id = 0L;

    public static void main(String[] args) throws InterruptedException {

    // 定义一个链表队列

    LinkQueue queue = new LinkQueue<>();

    // 模拟将100封需要发送的邮件入列

    for(int i=1;i<=100;i++){

    queue.enQueue(new Mail("@","@","第"+i+"封邮件","",i));

    }

    // 开始批量发送100封邮件,并统计所有邮件发送的时间

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");

    Long start = System.currentTimeMillis();

    System.out.println("开始时间:" + sdf.format(start));

    while(queue.getLength()>0){

    // 用随机数模拟发送邮件的时长

    Random random = new Random();

    TimeUnit.MILLISECONDS.sleep(random.nextInt(1000));

    System.out.println("正在发送"+queue.deQueue().getSubject());

    }

    Long end = System.currentTimeMillis();

    System.out.println("结束时间:" + sdf.format(end));

    System.out.println("耗用了" + (end - start) + "毫秒");

    }

    }

    代码分析

    定义一个邮件类;

    建立一个存放邮件发送任务的链式队列;

    生成100封邮件进入发送队列;

    队列按先进先出顺序发送任务:在程序随机数生成模拟发送时间,并显示当前发送任务;

    输出总共发送任务时长。

    结果输出如下:

    f43da09ab49875dd0a21ff9175556137.png

    730b29484942bc492563ca875710a315.png

    展开全文
  • * 链式队列 */ public class LinkQueue<T> implements Serializable{ private static final long serialVersionUID = -6726728595616312615L; //定义一个内部类Node,Node实例代表...
    import java.io.Serializable;
     
    /**
     * 链式队列
     */
    public class LinkQueue<T> implements Serializable{
      private static final long serialVersionUID = -6726728595616312615L;
     
      //定义一个内部类Node,Node实例代表链队列的节点。
      private class Node {
        
        private T data;//保存节点的数据
       
        private Node next;//指向下个节点的引用
     
        //无参数的构造器
        public Node() {
        }
     
        //初始化全部属性的构造器
        public Node(T data, Node next) {
          this.data = data;
          this.next = next;
        }
      }
      
      private Node front;//保存该链队列的头节点
      
      private Node rear;//保存该链队列的尾节点
     
      private int size;//保存该链队列中已包含的节点数
     
      /**
       * <p>Title: LinkQueue </p>     
       * <p>Description: 创建空链队列 </p> 
       */
      public LinkQueue() {
        //空链队列,front和rear都是null
        front = null;
        rear = null;
      }
     
      /**
       * <p>Title: LinkQueue </p>    
       * <p>Description: 以指定数据元素来创建链队列,该链队列只有一个元素</p> 
       */
      public LinkQueue(T element) {
        front = new Node(element, null);
        //只有一个节点,front、rear都指向该节点
        rear = front;
        size++;
      }
     
      /**
       * @Title: size     
       * @Description: 获取顺序队列的大小    
       * @return
       */
      public int size() {
        return size;
      }
     
      /**
       * @Title: offer     
       * @Description: 入队    
       * @param element
       */
      public void offer(T element) {
        //如果该链队列还是空链队列
        if (front == null) {
          front = new Node(element, null);     
          rear = front;//只有一个节点,front、rear都指向该节点
        } else {     
          Node newNode = new Node(element, null);//创建新节点     
          rear.next = newNode;//让尾节点的next指向新增的节点     
          rear = newNode;//以新节点作为新的尾节点
        }
        size++;
      }
     
      /**
       * @Title: poll     
       * @Description: 出队    
       * @return
       */
      public T poll() {
        Node oldFront = front;
        front = front.next;
        oldFront.next = null;
        size--;
        return oldFront.data;
      }
     
      /**
       * @Title: peek     
       * @Description: 返回队列顶元素,但不删除队列顶元素    
       * @return
       */
      public T peek() {
        return rear.data;
      }
     
      /**
       * @Title: isEmpty     
       * @Description: 判断顺序队列是否为空队列    
       * @return
       */
      public boolean isEmpty() {
        return size == 0;
      }
     
      /**
       * @Title: clear     
       * @Description: 清空顺序队列
       */
      public void clear() {
        //将front、rear两个节点赋为null
        front = null;
        rear = null;
        size = 0;
      }
     
      public String toString() {
        //链队列为空链队列时
        if (isEmpty()) {
          return "[]";
        } else {
          StringBuilder sb = new StringBuilder("[");
          for (Node current = front; current != null; current = current.next) {
            sb.append(current.data.toString() + ", ");
          }
          int len = sb.length();
          return sb.delete(len - 2, len).append("]").toString();
        }
      }
     
      public static void main(String[] args) {
        LinkQueue<String> queue = new LinkQueue<String>("aaaa");
        //添加两个元素
        queue.offer("bbbb");
        queue.offer("cccc");
        System.out.println(queue);
        //删除一个元素后
        queue.poll();
        System.out.println("删除一个元素后的队列:" + queue);
        //再次添加一个元素
        queue.offer("dddd");
        System.out.println("再次添加元素后的队列:" + queue);
        //删除一个元素后,队列可以再多加一个元素
        queue.poll();
        //再次加入一个元素
        queue.offer("eeee");
        System.out.println(queue);
      }
    }
    
    展开全文
  • importjava.util.ArrayList;importjava.util.Arrays;importjava.util.List;/****@authorlyx*@下午2:15:41*@TODO:*基数排序——多关键字排序*多关键字排序的思路是将待排数据里德排序关键字拆分成多个排序关键字;*第...
  • 一、基数排序描述基数排序(radix sort)属于"分配式排序"(distribution sort),又称"桶子法"(bucket sort)或bin sort,顾名思义,它是透过键值的部份资讯,将要排序的元素分配至某些"桶"中,藉以达到排序的作用,基数...
  • 99 } View Code 链式时间复杂度: 顺序实现: 1 //库函数头文件包含 2 #include 3 #include 4 #include 5 6 7 //函数状态码定义 8 #define TRUE 1 9 #define FALSE 0 10 #define OK 1 11 #define ERROR 0 12 #define...
  • 执行基数排序可采用链表的存储结构,用一个长度为n的单链表r存放待排序的n个记录,再使用两个长度为rd的一维数组f和e,分别存放rd个队列中指向队首结点和队尾结点的指针: 形成初始链表 将最小的关键字值作为当前...
  • 题目:利用队列实现对某一个数据序列的排序(采用基数排序),其中对数据序列的数据(第1和第2条进行说明)和队列的存储方式(第3条进行说明)有如下的要求:1)当数据序列是整数类型的数据的时候,数据序列中每个数据的...
  • 所谓链式基数排序,就是实现基数排序时,为减少所需的辅助存储空间,应采用链表作存储结构,即链式基数排序。... 2、“分配” 时,按当前“关键字位”所取值,将记录分配到不同的 “链队列” 中,每个队...
  • 各队列采用链式队列结构,分配到同一队列的关键码用链接指针链接起来。每一队列设置两 个队列指针: int front [radix]指示队头, int rear [radix] 指向队尾。 为了有效地存储和重排 n 个待排序对象,以静态链表...
  • java队列实现方法(顺序队列,链式队列,循环队列)发布于 2020-7-24|复制链接下面小妖就为大家分享一篇java队列实现方法(顺序队列,链式队列,循环队列),具有很好的参考价值,希望对大家有所帮助。一起跟随小妖过来看看...
  • 双向顺序队列ArrayDeque和双向链式队列LinkedList,JDK已经包含,在此略。ArrayDeque包括顺序栈和顺序队列,LinkedList包含链式栈和链式队列。ArrayDeque和LinkedList都是线程不安全的。PriorityQueue优先队列也在...
  • Java实现队列——队列内部使用链式存储结构链队列 代码:packagehash;/***CreatedwithIntelliJIDEA.*User:ASUS*Date:14-9-17*Time:上午11:58*TochangethistemplateuseFile|Settings|FileTemplates.*/...
  • Java实现链式队列

    千次阅读 2016-07-28 15:23:44
    Java实现链式队列
  • Java实现队列——顺序队列、链式队列 概念 先进者先出,这就是典型的“队列”。(First In, First Out,FIFO)。 我们知道,栈只支持两个基本操作:入栈push()和出栈pop()。队列跟栈非常相似,支持的操作也很有限,最...
  • java队列实现(顺序队列、链式队列、循环队列)
  • Java创建链式队列

    2021-04-03 10:29:50
    Java创建链式队列 更改成了可以互动的创建形式 来源:...
  • java实现链式队列

    2018-11-13 10:05:00
    java实现链式队列。。。比较简单 package datastruct; public class QueueLink implements Queue { // 定义一个节点内部类 class Node { private Object data; private Node next; public ...
  • 下面小编就为大家分享一篇java队列实现方法(顺序队列,链式队列,循环队列),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 队列(Queue)​ 队列是一种具有一定操作约束的线性表,它的插入和删除操作都只能在一端进行,数据插入叫做入队,数据删除称为出队,它是一种典型的先进先出(FIFO)的结构。抽象数据类型描述​ 数据对象集:一个有0个或...
  • Java实现顺序队列SeqQueue.classpackage sequence; import java.util.Arrays; public class SeqQueue&lt;T&gt; { private int front; private int rear; private T[] elementData; //private int ...
  • Java链式队列

    2018-11-19 11:10:00
    参考https://www.cnblogs.com/lixiaolun/p/4646312.html java实现链队列的类代码: 1 package linkqueue; 2 3 public class LinkQueue { 4 5 class Element 6 { 7 Object elem; ...
  • 链式队列 什么是链式队列? 数据结构的基本问题。队列 是一种特殊的线性表,它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作。进行插入操作的端称为队尾,进行删除操作的端称为队头。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 620
精华内容 248
关键字:

java链式队列

java 订阅