Java实现简单的单链表

最新推荐文章于 2022-04-21 14:17:37 发布
最新推荐文章于 2022-04-21 14:17:37 发布
阅读量391 收藏 4
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Java数据结构 文章标签： Java实现简单的单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wxx17353227396/article/details/90647414
该博客主要介绍用Java实现简单单链表。先阐述单链表概念，头节点指向首个数据节点，各节点通过next引用相连。接着说明用Java实现单链表的方法，包括编写Node类，以及单链表的增加、删除、排序、遍历等操作。最后总结并提出一些拓展操作。

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

1、Java实现简单的单链表：
参考文章：https://www.cnblogs.com/whgk/p/6589920.html
数据结构：单链表的实现-Java
数据结构还是很重要的，就算不是那种很牛逼的，但起码得知道基础的东西，这一系列就算是复习一下以前学过的数据结构和填补自己在这一块的知识的空缺。加油。珍惜校园中自由学习的时光。按照链表、栈、队列、排序、数组、树这种顺序来学习数据结构这门课程把。
一、单链表的概念
链表是最基本的数据结构，其存储的你原理图如下图所示:
在这里插入图片描述
上面展示的是一个单链表的存储原理图，简单易懂，head为头节点，他不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用，而每个节点中都有一个next引用，指向下一个节点，就这样一节一节往下面记录，直到最后一个节点，其中的next指向null。链表有很多种，比如单链表，双链表等等。我们就对单链表进行学习，其他的懂了原理其实是一样的。
二、用java实现单链表
2.1、编写一个Node类来充当结点的模型。我们知道，其中有两个属性，1存放数据的data，2存放下一结点的引用。为简单，data和Node都选用public类型。

package linkList;
public class Node {
	// 存放数据的变量，int型
	public int data;
	// 存放结点的变量，默认为null
	public Node next;	
	// 构造方法
	public Node(int data) {
		this.data = data;
	}
}

2.2、单链表的简单操作(增加，删除，获取总长度，链表元素排序，链表遍历)　
在这里插入图片描述
注意：在增加结点操作前需要将节点连接起来形成一个链表；

	public Node head;
	public SingleLinkList(int data) { // 构造函数
		this.head = new Node(data);
	}
	public SingleLinkList() { // 构造函数
		// this.head = new Node(data);
	}

2.2.1、增加结点操作，addNode(Node)
一开始也会想如果什么结点也没有。是不是需要判断插入的是第一个结点的问题，但写完后发现没有必要，是不是第一个结点操作都是一样的，所以通过移动的指针遍历整个链表，找到最后一个结点，往后添加即可。

	// 增加结点
	public void addNode(int data) {
		Node node = new Node(data);
		Node cur = this.head; 
		if(cur == null) {
			head = node;
			node.next = cur;
			cur = head;
		}else {
			while(cur.next != null) {
				cur = cur.next;
			}
			cur.next = node;
		}
	}

2.2.2、插入结点到链表的指定位置。　insertNodeByIndex(int index,Node node)

	// 插入结点到指定位置
	public void insertNodeByIndex(int i, Node node) {
		// 首先需要判断指定的位置是否合法
		if(i<0|i>length()) {
			System.out.println("插入位置不合理。");
			return;
		}
		int length =1;
		Node cur = this.head;
		if(i==0) {
			head = node;
			node.next = cur;
			cur = head;
			return;
		}
		else {
			if(i == length++) {
				node.next = cur.next;
				cur.next = node;
				return;
			}
			cur = cur.next;
		}
	}

注意：需要判断插入的位置在首位还是在中间，首位插入结点的指针指向与中间插入指针指向又区别。
2.2.3、删除指定位置上的结点　　delNodeByIndex(int index)

	//删除指定位置的结点
	public void delNodeByIndex(int i) {
		// 判断 i 是否合理
		if(i<0|i>length()-1) {
			System.out.println("给定的位置不合理。");
			return;
		}
		int length = 0;
		Node cur = head;
		Node pre = null;
		while(cur != null) {
			if(i == length++) {
				if(i == 0) {
					head = cur.next;
					return;
				} else {
					pre.next = cur.next;
					return;
				}
			}else {
				pre = cur;
				cur =cur.next;
			}
		}
		
	}

注意：删除结点此处使用了两个指针pre和cur，pre指向当前结点的前一个节点。此外，在链表的首位删除结点与链表的中间删除结点也有区别。
2.2.4、单链表进行选择排序　　selectSortNode()

	// 通过选择排序对链表进行排序
	public void selectSortNode() {
		if(length()<1) {
			System.out.println("无需排序");
			return;
		}
		// 选择排序
		Node cur = head;   //第一层遍历使用的移动指针，最处指向头结点，第一个结点用cur表示
		while(cur.next != null) {  //第一层遍历链表，从第一个结点开始遍历
			Node secondCur = cur.next;  //第二层遍历使用的移动指针，secondCur指向第二个结点，我们需要用到是第二个结点开始，所以用cur.next
			while(secondCur.next != null) {   //第二层遍历,从第二个结点开始遍历
				if(cur.data > secondCur.data) {   //第二层中的所有结点依次与第一次遍历中选定的结点进行比较，
					int t = secondCur.data;
					secondCur.data = cur.data;
					cur.data = t;
				}
				secondCur = secondCur.next;
			}
			if(secondCur.next == null) {  //  上面的方法无法读取最后一个结点，所以最后一个结点需另外考虑
				if(cur.data > secondCur.data) {
					int t = secondCur.data;
					secondCur.data = cur.data;
					cur.data = t;
				}
			}
		cur = cur.next;
		}
	}

2.2.5、单链表进行插入排序　　insertSortNode()

	//通过插入排序对链表进行排序
	public void insertSortNode() {
		if(length()<1) {
			System.out.println("无需排序");
			return;
		}
		Node newHead = new Node(0); // 新链表的头结点
		Node newCur = newHead;      // 新链表的移动
		Node cur = head;         // 旧链表的移动指针
		if(newCur.next == null) {  // 将第一个结点直接放入新链表中
			Node node = new Node(cur.data);
			node.next = newCur.next;
			newCur.next = node;
			cur = cur.next;  // 旧链表的指针移动到第二个结点处
		}
		while(cur.next != null) {
			if(newCur.next == null) {  // 先考虑新的链表中只有一个结点时
				if(newCur.data > cur.data) {
					Node node = new Node(cur.data);
					node.next = newCur;
					head = node;
				}
			}else {
				while(newCur.next != null) {  // 新的链表有多个各结点时
					// pre = newCur;
					if(newCur.next.data > cur.data) {
						Node node = new Node(cur.data);
						node.next = newCur.next;
						newCur.next = node;
						break;
					}
					newCur = newCur.next;
				}
				if(newCur.next == null) { // 到达末尾还没找到，该值最小，直接添加到链表。
					Node node = new Node(cur.data);
					newCur.next = node;
				}
			}
			cur = cur.next; // 旧链表指针指向下一位节点，继续重复和新链表的结点比较
			newCur = newHead;  // 新链表的移动指针需要复位，指向头结点
		}
		head = newHead; //开始使用新链表
	}

2.2.7、计算单链表的长度

	// 链表的长度
	public int length() {
		int length =0;
		Node cur = this.head;
		while(cur != null) {
			length++;
			cur = cur.next;
		}
		return length;
	}

2.2.8、遍历单链表，打印data

	// 打印链表中的所有结点的data
	public void print() {
		Node temp =this.head;
		while(temp != null) {
			System.out.print(temp.data+"  ");
			temp = temp.next;
		}
		System.out.println(); 
	}

三、总结
基本的单链表操作就是上面这些了，自己完全手动写一写，会对单链表这种数据结构的理解有很大的帮助。当然其中比较难的是在于对链表的排序上，说难也不难，只要懂的几种排序的原理，就跟写伪代码一样，去实现即可。这里还有一些操作，大家可以动手做一做，我会在下一篇文章中讲解这些答案。
3.1、如何从链表中删除重复数据
3.2、如何找出单链表中的倒数第k个元素
3.3、如何实现链表的反转
3.4、如何从尾到头输出单链表
3.5、如何寻找单链表的中间结点
3.6、如何检测一个链表是否有环
3.7、如何在不知道头结点的情况下删除指定结点
3.8、如何判断两个链表是否相交

附录：
完整代码包含两部分：封装的Node结点和SingleLinkList的实现
1、Node.java

package linkList;
public class Node {
	// 存放数据的变量，int型
	public int data;
	// 存放结点的变量，默认为null
	public Node next;	
	// 构造方法
	public Node(int data) {
		this.data = data;
	}
}

2、SingleLinkList.java

package linkList;

public class SingleLinkList {
	
	public Node head;
	public SingleLinkList(int data) {
		this.head = new Node(data);
	}
	public SingleLinkList() {
		// this.head = new Node(data);
	}
	
	// 增加结点
	public void addNode(int data) {
		Node node = new Node(data);
		Node cur = this.head; 
		if(cur == null) {
			head = node;
			node.next = cur;
			cur = head;
		}else {
			while(cur.next != null) {
				cur = cur.next;
			}
			cur.next = node;
		}
	}
	
	// 插入结点到指定位置
	public void insertNodeByIndex(int i, Node node) {
		// 首先需要判断指定的位置是否合法
		if(i<0|i>length()) {
			System.out.println("插入位置不合理。");
			return;
		}
		int length =1;
		Node cur = this.head;
		if(i==0) {
			head = node;
			node.next = cur;
			cur = head;
			return;
		}
		else {
			if(i == length++) {
				node.next = cur.next;
				cur.next = node;
				return;
			}
			cur = cur.next;
		}
	}
	
	//删除指定位置的结点
	public void delNodeByIndex(int i) {
		// 判断 i 是否合理
		if(i<0|i>length()-1) {
			System.out.println("给定的位置不合理。");
			return;
		}
		int length = 0;
		Node cur = head;
		Node pre = null;
		while(cur != null) {
			if(i == length++) {
				if(i == 0) {
					head = cur.next;
					return;
				} else {
					pre.next = cur.next;
					return;
				}
			}else {
				pre = cur;
				cur =cur.next;
			}
		}
		
	}
	
	// 通过选择排序对链表进行排序
	public void selectSortNode() {
		if(length()<1) {
			System.out.println("无需排序");
			return;
		}
		// 选择排序
		Node cur = head;
		while(cur.next != null) {
			Node secondCur = cur.next;
			while(secondCur.next != null) {
				if(cur.data > secondCur.data) {
					int t = secondCur.data;
					secondCur.data = cur.data;
					cur.data = t;
				}
				secondCur = secondCur.next;
			}
			if(secondCur.next == null) {
				if(cur.data > secondCur.data) {
					int t = secondCur.data;
					secondCur.data = cur.data;
					cur.data = t;
				}
			}
		cur = cur.next;
		}
	}
	
	//通过插入排序对链表进行排序
	public void insertSortNode() {
		if(length()<1) {
			System.out.println("无需排序");
			return;
		}
		Node newHead = new Node(0); // 新链表的头结点
		Node newCur = newHead;      // 新链表的移动
		Node cur = head;         // 旧链表的移动指针
		if(newCur.next == null) {  // 将第一个结点直接放入新链表中
			Node node = new Node(cur.data);
			node.next = newCur.next;
			newCur.next = node;
			cur = cur.next;  // 旧链表的指针移动到第二个结点处
		}
		while(cur.next != null) {
			if(newCur.next == null) {
				if(newCur.data > cur.data) {
					Node node = new Node(cur.data);
					node.next = newCur;
					head = node;
				}
			}else {
				while(newCur.next != null) {
					// pre = newCur;
					if(newCur.next.data > cur.data) {
						Node node = new Node(cur.data);
						node.next = newCur.next;
						newCur.next = node;
						break;
					}
					newCur = newCur.next;
				}
				if(newCur.next == null) { // 到达末尾还没找到，该值最小，直接添加到链表。
					Node node = new Node(cur.data);
					newCur.next = node;
				}
			}
			cur = cur.next; // 旧链表指针指向下一位节点，继续重复和新链表的结点比较
			newCur = newHead;  // 新链表的移动指针需要复位，指向头结点
		}
		head = newHead; //开始使用新链表
	}
	
	// 链表的长度
	public int length() {
		int length =0;
		Node cur = this.head;
		while(cur != null) {
			length++;
			cur = cur.next;
		}
		return length;
	}
	
	// 打印链表中的所有结点的data
	public void print() {
		Node temp =this.head;
		while(temp != null) {
			System.out.print(temp.data+"  ");
			temp = temp.next;
		}
		System.out.println(); 
	}
	
	//main函数
	public static void main(String[] args) {
		SingleLinkList list = new SingleLinkList();
		// Node node1 = new Node(9);
		list.addNode(3);
		list.addNode(2);
		list.addNode(1);
		list.addNode(6);
		list.addNode(0);
		list.print();
		list.insertSortNode();
		list.print();
		// list.delNodeByIndex(0);
		// list.print();
		// list.insertNodeByIndex(0, node1);
		// list.print();
		// System.out.println(list.length());
	}
}

本人经过实际测试，如有问题欢迎提问。

java实现单链表
qq_28840013的博客
08-16 780
参考于 尚硅谷Java数据结构与java算法，韩顺平数据结构与算法 1.什么是链表： 链表是有序的列表，但是它在内存中可以以不连续空间存放，存储如下 根据上图，可以发现： 链表是以节点的方式来存储，是链式存储 每个节点包含 data 域，next域:指向下一个节点. 链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定（头节点一般不存储数据，只用于作为标识） 因而带头节点的单链表的逻辑结构可以看作： 2.单链表的实现 需求： 使用带head头节点的单链表；
java实现链表
u011723409的博客
06-25 1万+
链表实现
利用Java实现单链表
qq_45077173的博客
07-25 426
Java实现单链表 前言： StuNode类相当于C语言当中的结构体 StuNode next：相当于指向下一个元素的指针。 在Java里面没有指针的概念，只有变量的概念。 StuNode.java /** * @author Cody * @date 2020/7/25 - 9:33 */ public class StuNode { public int id; public String name; public int age; public StuNode n
Java实现单链表以及单链表的操作.zip
09-02
以上就是使用Java实现单链表及其实现的各种操作的详细解析。掌握这些基本操作，能帮助我们在处理复杂问题时更加得心应手。在实际编程中，根据具体需求，还可以扩展链表的功能，例如支持双向链表、循环链表等。
基于Java实现的单链表基本操作之链表排.zip
最新发布
04-26
这个项目提供了Java实现单链表基本操作，包括链表排序的具体代码，可以帮助初学者深入理解链表数据结构及其操作。通过实践这些操作，可以提升对数据结构的理解，为更复杂的算法和系统设计打下坚实的基础。
基于Java实现的单链表基本操作之链表合并.zip
04-26
以下是一个简单的Java实现： ```java public ListNode mergeTwoLists(ListNode l1, ListNode l2) { if (l1 == null) return l2; if (l2 == null) return l1; ListNode head; if (l1.val ) { head = l1; l1....
基于Java实现的单链表基本操作之链表分割.zip
04-26
本篇文章将深入探讨如何在Java中实现单链表的基本操作，特别是链表的分割。 首先，我们需要理解单链表的基本结构。一个简单的单链表节点类（Node）可能如下所示： ```java public class Node { int data; Node ...
基于Java实现的单链表基本操作之获取链表长度.zip
04-26
本教程主要探讨的是如何在Java编程语言中实现单链表的基本操作，特别是如何获取链表的长度。下面我们将深入讨论相关知识点。 首先，我们需要理解单链表的概念。单链表是由一系列节点构成的，每个节点包含两部分：...
用java实现单链表
weixin_30261095的博客
09-25 102
对于一个单链表来说，要求有最基本的数据节点以及一些重要的方法。 方法应该有增删改查、定位、输出、获取链表长度、排序、链表读入、链表输出。下面是我用java写的单链表 public class List { public class Node{//定义节点 public int data; public Node next;...
java实现一个简单的单链表
qq_44363212的博客
09-28 947
今天写一个简单的单链表，作为小白的我可能会犯一些错误要是有大佬看到啦还麻烦指出哦。 1.创建一个链表 public class LinkedNode { public int data; public LinkedNode next = null; } 2.我们先来写头插法 头插法很简单，就是直接在链表头部进行插入数据 public void addFirst(int data)...
Java单链表简单实现
boneinegg的博客
08-11 252
Java中 单链表简单实现，插入删除等功能 //节点结构 class Link { int data; Link next; public Link(int data) { this.data = data; } //打印节点数据 public void show() { System.out.print(data +...
Java实现单链表的简单操作
振宇的博客
11-03 1309
文章目录前言一、基本实现思路二、代码实现1.定义结点类2.定义链表类3.测试调用4.结果总结 前言 用Java实现单链表的简单操作，阅读本文和上一篇文章体会Java中类与C++中结构体指针的区别 提示：以下是本篇文章正文内容，下面案例可供参考 一、基本实现思路 构造结点类 构造链表类 具体测试实现 二、代码实现 1.定义结点类 package list.test01; /* *定义结点类 */ public class Node { private int data; public Nod.
JAVA的链表实现
huobengle
09-18 123
其实很早就想开始在优快云写博客了，但是苦于时间或者是懒，一直没有动手，想了想，最后还是开始吧，第一篇博客，开始我的优快云之旅。 java动态链表奉上 package com.bird.node; public class IntSLLNode { public int info; public IntSLLNode next; public IntSLLNod...
java 链表实现
热门推荐
做一个会思考的技术人
09-01 2万+
package myLinkList; public class LinkList { private Node tail; private Node head; public LinkList(){ head = tail=null; } public static class Node{ T data; Node next; Node(T data,Node next){//当为中间节
链表 java 实现
qs_266的博客
04-21 1035
单链表 public class SingleLinkedListDemo { public static void main(String[] args) { // TODO Auto-generated method stub // 开始测试 HeroNode hero1 = new HeroNode(1, "亚索", "疾风剑豪"); HeroNode hero2 = new HeroNode(2, "易", "无极剑圣"); HeroNode hero3 = new Hero
Java实现循环单链表基本操作详解
本节主要探讨循环单链表的基本操作实现，使用Java语言进行源码级别的讲解。 循环单链表的特点是，无论何时，只要链表中有节点存在，我们总可以从一个节点出发访问到链表中的所有节点。这种结构特别适合实现队列、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值