2021-08-24

最新推荐文章于 2024-11-03 11:01:20 发布

刘大浪

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量78

点赞数

文章标签： java 算法数据结构

本文链接：https://blog.csdn.net/qq_41739657/article/details/119881047

版权

Duque 常用方法

Deque接口继承了Queue的接口规范。LinkedList、ArrayDeque都是实现Deque接口。

   Queue<-----Duque<-----LinkedList、ArrayDeque 是常用的数据结构，可以将队列看成特殊的线性表，队列限制了对线性表的访问方式：只能从线性表的一端添加（offer）元素，从另一端取出（poll）元素。Queue接口：在包 java.util.Queue。

1）队列遵循先进先出原则：FIFO（First Input First Output）队列不支持插队，插队是不道德的。
2）JDK 中提供了 Queue 接口，同时使得 LinkedList 实现了该接口（选择 LinkedList 实现Queue 的原因在于 Queue 经常要进行插入和删除的操作，而 LinkedList 在这方面效率较高）。
方法：
①boolean offer(E e)：将一个对象添加至队尾，如果添加成功则返回 true。
②poll()：从队列中取出元素，取得的是最早的 offer 元素，从队列中取出元素后，该元素会从队列中删除。若方法返回 null 说明队列中没有元素了。
③peek()：获取队首的元素（不删除该元素!）

package day0607;

import java.util.LinkedList;
import java.util.Queue;

/**
* @author Limi
* Queue 队列     先进先出
*/
public class Demo04 {
  public static void main(String[] args) {
  	Queue<Integer> queue = new LinkedList<Integer>();
  	for(int i=0;i<=10;i++){
  		queue.offer(i);
  	}
  	System.out.println(queue);
  	
  	/*
  	 * peek()：获取队首的元素（不删除该元素!）
  	 */
  	System.out.println("peek():"+queue.peek());
  	
  	/*
  	 * poll()：从队列中取出元素，取得的是最早的 offer 元素，从队列中取出元素后，
  	 * 该元素会从队列中删除。若方法返回 null 说明 队列中没有元素了。
  	*/
  	Integer integer = null;
  	while((integer=queue.poll()) != null){
  		System.out.print(integer);
  	}
  	
  	System.out.println("\npeek():"+queue.peek());
  }
}

LinkedList类是双向列表（底层使用链表结构），列表中的每个节点都包含了对前一个和后一个元素的引用。LinkedList有很多方法，通过这些方法可以很容易将其用作队列、栈等数据结构。

1、常用方法：

1）获取第一、最后一个元素：

LinkedListlist = new LinkedList();

System.out.println("链表的第一个元素是: " + list.getFirst());

System.out.println("链表最后一个元素是: " + list.getLast());

2）生成子链表：

List sub = list.subList(1, 3);//subList(int fromIndex,int toIndex)下标从0开始，不包含最后的toIndex

System.out.println(sub);

3）插入：

publicboolean add(Object element)：元素将被添加到链表的最后；

public boolean add(int index, Object element)：元素将被添加到链表指定索引的位置（从0开始）；

publicboolean addFirst(Object element)：在头部插入；

publicboolean addLast(Object element)：在尾部插入；

4）删除元素：

remove()：删除第一个元素；

remove(int index)：删除指定索引位置的元素（从0开始）；

removeFirst()：删除第一个元素；

removeLast()：删除最后一个元素；

clear()：清空列表；

list.subList(1,3).clear()：根据范围删除列表元素；

5）将LinkedList转换成ArrayList：

ArrayListarrayList = new ArrayList(linkedList);

6）查找元素位置：

list.indexOf(“e”);//下标从0开始

7）替换元素：

set(int index, element);//下标从0开始

8）是否包含元素：

list.contains(“eeee”);//返回true或者false

2、实现队列：

importjava.util.LinkedList;

importjava.util.Queue;

public classMyQueue {
private Queue storage = newLinkedList();

/** 将指定的元素插入队尾 */

public void offer(T v) {
    storage.offer(v);

}



/** 检索，但是不移除队列的头，如果此队列为空，则返回 null */

public T peek() {
    return storage.peek();

}



/** 检索，但是不移除此队列的头 */

/** 此方法与 peek 方法的惟一不同是，如果此队列为空，它会抛出一个异常 */

public T element() {
    return storage.element();

}



/** 检索并移除此队列的头，如果队列为空，则返回 null */

public T poll() {
    return storage.poll();

}



/** 检索并移除此队列的头 */

/** 此方法与 poll 方法的不同在于，如果此队列为空，它会抛出一个异常 */

public T remove() {
    return storage.remove();

}



/** 队列是否为空 */

public boolean empty() {
    return storage.isEmpty();

}



/** 打印队列元素 */

public String toString() {
    return storage.toString();

}

}

说明：使用java.util.Queue接口,其底层关联到一个LinkedList（双端队列）实例。由于只暴露部分基于队列实现的接口，所以可以提供安全的队列实现。

3、实现栈：

importjava.util.LinkedList;

public classStack {
private LinkedList storage = newLinkedList();

 /** 入栈 */

public void push(T v) {
   storage.addFirst(v);

}



 /** 出栈，但不删除 */

public T peek() {
   return storage.getFirst();

}



 /** 出栈 */

public T pop() {
   return storage.removeFirst();

}



 /** 栈是否为空 */

public boolean empty() {
   return storage.isEmpty();

}



 /** 打印栈元素 */

public String toString() {
   return storage.toString();

}

}