LinkedList(链表)模仿先进先出或者先进后出

最新推荐文章于 2024-08-11 22:52:46 发布
原创 最新推荐文章于 2024-08-11 22:52:46 发布 · 6.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文介绍了如何使用LinkedList在Java中实现先进先出(FIFO)或先进后出(LIFO)策略。通过addFirst, addLast, removeFirst和removeLast方法的组合，可以灵活地设计存储和取出元素的顺序。例如，！First与*Frist结合使存取顺序相反，而！Last与*Last结合也有类似效果。" 51674037,5223081,PHP接收Android JSON数据存库并返回JSON响应,"['PHP', 'Android开发', '数据库操作', 'MySQL', 'Linux']

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

 前注：本文参考传智博客毕向东老师的java教学视屏加上本菜鸟的一些总结理解，错漏之处烦请各位批评改正，望共同进步。
一 所用主要方法介绍
1.removedFirst（移除对象）
  removedLast
2.addFirst(添加对象)
  addLast
3.isEmpty(判断元素是否为空)

二 代码展示（以下代码是毕向东老师）
LinkedList list = new LinkList();//获取LinkdeList对象
//添加对象
List.addFirst("abc1");
List.addFirst("abc2");
List.addFirst("abc3");
List.addFirst("abc4");
//判断元素是否为空，不为空就取出对象。
while(！list.isEmpty){
System.out.println(List.removedFirst()))
}
结果： 





abc4

abc3

abc2

abc1


三 体会：可以代替Iterator。可以用addFirst ， addLast ， removeFirst ， removeLast重新组合。


！代表add ，*代表remove


用！First和*Frist组合那么存入和取出顺序相反


用！Last和*Last组合那么存入和取出顺序相反


用！First和*Last。。。。。。。（自己实验）

四 end

java_haha努力更新中。。。下篇再见。

                

        

    

    
  



    



                



	

		

			

				
					
BAT 大厂Java 面试题集锦之核心篇附参考答案

				
			

			

				

					AI天才研究院
				

				

					11-05
					
					1万+
					
				

			

		

		

			
				
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...

			
		

	



                

            
              



	

		

			

				
					
【学习笔记】数据结构之单链表（先进先出、先进后出）

				
			

			

				

					J小白的博客
				

				

					03-24
					
					7133
					
				

			

		

		

			
				
先看下数据结构中一种重要的数据存储形式，链表，下面两段是来自百度百科：
   链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。...

			
		

	



              


  
              

                


	

		

			

				
					
利用LinkedList类构造一个先进后出的堆栈

				
			

			

				

					weixin_49884545的博客
				

				

					11-09
					
					324
					
				

			

		

		

			
				
利用LinkedList类构造一个先进后出的堆栈。


代码如下
import java.util.LinkedList;
import java.util.Scanner;

class StringStack {
    private LinkedList<String> ld = new LinkedList<String>();

    public void push(String s) {             //入栈操作
        ld.addFirs..

			
		

	





	

		

			

				
					
LinkeList基本方法和先进先出

				
			

			

				

					qq_38598020的博客
				

				

					04-08
					
					2789
					
				

			

		

		

			
				
LinkedList其实也就是我们在数据结构中的链表，这种数据结构有这样的特性：分配内存空间不是必须是连续的；插入、删除操作很快，只要修改前后指针就OK了，时间复杂度为O(1)；访问比较慢，必须得从第一个元素开始遍历，时间复杂度为O(n)；LinkedList其实也就是我们在数据结构中的链表，这种数据结构有这样的特性：    1、分配内存空间不是必须是连续的；    2、插入删除操作很快，时间复杂...

			
		

	



		

			
		



	

		

			

				
					
2.3线性表的链式存储结构（链表生成：先入先/后出）

				
			

			

				

					jzj_c_love的博客
				

				

					10-24
					
					471
					
				

			

		

		

			
				
数据结构学习笔记（二）
2.3.1单链表
1.单链表的一般形式

知道一个概念 头结点和首节点
头结点其中没有数据，首节点作为数据域的一部分
如图所示


建立链表的代码
struct node
{
       ElemType data;
       struct node *next;
};
//使用typedef定义指针类型
typedef struct node
{
       El...

			
		

	





	

		

			

				
					
java list 先进先出_java中List集合及其遍历详解

				
			

			

				

					weixin_42464967的博客
				

				

					02-12
					
					4048
					
				

			

		

		

			
				
1. 首先List集合继承与Collection，是一个接口。① Collection (集合框架是JDK1.2版本出现的)② list:是有序的，元素可以重复，以为该集合体系有索引。经常用到的是实现该接口的ArrayList和LinkedList类③ Arraylist: 底层的数据结构使用的是数组结构，特点： 查询速度很快，但是增删稍慢。线程不同步LinkedList： 底层使用的...

			
		

	





	

		

			

				
					
LinkedList : 请用LinkedList模拟栈数据结构的集合，并测试 栈：先进后出 题目的要求是：自己创建一个类，将LinkedList作为成员变量，将来创建自己的类对象

				
			

			

				

					ABU009的博客
				

				

					08-11
					
					247
					
				

			

		

		

			
				
#LinkedList#模拟出栈

			
		

	





	

		

			

				
					
使用LinkedList来模拟堆栈或队列数据结构

				
			

			

				

					linweieran的博客
				

				

					10-24
					
					840
					
				

			

		

		

			
				
最近一直在学习集合，其中使用比较多的就是LinkedList，那么什么是LinkedList呢。在list中共有三种容器，LinkedList是容器的一种，具体介绍如下，

List:
|--Vector：组数据结构，是同步的（效率低，几乎不用），可增长。增删查询都很慢！
|--LinkedList：内部是数组数据结构，是不同步的（效率高），大小可变的，代替了Vector。查询速度快
...

			
		

	





	

		

			

				
					
Java_Programs:在辅导网站上用作示例的 Java 程序

				
			

			

				

					07-05
				

			

		

		

			
				
3. **队列**：队列是一种先进先出（FIFO）的数据结构，与银行排队类似。Java的`java.util.Queue`接口和`java.util.LinkedList`类可以用来实现队列。队列在任务调度、事件处理和多线程中扮演重要角色。  4. **链表**...

			
		

	





	

		

			

				
					
Lista05_EstruturaDados_EX02

				
			

			

				

					03-18
				

			

		

		

			
				
4. 队列（Queue）：队列是一种先进先出（FIFO）的数据结构，像排队等候一样。Java提供了java.util.Queue接口，可以使用LinkedList或其他实现类来创建队列。  5. 树（Tree）：树数据结构包括二叉树、平衡树（如AVL树...

			
		

	





	

		

			

				
					
java使用链表实现栈（先进后出）

				
			

			

				

					入眸幻灭的博客
				

				

					04-10
					
					1498
					
				

			

		

		

			
				
public class LinkStack &lt;Item&gt; implements Iterable&lt;Item&gt;{

    private Node first;//栈顶
    private int N;//元素数量
    private Node temp;//遍历对象
    public boolean isEmpty(){
        return N==...

			
		

	





	

		

			

				
					
如何使用LinkedList完成一个堆栈（先进后出）

				
			

			

				

					atangxue的博客
				

				

					06-17
					
					395
					
				

			

		

		

			
				

			
		

	





	

		

			

				
					
链表实现栈（先进后出）

				
			

			

				

					qq_58595750的博客
				

				

					01-28
					
					456
					
				

			

		

		

			
				
定义类：


public class ListNode {

    int val;
    ListNode next;

    public ListNode(int val) {
        this.val = val;
        this.next = null;
    }

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val

			
		

	





	

		

			

				
					
LinkedList集合模拟栈的先进后出

				
			

			

				

					weixin_40487115的博客
				

				

					10-24
					
					799
					
				

			

		

		

			
				
1



			
		

	





	

		

			

				
					
Java之链表实现先进先出队列/可迭代泛型数据类型

				
			

			

				

					qq_16118409的博客
				

				

					05-11
					
					604
					
				

			

		

		

			
				
话不多说，直接进入正题吧，代码很详细：
/*
 1.链表是一种递归的数据结构，它或者为空（null），或者是指向一个节点（node）的引用，该节点含有一个泛型的元素和一个指向另一条链表的引用；
 2.嵌套类来定义抽象数据类型：
   private class Node
   {
     Item item;
     Node next;
   }
  3.Node的初始化为null;
  4...

			
		

	





	

		

			

				
					
先进先出队列(链表实现)

				
			

			

				

					王二的专栏
				

				

					05-10
					
					2252
					
				

			

		

		

			
				
import java.util.Scanner;
import java.util.Iterator;

// 先进先出队列
public class MyQueue implements Iterable {
	private Node first;
	private Node last;
	private int N;
	
	private class Node{
		Item item;


			
		

	





	

		

			

				
					
Java04——LinkedList详细介绍(源码解析)和使用示例

				
			

			

				

					JasonChen3318的博客
				

				

					08-30
					
					278
					
				

			

		

		

			
				
一、LinkedList介绍


LinkedList是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
LinkedList实现List接口，能对它进行队列操作。
LinkedList实现Deque接口，即能将LinkedList当作双端队列使用。
LinkedList实现了Cloneable接口，即覆盖了函数clo...

			
		

	





	

		

			

				
					
入理解ArrayList与LinkedList的区别

				
			

			

				

					pbyang_love的博客
				

				

					07-26
					
					215
					
				

			

		

		

			
				


ArrayList与LinkedList都是List接口的实现类，只是实现的方式有所不同，而List接口继承了Collection接口，Collection接口又继承了Iterable接口，因此可以看出List同时拥有了Collection与Iterable接口的特性。

一、理解ArrayList

ArrayList实现了List接口,它是以数组的方式来实现的,数组的特性是可以使用索引的方...

			
		

	





	

		

			

				
					
Java用链表实现队列

				
			

			

				

					♂戏子无情♂的博客
				

				

					05-18
					
					281
					
				

			

		

		

			
				
队列（queue）：是一种特殊的线性表，特殊之处在于它遵从先进先出原则，它只允许在表的前端进行删除操作，而在表的后端进行插入操作，队列和栈一样是一种操作受限制的表，进行插入操作的端称之为队尾，进行删除操作的端称之为队头，队列中没有元素时称之为空队列。向队尾进行插入操作称之为入队，向队头进行删除操作称之为出，队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除（先进先出原则）。
1、初始化（创建）队列
public class QueueLinkedList {
    priv

			
		

	





	

		

			

				
					
java中栈和队列

					
最新发布

				
			

			

				

					03-15
				

			

		

		

			
				
<think>好的，我现在需要帮助用户理解Java中栈和队列的概念及实现。用户已经提供了一些参考资料，我需要仔细梳理这些信息，并按照用户的要求组织回答。

首先，用户提到系统级指令，要求使用中文回答，生成相关问题，并正确应用引用标识。同时，回答需要结构清晰，分步解释。用户给出的示例中，快速排序部分有代码示例和相关问题，我需要模仿这种结构。

接下来，我需要分析用户提供的引用内容。引用[1]和[3]提到了栈和队列的不同实现方式，比如链式队列、顺序栈，以及用数组或链表实现栈。引用[2]和[5]展示了如何用栈实现队列，以及栈的基本方法如push、pop、peek。引用[4]则比较了队列的方法，如element()和peek()的区别。

我需要将这些信息整合成栈和队列的概念、实现方式、使用方法，以及常见问题。首先，栈是后进先出（LIFO）结构，队列是先进先出（FIFO）。Java中的实现可以通过集合框架中的类，如LinkedList、ArrayDeque，或者自己用数组/链表实现。

然后，需要分别说明栈和队列的标准库用法，比如使用Deque接口作为栈和队列，以及各自的方法。比如栈的push、pop、peek，队列的offer、poll、peek等。还要注意异常处理，比如pop在空栈时会抛出异常，而poll返回null。

接下来是代码示例，用户提供的引用中有几个例子，比如用两个栈实现队列，或者用数组实现栈。需要选择合适的代码片段，确保语法正确，并符合用户的要求。比如引用[2]中的MyQueue类，使用两个栈来模拟队列，这可能是一个好的例子。

然后，用户要求生成相关问题，我需要根据内容提出三个相关问题，可能涉及性能比较、实现方式的选择、异常处理等。

同时，要注意引用标识的正确添加，每个引用来源在回答中的适当位置标注，比如在提到栈的数组实现时引用[3]，在讨论队列方法时引用[4]。

还需要检查LaTeX格式是否正确，确保数学表达式用$...$包裹，独立公式用$$...$$，但根据问题内容，可能数学公式较少，主要关注代码和文本结构。

最后，确保回答结构清晰，分点讲解，帮助用户逐步理解栈和队列的实现与用法，并附上相关问题以供进一步学习。</think>### Java中栈和队列的实现与用法详解

#### 一、基本概念
1. **栈（Stack）**  
   遵循**后进先出（LIFO）**原则，核心操作包括入栈（`push`）、出栈（`pop`）和查看栈顶元素（`peek`）。Java中可通过`Deque`接口模拟栈[^5]。

2. **队列（Queue）**  
   遵循**先进先出（FIFO）**原则，核心操作包括入队（`offer`）、出队（`poll`）和查看队首元素（`peek`）。`Deque`接口支持双端队列操作[^1]。

---

#### 二、标准库实现方式
##### 1. 栈的实现
- **链式栈**：通过`LinkedList`实现  
  ```java
  Deque<Integer> stack = new LinkedList<>();
  stack.push(1);  // 入栈
  stack.pop();    // 出栈
  ```
- **顺序栈**：通过`ArrayDeque`实现（推荐）[^3]  
  ```java
  Deque<Integer> stack = new ArrayDeque<>();
  ```

##### 2. 队列的实现
- **链式队列**：使用`LinkedList`  
  ```java
  Queue<Integer> queue = new LinkedList<>();
  queue.offer(1);  // 入队
  queue.poll();    // 出队
  ```
- **顺序队列**：使用`ArrayDeque`（线程不安全但高效）[^1]  
  ```java
  Deque<Integer> queue = new ArrayDeque<>();
  ```

---

#### 三、核心方法对比
| **操作** | **栈方法**         | **队列方法**               | 说明                                      |
|----------|--------------------|---------------------------|-----------------------------------------|
| 添加元素 | `push(e)`          | `offer(e)`                | 栈顶/队尾插入元素                          |
| 移除元素 | `pop()`            | `poll()`                  | 栈顶/队首移除元素（空时`pop`抛异常，`poll`返回`null`）[^4] |
| 查看元素 | `peek()`           | `peek()`                  | 查看栈顶/队首元素（空时返回`null`）          |

---

#### 四、相互实现案例
##### 1. 用栈实现队列（满足FIFO）
```java
class MyQueue {
    private Stack<Integer> A = new Stack<>();
    private Stack<Integer> B = new Stack<>();
    
    public void push(int x) {
        while (!B.isEmpty()) A.push(B.pop());
        A.push(x);
        while (!A.isEmpty()) B.push(A.pop());  // 通过双栈反转顺序[^2]
    }
    public int pop() { return B.pop(); }
}
```

##### 2. 用队列实现栈（满足LIFO）
```java
class MyStack {
    Queue<Integer> queue = new LinkedList<>();
    
    public void push(int x) {
        queue.offer(x);
        for (int i = 1; i < queue.size(); i++) {
            queue.offer(queue.poll());  // 通过循环移动元素模拟栈
        }
    }
    public int pop() { return queue.poll(); }
}
```

---

#### 五、应用场景
- **栈**：函数调用栈、括号匹配、表达式求值  
- **队列**：消息队列、线程池任务调度、广度优先搜索（BFS）

---

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值