个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
34
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章Java实现单链表、栈、队列三种数据结构由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.
1、单链表 。
1、在我们数据结构中，单链表非常重要。它里面的数据元素是以结点为单位，每个结点是由数据元素的数据和下一个结点的地址组成，在java集合框架里面 LinkedList、HashMap（数组加链表）等等的底层都是用链表实现的.
2、下面是单链表的几个特点:
数据元素在内存中存放的地址是不连续的：单链表的结点里面还定义一个结点，它里面保存着下一个结点的内存地址，在实例化对象的时候，jvm会开辟不同内存空间，并且是不连续的.
添加效率高：添加一个元素时，先找到插入位置的前一个，只需要将1，2个元素的连接断开，将插入结点的next指向第一个元素的next 。
（1），然后将第一个元素的next指向插入结点（2）， 。
不用在挪动后面元素.
删除效率高：删除一个元素时，先找到删除位置，将前一个的next指向删除位置的next，不用在挪动后面元素.
查询效率低：查询的时候必须从头开始，依次遍历，而数组因为它的内存是连续的，可以直接通过索引查找.
3、下面通过代码来实现单链表结构:
package com.tlinkedList; 。
/** 。
* User:zhang 。
* Date:2020/10/26 。
**/ 。
public class TLinkedList<T> { 。
private Node head;//链表头部 。
private int size;//链表元素的个数 。
public TLinkedList(){ 。
head=null; 。
size=0; 。
} 。
// 将结点作为内部类。也可以新建一个Node类，作为结点 。
class Node{ 。
private Node next;//下一个结点 。
private T t;//结点的数据 。
public Node(T t){ 。
tthis.t=t; 。
} 。
public T getT() { 。
return t; 。
} 。
public void setT(T t) { 。
tthis.t = t; 。
} 。
} 。
// 在链表头部添加一个结点 。
public void addFirst(T t){ 。
Node node = new Node(t); 。
node.next=head; 。
head=node; 。
size++; 。
} 。
// 在链表中间添加一个结点 。
public void addMid(T t,int index){ 。
Node node = new Node(t); 。
Node mid=head; 。
for (int i = 0; i < index - 1; i++) { 。
midmid=mid.next; 。
} 。
node.next=mid.next; 。
mid.next=node; 。
size++; 。
} 。
// 在链表尾部添加一个结点 。
public void addLast(T t){ 。
Node node = new Node(t); 。
Node last=head; 。
while (last.next!=null){ 。
lastlast=last.next; 。
} 。
last.next=node; 。
node.next=null; 。
size++; 。
} 。
// 删除链表的头结点 。
public void removeFirst(){ 。
headhead=head.next; 。
size--; 。
} 。
// 删除链表的中间元素 。
public void removeMid(int index){ 。
Node mid=head; 。
if (index==0){ 。
removeFirst(); 。
return; 。
} 。
int j=0; 。
Node qMid=head; 。
while (j<index){ 。
qMid=mid; 。
midmid=mid.next; 。
j++; 。
} 。
qMid.next=mid.next; 。
size--; 。
} 。
// 删除链表的尾结点 。
public void removeLast(){ 。
Node mid=head; 。
Node qMid=head; 。
while (mid.next!=null){ 。
qMid=mid; 。
midmid=mid.next; 。
} 。
qMid.next= null; 。
size--; 。
} 。
// 获取链表指定下标的结点 。
public Node get(int index){ 。
Node mid=head; 。
if (index==0){ 。
return head; 。
} 。
int j=0; 。
while (j<index){ 。
midmid=mid.next; 。
j++; 。
} 。
return mid; 。
} 。
public static void main(String[] args) { 。
TLinkedList<String> linkedList = new TLinkedList<>(); 。
linkedList.addFirst("hello1"); 。
linkedList.addFirst("hello2"); 。
linkedList.addFirst("hello3"); 。
for (int i = 0; i < linkedList.size; i++) { 。
System.out.println(linkedList.get(i).getT()); 。
} 。
// linkedList.removeLast(); 。
// linkedList.removeFirst(); 。
// linkedList.addLast("hello4"); 。
linkedList.addMid("hello",2); 。
System.out.println("--------------"); 。
for (int i = 0; i < linkedList.size; i++) { 。
System.out.println(linkedList.get(i).getT()); 。
} 。
} 。
} 。
结果如下:
2、栈(Stack) 。
1、一提到栈我们脑海就会浮现四个字“先进后出”，没错，它就是栈的最大特点.
2、栈的应用场景也非常多，比如将字符串反转、jvm里面的栈区等等.
3、栈里面的主要操作有:
相当于只有一个开口就是尾部，只能从尾进，从尾出.
4、下面通过链表结构实现栈结构:
package com.tStack; 。
/** 。
* User:zhang 。
* Date:2020/10/26 。
**/ 。
public class Test_Stack<T> { 。
private Node head;//栈的头结点 。
private int size;//栈的元素个数 。
class Node{ 。
private Node next;//下一个结点 。
private T t;//结点的数据 。
public Node(T t){ 。
tthis.t=t; 。
} 。
public T getT() { 。
return t; 。
} 。
public void setT(T t) { 。
tthis.t = t; 。
} 。
} 。
public Test_Stack() { 。
head=null; 。
size=0; 。
} 。
public static void main(String[] args) { 。
Test_Stack<String> TStack = new Test_Stack<>(); 。
TStack.push("hello1"); 。
TStack.push("hello2"); 。
TStack.push("hello3"); 。
for (int i = 0; i < 3; i++) { 。
System.out.println(TStack.pop()); 。
} 。
} 。
// 入栈 。
public void push(T t){ 。
Node node = new Node(t); 。
if (size==0){ 。
node.next=head; 。
head=node; 。
size++; 。
return; 。
} 。
if (size==1){ 。
head.next=node; 。
node.next=null; 。
size++; 。
return; 。
} 。
Node lastNode=head; 。
while (lastNode.next!=null){ 。
lastNodelastNode=lastNode.next; 。
} 。
lastNode.next=node; 。
node.next=null; 。
size++; 。
} 。
// 出栈 。
public T pop(){ 。
if (size==0){ 。
System.out.println("栈内无值"); 。
return null; 。
} 。
if (size==1){ 。
T t = head.getT(); 。
head=null; 。
size--; 。
return t; 。
} 。
Node lastNode=head; 。
Node qNode=head; 。
while (lastNode.next!=null){ 。
qNode=lastNode; 。
lastNodelastNode=lastNode.next; 。
} 。
T t = lastNode.getT(); 。
qNode.next=null; 。
size--; 。
return t; 。
} 。
// 获取栈里面元素的个数 。
public int getSize(){ 。
return size; 。
} 。
// 返回栈顶元素 。
public T peek(){ 。
if (size==0){ 。
System.out.println("栈内无值"); 。
return null; 。
} 。
if (size==1){ 。
return head.getT(); 。
} 。
Node lastNode=head; 。
while (lastNode.next!=null){ 。
lastNodelastNode=lastNode.next; 。
} 。
return lastNode.getT(); 。
} 。
} 。
结果:
3、队列(Queue) 。
1、队列的特点也用“先进先出”四个字来概括。就是先进去的元素先输出出来.
2、我们常见的消息队列就是队列结构实现的.
3、队列的常见操作如下:
4、通过链表结构实现队列:
package com.tQueue; 。
/** 。
* User:zhang 。
* Date:2020/10/26 。
**/ 。
public class TQueue<T> { 。
private Node front;//头结点 。
private Node tail;//尾结点 。
private int size;//队列中元素的个数 。
class Node { 。
private Node next;//下一个结点 。
private T t;//结点的数据 。
public Node(T t) { 。
tthis.t = t; 。
} 。
public T getT() { 。
return t; 。
} 。
public void setT(T t) { 。
tthis.t = t; 。
} 。
} 。
public int getSize() { 。
return size; 。
} 。
public void setSize(int size) { 。
this.size = size; 。
} 。
public TQueue() { 。
front = tail = null; 。
} 。
// 入队 。
public void put(T t) { 。
Node node = new Node(t); 。
if (size == 0) { 。
front = tail = node; 。
size++; 。
return; 。
} 。
Node lastNode = front; 。
while (lastNode.next != null) { 。
lastNodelastNode = lastNode.next; 。
} 。
lastNode.next = node; 。
tail = node; 。
size++; 。
} 。
// 出队 。
public T pop() { 。
if (size == 0) { 。
System.out.println("队列中无值"); 。
return null; 。
} 。
T t = front.getT(); 。
frontfront=front.next; 。
size--; 。
return t; 。
} 。
public static void main(String[] args) { 。
TQueue<String> tQueue = new TQueue<>(); 。
tQueue.put("Hello1"); 。
tQueue.put("Hello2"); 。
tQueue.put("Hello3"); 。
for (int i = 0; i < 3; i++) { 。
System.out.println(tQueue.pop()); 。
} 。
} 。
} 。
结果:
最后此篇关于Java实现单链表、栈、队列三种数据结构的文章就讲到这里了,如果你想了解更多关于Java实现单链表、栈、队列三种数据结构的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
34
4
0
我创建了一个单链表。一切正常。 我只想知道我是否在我的代码中做了任何有潜在危险的事情。我关心的代码片段是我的推送、弹出和清理。部分代码仅用于用户交互，因此并不重要(无论如何我都发布了它，以便更清楚地了
链表：是一个有序的列表，但是它在内存中是分散存储的，使用链表可以解决类似约瑟夫问题，排序问题，搜索问题，广义表 单向链表，双向链表，环形链表 PHP的底层是C，当一个程序运行时，内存分成五个区（
我最近开始专注于使用数据结构及其用例的编码练习。下面是我的程序，将数据插入到单个链表中，其中每个节点存储下一个节点的对象。这个程序运行良好。我想了解下面的代码有多有效，所遵循的逻辑是否有效且高效。当节
尝试编写一种方法，从单链表中删除某个值的所有实例，但它似乎不起作用。 我试图适应头部是否包含该值，但我不确定这是否是正确的方法: public void remove (int value) {
struct nodeStruct { int value; struct nodeStruct *next; } struct nodeStruct* List_createNode
typedef struct node { int data; struct node *next; } NODE; NODE* add_head(NODE **phead, int data) {
void addToEnd() { newnode = (struct node*)malloc(sizeof(struct node)); printf ("Enter the cu
我想编写一种方法，从单向链表中删除具有重复数据值的连续项。该方法应返回移除的项目数。该方法应根据需要清理内存，并应假定内存是使用 new 分配的。 比如传入列表 ->a->b->c->c->a->b-
我有一个存储播放列表的表。它的定义非常简单，只有三列: setID - 引用播放列表中的一行的 16 位十六进制 songID - 16 位十六进制数，引用我的歌曲表中的一行 nextID - 16
为什么我的代码不删除链表的最后一个元素？我创建了一个当前指针来横向穿过我的列表并跳出循环..(下一个是我的结构中名为 Card_Node 的点)。回答起来应该很简单，只是不确定为什么它不会删除列表中的
大家好，我现在正在为期中考试学习，正在努力尝试使用单链表创建一个简单的程序。我想让它做的就是将“1”、“2”、“3”、“4”插入列表并打印出来。请看下面的代码: #include #include
我想创建单链表(使用类)，其中每个列表中都有:指向文本的指针、整数、指向下一个列表的指针。 我需要实现 3 个功能:插入(将列表插入单链表并根据指针指向的文本使用strcmp对元素进行排序)remov
我已经实现了一个单链表，我注意到了非常奇怪的行为，但无法查明它发生的确切原因。我已经尝试使用 gdb 找出问题所在，看起来每当我计算列表的大小时，事情就开始出错了。这是我用来测试我的实现的程序，下面是
我正在尝试找出一种从链表中间删除的算法.. 我的想法是遍历链表，找到我要删除的节点之前的节点，命名为Nprev，将Nprev设置为Nnext，其中Nnext在要删除的节点之后Ndelete。 所以 N
我正在尝试创建一个简单的单向链表。以前，我成功地做到了这一点，没有任何错误，但是现在我遇到了错误。我怀疑由于第 23 行中的 if 语句，内存分配存在某种问题。 我尝试过的: 我在我的所有声明中都使用
我正在尝试创建一个简单的单向链表。以前，我成功地做到了这一点，没有任何错误，但是现在我遇到了错误。我怀疑由于第 23 行中的 if 语句，内存分配存在某种问题。 我尝试过的: 我在我的所有声明中都使用
我在学习C++语言的同时尝试构建一个链表，并实现一个从最低到最高的节点插入功能。我遵循了互联网和教科书中的一些教程。 我有一个用于链表节点设置的结构: struct Node { private:
本文实例讲述了Python数据结构与算法之链表定义与用法。分享给大家供大家参考，具体如下： 本文将为大家讲解： （1）从链表节点的定义开始，以类的方式，面向对象的思想进行链表的设计 （2）链表
1561/1563 test cases passed 问题描述: You are given two non-empty linked lists representing two non-nega
我有一个任务来实现一个单链表。我试图找出如何获取头部，但最终出现堆栈溢出错误或空指针错误。有人可以帮助我吗？我已经显示了相关的代码片段: public class Llist { privat
我是一名优秀的程序员,十分优秀！