用链表实现队列

最新推荐文章于 2022-09-04 17:42:03 发布
最新推荐文章于 2022-09-04 17:42:03 发布
阅读量196 收藏
点赞数
分类专栏： java 文章标签： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/happy_zhourong/article/details/84418827
版权 
package nodelist;

public class LinkNode {
	public Object data;//节点内的数据对象
	public LinkNode next;//对下一个节点的引用
	
}


package nodelist;
/**
 * 用链表实现一个队列
 * @author zr
 *
 */
public class NodeList {
	private LinkNode root;
	private int size;
	private int count=1;
	LinkNode tem1=new LinkNode();//实例化一个节点tem1作为一个临时节点使用
	public NodeList(LinkNode root){
		this.root=root;
	}
	
	/**
	 * 向队列中加入一个元素
	 * @param obj 要向队列中加入的元素
	 */
	public void add(Object obj){
		
		if(root==null){
			root=new LinkNode();//实例化一个根节点
			root.data=obj;
			tem1=root;//将tem1指向根节点root
//			System.out.println("if---tem1.data="+tem1.data);
		}else{
//			System.out.println("else---tem1.data="+tem1.data);
			LinkNode tem=new LinkNode();//实例化一个节点tem
			tem.data=obj;
			//tem1=root;//注意:不能在此处将tem1指向root，否则，每次加入的新元素都加在了root后面
			tem1.next=tem;//将tem1的下一个节点指向tem
			tem1=tem;//将tem1指向tem
//			System.out.println("tem1.data="+tem1.data);
//			System.out.println("root.data="+root.data);
		}
	
			}
	
	/**
	 * 获取链表指定位置的节点
	 * @param index 指定的位置
	 * @return
	 */
	public LinkNode get(int index){
		LinkNode node=new LinkNode();
		LinkNode tem=root;
		while(count<index||count==index){
			if(count==index){
				node=tem;
			}
			count++;
			tem1=tem.next;
			tem=tem1;		
		}
		return node;
		
	}
	
	/**
	 * 获得队列的长度
	 * @return 返回队列的长度
	 */
	public int size(){
//		System.out.println("size---root.data="+root.data);
		LinkNode tem=root;
		while(tem!=null){
			size++;
			tem1=tem.next;
			tem=tem1;
			//System.out.println("tem.data="+tem.data);
		}
//		System.out.println("size="+size);
		return size;
		
	}

}


package nodelist;

import nodelist.LinkNode;
/**
 * 测试用链表实现的队列
 * @author zr
 *
 */
public class Test {
	private static LinkNode root;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Test t=new Test();
		NodeList nl=new NodeList(root);
		nl.add("根节点");
 
	        nl.add("节点1");
  
		nl.add("节点2");
 
		nl.add("节点3");
  
		nl.add("节点4");
  
		root=nl.getRoot();
		t.printLinkList(root);
		int size=nl.size();
		System.out.println("链表的长度为："+size);
		LinkNode node=nl.get(4);
		System.out.println("第4个节点的值为："+node.data);
	}
	
	
	/**
	 * 遍历一个链表
	 * @param lroot 链表的根节点
	 */
	public void printLinkList(LinkNode lroot){
		if(lroot!=null){
			System.out.println(lroot.data);
			LinkNode tem=new LinkNode();
			tem=lroot.next;
			printLinkList(tem);
		}
	}

}

 

结果：

根节点
节点1
节点2
节点3
链表的长度为：4
第4个节点的值为：节点3

 

往队列中添加元素:

 

第一个节点进来时：

tem1=root;//将tem1指向根节点root，此时tem1和root指向的是同一个地址

 

  

第二个节点进来时：

tem1.next=tem;//将tem1的下一个节点指向tem,因为root和tem1指向的是同一个地址，所以root.next也指向了tem

tem1=tem;//将tem1指向tem,此时tem1和tem指向同一个地址（此时tem所指向的地址）

   

 

第三个节点进来时:

tem1.next=tem;//将tem1的下一个节点指向tem,由于此时的tem1和上一次的tem指向的是同一个地址，所以tem.next也指向了tem

tem1= tem;//将tem1指向tem,此时tem1和tem指向同一个地址（此时tem所指向的地址）

 

 

 

 

第四个节点进来时：

tem1.next=tem;//将tem1的下一个节点指向tem, 由于此时的tem1和上一次的tem指向的是同一个地址，所以tem.next也指向了tem

 

tem1=tem;//将tem1指向tem, 此时tem1和tem指向同一个地址（此时tem所指向的地址） 

 

  

上面向队列中添加元素只能在链表为空的情况下添加，通过以上分析，下面我们来完善一下add()方法，使得无论链表是否为空，我们都可以向队列中添加元素。

 

分析：

当链表不为空时；

上例是首先将tem1指向了root节点，然后如上所述添加了新的节点；在这里，我们可以把tem1指向最后一个节点，然后如上所述添加新的节点。

 

tem1=end;//将tem1指向end，此时tem1和end指向同一地址

 

 

 

tem1.next=tem;//将tem1.next指向了tem,由于上一步tem1和tem1指向了同一地址，所以tem1也指向了tem

tem1=tem;//将tem1指向tem,此时tem1和tem指向了同一地址

 

 

 

我们如何获取最后一个节点呢？

1、  先求出已有链表的长度index,所以我们需要写一个求链表长度的方法LinkListSize()；

2、  链表最后一个节点的位置就是index；

3、  然后我们要获得最后一个节点，所以我们需要一个获取链表上某一指定位置节点的方法get(int index);

 

关键代码如下：

/**
 * 用链表实现一个队列
 * @author zr
 *
 */

public class NodeList {
	private LinkNode root;
	LinkNode tem1=new LinkNode();//实例化一个节点tem1作为一个临时节点使用
	public NodeList(LinkNode root){
		this.root=root;
	}
	
	/**
	 * 向队列中加入一个元素
	 * @param obj 要向队列中加入的元素
	 */
	public void add(Object obj){
		
		if(root==null){
			root=new LinkNode();//实例化一个根节点
			root.data=obj;
		}else{
			
			LinkNode tem=new LinkNode();//实例化一个节点tem
			tem.data=obj;
			int index=LinkListSize();//获得链表的长度
			tem1=get(index);//获得链表的最后一个节点
			//tem1=root;//注意:不能在此处将tem1指向root，否则，每次加入的新元素都加在了root后面
			tem1.next=tem;//将tem1的下一个节点指向tem
			tem1=tem;//将tem1指向tem
		}
	
	}
	
	/**
	 * 当链表不为空时，向队列中加入元素
	 * @param obj
	 * @return 返回链表根节点
	 */
	public LinkNode add1(Object obj){
		int index=LinkListSize();
		LinkNode end=get(index);
		System.out.println("end.data="+end.data);
		LinkNode tem=new LinkNode();
		tem.data=obj;
		tem1=end;//将tem1指向end
		tem1.next=tem;
		tem1=tem;
		System.out.println("tem1.data="+tem1.data);
		return root;
		
	}
	
	/**
	 * 获取链表指定位置的节点
	 * @param index 指定的位置
	 * @return
	 */
	public LinkNode get(int index){
		int count=1;
		LinkNode node=new LinkNode();
		LinkNode tem=new LinkNode();
		LinkNode tem1=new LinkNode();
		tem=root;
		while(count<index||count==index){
			if(count==index){
				node=tem;
			}
			count++;
			tem1=tem.next;
			tem=tem1;		
		}
		return node;
		
	}
	
	/**
	 * 获得队列的长度
	 * @return 返回队列的长度
	 */
	public int LinkListSize(){
		int size = 0;
		LinkNode tem=new LinkNode();
		LinkNode tem2=new LinkNode();
		tem2=root;
		while(tem2!=null){	
			tem=tem2.next;
			tem2=tem;
			size++;
		}
		
		return size;
		
	}

}


/**
 * 测试用链表实现的队列
 * @author zr
 *
 */
public class Test {
	private static LinkNode root,root2;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Test t=new Test();
		
		System.out.println("当链表为空时开始添加");
		NodeList nl=new NodeList(root);
		nl.add("根节点");
  
		nl.add("节点1");
  
		nl.add("节点2");
  
		nl.add("节点3");
  
		nl.add("节点4");
  
		root=nl.getRoot();		
		System.out.println("打印出链表：");
		t.printLinkList(root);
		int size=nl.LinkListSize();
		System.out.println("链表的长度为："+size);
		LinkNode node=nl.get(4);
		System.out.println("第4个节点的值为："+node.data);
		
		System.out.println();
		System.out.println("当链表不为空时开始添加");
		root2=t.createLinkList();
		NodeList nl2=new NodeList(root2);
		nl2.add("节点5");
  
		nl2.add("节点6");
  
		System.out.println("打印出链表：");
  
		root2=nl.getRoot();
		t.printLinkList(root2);
  
		int size2=nl2.LinkListSize();
		System.out.println("链表的长度为："+size2);
		LinkNode node2=nl2.get(7);
		System.out.println("第7个节点的值为："+node2.data);
	}
	
	/**
	 * 创建一个链表
	 * @return 返回链表的根节点
	 */
	public LinkNode createLinkList(){
		
		root=new LinkNode();
		LinkNode n1=new LinkNode();
		LinkNode n2=new LinkNode();
		LinkNode n3=new LinkNode();
		LinkNode n4=new LinkNode();
		root.data="根节点";
		root.next=n1;
		n1.data="节点1";
		n1.next=n2;
		n2.data="节点2";
		n2.next=n3;
		n3.data="节点3";
		n3.next=n4;
		n4.data="节点4";
		return root;
		
	}
	
	/**
	 * 遍历一个链表
	 * @param lroot 链表的根节点
	 */
	public void printLinkList(LinkNode lroot){
		if(lroot!=null){
			System.out.println(lroot.data);
			LinkNode tem=new LinkNode();
			tem=lroot.next;
			printLinkList(tem);
		}
	}

}

 
结果为：

当链表为空时开始添加
打印出链表：
根节点
节点1
节点2
节点3
节点4
链表的长度为：5
第4个节点的值为：节点3

当链表不为空时开始添加
打印出链表：
根节点
节点1
节点2
节点3
节点4
节点5
节点6
链表的长度为：7
第7个节点的值为：节点6

 

 

 

 

 

链表实现队列
qq_51500472的博客
10-31 305
c++链表实现队列代码如下 （注：此代码为依次进队或出队单元素，从队尾进队，从队首出队，详情见文末图片） （考虑了队列为空的情况） #include <stdio.h> #include <iostream> using namespace std; struct node { int data; struct node *link; };//定义节点类型 bool IsEmpty_queue(struct node *head) { if(head==
C语言实现队列（链表实现）超详细教程（图解+代码逐行分析）
最新发布
sanyueqi520的博客
04-21 928
队列（Queue）是一种先进先出（FIFO）的线性数据结构，在任务调度、消息队列等场景广泛应用。本文通过C语言实现基于链表的队列结构，特别针对初学者设计，包含完整代码注释和实现原理图解。cint data;// 节点存储的数据// 指向下一节点的指针} Node;内存结构cNode head;// 虚拟头节点（head.next指向首元素）Node* tail;// 尾指针（指向链表末尾）} LinkList;设计说明使用虚拟头节点统一插入操作tail指针加速尾部插入操作c。
用链表实现队列（有错误）.zip
03-05
在计算机科学中，数据结构是...总之，用链表实现队列是一种灵活且高效的方法，但需要仔细处理入队和出队操作，避免上述可能的错误。通过深入学习和实践，我们可以更好地掌握这种数据结构，为编程解决方案打下坚实基础。
用链表实现队列（最终版）.zip
03-06
要使用链表实现队列，我们需要两个关键操作：入队（enqueue）和出队（dequeue）。 1. 入队操作：当一个新元素加入队列时，它被添加到队尾。在链表中，这可以通过创建一个新的节点，将新元素的值存储在节点中，然后...
用链表模拟实现队列（FIFO）
m0_64770095的博客
05-30 3880
你还不会循环队列吗.赶快来看看吧
C语言：链表实现队列（queue）
weixin_50711484的博客
09-04 1099
先到先得，后到后得是队列得核心思想。文章也是这样，先看此文章的人当然先学会啦！
c++用链表实现队列
BlackCarDriver的博客
03-21 2602
注意些插入元素时要注意特殊的情况，例如队列为空时，队列只有一个元素时，或队列有多个元素时分别要以怎样的方式插入。 #include<iostream> #include<stdio.h> #include<string.h> using namespace std; struct Node{ int val; Node* next; Node(int v...
使用链表实现队列
Maggieq8324的博客
07-10 1509
前言 使用链表实现队列，需要队首指向队列头部管理数据出对，队尾指向队列尾部管理数据入队。 具体实现 队列接口 public interface Queue<T> { /** * 元素入队 * @param t */ void enqueue(T t); /** * 元素出队 * @return */ T dequeue(); /** * 获取队首元素 * @r
队列:使用链表实现一个队列
EDGNB6666的博客
03-06 735
#include<iostream> using namespace std; struct Node { int data; Node* next; }; Node* front = NULL; Node* rear = NULL; void Enqueue(int x) { Node* temp = new Node; temp->data = x; temp->next = NULL; if(front == NULL && rear =.
用链表实现队列java
10-25
链表可以用来实现队列数据结构，这是因为链表的特点支持高效的插入和删除操作。在Java中，我们可以创建两个指针，一个叫做`front`指向队列的头部，另一个叫做`rear`指向队列的尾部。以下是基本的单向链表队列实现： ```java public class LinkedListQueue { private Node front; // 队首节点 private Node rear; // 队尾节点 // 结点类定义 private static class Node { int data; Node next; Node(int data) { this.data = data; this.next = null; } } // 添加元素到队尾 public void enqueue(int value) { Node newNode = new Node(value); if (rear == null) { front = rear = newNode; } else { rear.next = newNode; rear = newNode; } } // 从队首移除元素并返回 public int dequeue() { if (front == null) { throw new IllegalStateException("Queue is empty"); } int removedValue = front.data; front = front.next; if (front == null) { rear = null; } return removedValue; } // 判断队列是否为空 public boolean isEmpty() { return front == null; } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值