Java单链表的实现（增删改、逆序输出、查找倒数第n个节点）

最新推荐文章于 2022-01-13 21:30:17 发布
最新推荐文章于 2022-01-13 21:30:17 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43618881/article/details/105252747
版权

单链表

介绍

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表是以节点的方式来存储的，用head作为基点，每个节点包含data域和next域（指针域）。data域用来存储数据，next指定下一节点。
如下图：
在这里插入图片描述

链表的增删改

节点定义

//定义Node, 每一个Node就是一个节点
class Node{
	//数据域，可以封装成一个类
	public int num;    
	public String name;
	public String nickName;
	//下一节点
	public Node next;  
	
	public Node(int num,String name,String nickName) {
		this.num=num;
		this.name=name;
		this.nickName=nickName;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "num:"+this.num+" name:"+this.name+" nickName:"+this.nickName;
	}
	
}

节点增加

前插法
先把node节点指向head节点的下一个节点(node.next=head.next),再把node节点作为head节点的下一个节点（head.next=node）
在这里插入图片描述
后插法
先遍历链表找到最后一个节点,用temp节点存储。把node节点作为temp节点的下一个temp.next=node
在这里插入图片描述

//添加节点
	//找到最后的节点，在其后方添加新节点
	public void addNode(Node Node) {
		//head节点不能动，用temp辅助操作
		Node temp=head;
		//遍历列表
		while(true) {
			//找到退出
			if(temp.next==null) {
				break;
			}
			temp=temp.next;
		}
		temp.next=Node;
	}

按数据域某一属性的顺序插入（指定位置插入）
先遍历链表找到指定节点的前一个,用temp节点存储。把temp节点作为node节点的下一个(node.next=temp.next),再把node作为temp的下一节点（temp.next=node）
在这里插入图片描述

//按顺序添加
	public void addByOrder(Node Node) {
		//寻找的节点是要添加位置的前一个
		Node temp=head;
		boolean flag=false;  //添加的节点是否存在
		
		while(true) {
			//temp为最后一个
			if(temp.next==null) {
				break;
			}
			
			if(temp.next.num>Node.num) {  //位置找到
				break;
			}else if(temp.next.num==Node.num) {   //节点已存在
				flag=true;
				break;
			}
			
			temp=temp.next;
		}
		
		if(flag) {
			System.out.println(Node+"节点已存在");
		}else {
			Node.next=temp.next;
			temp.next=Node;
			System.out.println(Node+"节点添加成功");
		}
	};

节点修改

遍历找到要修改的节点，修改数据

//修改节点
	public void updateNode(Node Node) {
		if(head.next==null) {
			System.out.println("链表为空");
			return;
		}
		
		Node temp=head.next;
		boolean flag=false;
		
		while(true) {
			if(temp==null) {  //已经遍历完
				break;
			}
			
			if(temp.num==Node.num) {  //找到数据
				flag=true;
				break;
			}
			
			temp=temp.next;
		}
		
		if(flag) {
			temp.name=Node.name;
			temp.nickName=Node.nickName;
			System.out.println(Node+"修改成功");
		}else {
			System.out.println("未找到节点");
		}
	}

节点删除

找到要删除节点的前一个，用temp节点存储，用temp的下一节点指向temp节点下一节点的下一节点（temp.next=temp.next.next），而要删除的节点由于没有指针指向，会被java的垃圾回收机制自动回收，即被删除。
在这里插入图片描述

//删除节点
public void deleteNode(int num) {
		Node temp=head;
        boolean flag=false;
		while(true) {
			if(temp.next==null) {  //已经遍历完
				break;
			}	
			if(temp.next.num==num) {  //找到数据
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if(flag) {
			//变换节点
			//要删除的节点（没有指向）会被jvm回收
			temp.next=temp.next.next;
			System.out.println("节点删除成功");
		}else {
			System.out.println("未找到节点");
		}
		
	}

链表的逆序输出

1、遍历链表，用一个临时链表以前插法添加节点

//反转链表
	//遍历链表，把链表的节点前插
	public void reserveLinkedList(Node head) {
		//链表为空,或链表只有一个值
		if(head.next==null||head.next.next==null) {
			return;
		}
		
		Node temp=head.next;
		Node next=null;  //当前节点的下一节点
		Node reserveHead=new Node(0,"","");   //反转列表的头结点
		
		while(temp!=null) {
			next=temp.next;  //先存储链表的下一节点
		
			//前插到临时列表
			temp.next=reserveHead.next;
			reserveHead.next=temp;	
			
			//移到下一节点
			temp=next;
		}
		//实现列表反转
		head.next=reserveHead.next;
	}

2、利用栈先进后出的特性，把链表数据压入栈中，再输出栈中的数据


	//逆序输出，通过栈的先进后出特性
	public void reserveShow(Node head) {
		if(head.next==null) {
			return;
		}
		Stack<Node> stack=new Stack<Node>();
		Node temp=head.next;
		
		while(temp!=null) {
			stack.push(temp);
			temp=temp.next;
		}
		while(stack.size()>0) {
			System.out.println(stack.pop());
		}
	}

链表查找倒数第n个节点

1、首先获取链表的有效长度

//获取链表有效数据长度
	public int getLength(Node head) {
		if(head.next==null) {  //空链表
			return 0; 
		}
		
		int length=0;
		Node temp=head.next;
		
		while(temp!=null) {
			length++;
			temp=temp.next;
		}
		return length;
	}

2、从第一个节点遍历链表长度的size-n次

//查找倒数第k个节点
	//先遍历链表，求取链表长度，遍历size-k次
	public Node getIndexNode (Node head,int index) {
		if(head.next==null) {
			return null; //链表为空
		}
		
		int size=getLength(head);  //链表长度
		
		if(size<=0||index>size) {
			return null;
		}
		
		Node temp=head.next;  //第一个数据
		for(int i=0;i<size-index;i++) {
			temp=temp.next;
		}
		return temp;
	}

完整代码

public class SingleLinkedListDemo {
	
      public static void main(String[] args) {
    	  
    	  Node node1=new Node(1,"张三","小张");
    	  Node node2=new Node(3,"李四","小李");
    	  Node node3=new Node(4,"王五","小王");
    	  Node node4=new Node(2,"赵六","小赵");
    	  
    	  SingleLinkedList list=new SingleLinkedList();
    	  list.addByOrder(node1);
    	  list.addByOrder(node2);
    	  list.addByOrder(node3);
    	  list.addByOrder(node4);
    	  
    	  System.out.println("反转前:");
    	  list.showList();
    	  System.out.println("逆序输出(没有改变链表结构):");
    	  list.reserveShow(list.getHead());
    	  list.reserveLinkedList(list.getHead());
    	  System.out.println("反转后(改变链表结构):");
    	  list.showList();
    	  System.out.println("查找倒数第二个节点");
    	  Node n=list.getIndexNode(list.getHead(), 2);
    	  System.out.println("倒数第二个节点:"+n.toString());
      }
}

//定义Node, 每一个Node就是一个节点
class Node{
	
	public int num;
	public String name;
	public String nickName;
	public Node next;  //下一节点
	
	public Node(int num,String name,String nickName) {
		this.num=num;
		this.name=name;
		this.nickName=nickName;
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "num:"+this.num+" name:"+this.name+" nickName:"+this.nickName;
	}
	
}

//定义单链表
class SingleLinkedList{
	
	//初始化头节点
	private Node head=new Node(0,"","");
	
	//获取头结点
	public Node getHead() {
		return head;
	}
	
	//添加节点
	//找到最后的节点，在其后方添加新节点
	public void addNode(Node Node) {
		
		//head节点不能动，用temp辅助操作
		Node temp=head;
		
		//遍历列表
		while(true) {
			//找到退出
			if(temp.next==null) {
				break;
			}
			temp=temp.next;
		}
		
		temp.next=Node;
	}
	
	//按顺序添加
	public void addByOrder(Node Node) {
		//寻找的节点是要添加位置的前一个
		Node temp=head;
		boolean flag=false;  //添加的节点是否存在
		
		while(true) {
			//temp为最后一个
			if(temp.next==null) {
				break;
			}
			
			if(temp.next.num>Node.num) {  //位置找到
				break;
			}else if(temp.next.num==Node.num) {   //节点已存在
				flag=true;
				break;
			}
			
			temp=temp.next;
		}
		
		if(flag) {
			System.out.println(Node+"节点已存在");
		}else {
			Node.next=temp.next;
			temp.next=Node;
			System.out.println(Node+"节点添加成功");
		}
	}
	
	//修改节点
	public void updateNode(Node Node) {
		if(head.next==null) {
			System.out.println("链表为空");
			return;
		}
		
		Node temp=head.next;
		boolean flag=false;
		
		while(true) {
			if(temp==null) {  //已经遍历完
				break;
			}
			
			if(temp.num==Node.num) {  //找到数据
				flag=true;
				break;
			}
			
			temp=temp.next;
		}
		
		if(flag) {
			temp.name=Node.name;
			temp.nickName=Node.nickName;
			System.out.println(Node+"修改成功");
		}else {
			System.out.println("未找到节点");
		}
	}
	
	//获取链表有效数据长度
	public int getLength(Node head) {
		if(head.next==null) {  //空链表
			return 0; 
		}
		
		int length=0;
		Node temp=head.next;
		
		while(temp!=null) {
			length++;
			temp=temp.next;
		}
		
		return length;
	}
	
	//删除节点
	public void deleteNode(int num) {
		Node temp=head;
		
        boolean flag=false;
		
		while(true) {
			if(temp.next==null) {  //已经遍历完
				break;
			}	
			if(temp.next.num==num) {  //找到数据
				flag=true;
				break;
			}
			temp=temp.next;
		}
		
		if(flag) {
			//变换节点
			//要删除的节点（没有指向）会被jvm回收
			temp.next=temp.next.next;
			System.out.println("节点删除成功");
		}else {
			System.out.println("未找到节点");
		}
		
	}
	
	//查找倒数第k个节点
	//先遍历链表，求取链表长度，遍历size-k次
	public Node getIndexNode (Node head,int index) {
		if(head.next==null) {
			return null; //链表为空
		}
		
		int size=getLength(head);  //链表长度
		
		if(size<=0||index>size) {
			return null;
		}
		
		Node temp=head.next;  //第一个数据
		for(int i=0;i<size-index;i++) {
			temp=temp.next;
		}
		return temp;
	}
	
	//反转链表
	//遍历链表，把链表的节点前插
	public void reserveLinkedList(Node head) {
		//链表为空,或链表只有一个值
		if(head.next==null||head.next.next==null) {
			return;
		}
		
		Node temp=head.next;
		Node next=null;  //当前节点的下一节点
		Node reserveHead=new Node(0,"","");   //反转列表的头结点
		
		while(temp!=null) {
			next=temp.next;  //先存储链表的  下一节点
			
			//前插
			temp.next=reserveHead.next;
			reserveHead.next=temp;	
			
			//移到下一节点
			temp=next;
			
		}
		//实现列表反转
		head.next=reserveHead.next;
	}
	
	//显示列表
	public void showList() {
		if(head.next==null) {
			System.out.println("链表为空");
			return;
	    }
		
		Node temp=head;
		//遍历列表
		while(true) {
		  //找到退出
			if(temp.next==null) {
					break;
			}
			temp=temp.next;
			System.out.println(temp.toString());
		}
    }
	
	//逆序输出，通过栈的先进后出特性
	public void reserveShow(Node head) {
		if(head.next==null) {
			return;
		}
		
		Stack<Node> stack=new Stack<Node>();
		Node temp=head.next;
		
		while(temp!=null) {
			stack.push(temp);
			temp=temp.next;
		}
		
		while(stack.size()>0) {
			System.out.println(stack.pop());
		}
	}
}

结果如下
在这里插入图片描述

链表 第一部分：单向链表增删改反转合并等
笔记别偷看
10-06 607
链表 链表(Linked List)介绍 链表是有序的列表，但是它在内存中是存储如下： 小结上图: 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域：存数据的， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表 逻辑结构 单链表(带头结点) 逻辑结构示意图如下： 单链表的应用实例 使用带head头的单向链表实现 –水浒英雄排行榜管理 完成对英雄人物的增删改查操作， 注: 删除和修改,查找
【数据结构】Java实现常用数据结构
Java
09-15 1056
【数据结构】Java算法基础 一、前言 KMP算法 汉诺塔 八皇后（分治算法） 马踏棋盘算法（骑士周游问题）图的深度优先算法+贪心算法优化 第一章、稀疏数组和队列 1.1 稀疏数组 基本介绍 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个有效值 把具有不同值的有效元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 package zy.code.sparsearray; /** * 稀
找单链表倒数第N个元素
05-17
很多大公司的面试题，查找单链表倒数第N个节点
每日算法（二十五）-java求单链表的倒数第n个元素的值
Tong_Nan的博客
06-01 1594
每日算法（二十四）-java求单链表的倒数第n个元素的值 求单链表的倒数第n个元素的值 比如1-2-3-4-5-6 求倒数第3个元素 是 4 … 建立两个指针，一开始都指向第一个数，然后将第二个指针先跑到倒数第n-1数的位置，当第二个指针的下个节点不为空时，两个指针依次往后走，当为空时，第一个指针指向的位置就刚好是倒数第n个数 public static int getbackward(Lis...
【data structure】之查找链表中倒数第N个元素
java开发指南博客 【转载】
12-22 132
问题： 给定一个链表，在只遍历一遍的前提下查找倒数第n个元素。数据开销要求尽可能小。 思路： 设置两个哨兵指针，第一个指针先移动n个位置，然后第二个指针再从头结点与第一个指针一起移动。这样第一个指针跟第二个指针之间的距离为n个结点长度，因此当第一个指针移动到尾部的时候，第二个指针即指向倒数第n个结点。 代码： #include &lt;iostream&gt; using names...
单链表拿到倒数第N个节点
bully9的博客
01-13 778
一.实现思路 转变一下思路，因为单链表是只能正向遍历的，所以遍历的次数为(链表长度-N)，拿到的节点即为倒数第N个节点 二.代码实现 //拿到节点的个数 public int getNodeNum(Node head) { if (head.next == null) { return 0; } int count = 0; Node cur = head.next; ...
一个单链表中返回倒数第n个元素
有姿有势的猿人俱乐部
01-16 970
这里我们假设使用两个指针p1,p2； p1指向头节点,p2指向节点n； p1和p2一齐移动，始终保持距离R，R=n； 很容易得p2=null时，p1就是所要的值。 建立链表的代码在上一篇笔记上有写，在此直接调用 public class qu_n_zhi { static int []input={12,35,12,78,15,76,21,58,54,1}; publ
常用算法和思维归纳
weixin_40695328的博客
03-31 722
是啥
如何面试软件测试工程师
测试
03-17 2918
在牛客网找面经 目录一、开场白1. 自我介绍2. 项目经历二、软件测试基础工作内容测试方法测试文档自动化测试测试工具性能测试梳理明确压测的目的和步骤：如何定位问题以及优化游戏测试三、软件测试实战排查问题的思路实战案例四、语言基础JavaPython五、数据结构与算法链表数组排序树递归字符串堆与栈动态规划高级算法查找哈希图六、框架开发框架测试框架seleniumAppiumUnittestPytestTestNGJunit七、计算机基础计算机网络TCP/UDPHTTP/HTTPS操作系统进程/线程Linux数
2021-09-26
热门推荐
qq_25843323的博客
09-26 1万+
面试二问了整个项目的整体的流程，为什么选择某些技术或者基础组件 1.自我介绍 2.挑一个项目，画项目的架构图 Kafka发送数据之后立即返回还是等待ACK之后才返回？ Kafka工作流程： producter先从Zookeeper获取分区的leader producter将消息发送给leader Leader将消息写入本地文件 followers从leader pull消息 followers将消息写入本地后向leader发送ACK leader收到所有副本的A
008实现一个算法从一个单链表中返回倒数第n个元素（keep it up）
yanziguilai的专栏
08-19 1602
我们维护两个指针， 它们之间的距离为n。然后，我将这两个指针同步地在这个单链表上移动，保持它们的距离 为n不变。那么， 当第二个指针指到空时，第一个指针即为所求。 #include struct Node { int data; Node* next; }; void initList(Node* vNode) { for (int i=0; i < 20; ++i) {
Java：如何找出单链表中的倒数第k个元素
model1220的学习之路
10-06 2321
设置两个指针，相差k个节点。//如何找出单链表中的倒数第k个元素 public class findelem { public static Node method(Node head,int k) { if(k<1) { return null; } Node p1=head; Node p2=head; for(int i=0;i<k-1&&p1!=null;i++
python 单向链表查找倒数第n个元素_求单链表倒数第N个数
weixin_39720181的博客
12-09 1377
昨天我们解决了单链表逆序的问题，同时给出了三种解决方案。今天我们解决另外一个常见面试题：求单链表倒数第N个数。这个问题很有代表性。不管是顺数n个还是倒数n个，其实都是距离-标尺问题。标尺是一段距离可以用线段的两个端点来衡量，我们能够判断倒数第一个节点，因为他的next==NULL。如果我们用两个指针，并保持他们的距离为n，那么当这个线段的右端指向末尾节点时，左端节点就指向倒数第n个节点。所以思路出...
python 单向链表查找倒数第n个元素_单链表的倒数第n个元素
weixin_39673471的博客
02-03 371
看到网上的算法面试题，觉得很有趣。输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。弄法楚题目后，想了几种方法：一。先遍历一次单链表,求其长度length，再第二次遍历 length-k 次二。设置两个指针p1,p2 (p1=p2= p-> head 指向单链表的开始位置)，让第一个指针跑k次 p1 = p1->next, 再一直让p1,p2 执行nex...
在单向链表中如何快速查到倒数第n个节点？
君之剑的专栏
09-03 1598
<br />（1）定义2个指针p1，p2。<br />（2）使用循环让p2指向顺数第n个节点；<br />（3）然后，p1和p2同时移动，直到p2指向NULL，此时p1应该指向倒数第n个节点。<br /> <br />如果n=1，那么p1指向倒数第一个节点，这是很常见的算法。
面试-算法-找到单链表的倒数第N个元素（转）
u013827488的博客
12-20 845
一、几种方法 1. 遍历法，第一次遍历确定链表总长度，第二次遍历找到倒数第N个元素。需要遍历两次 2. N长度队列，遍历链表每个元素入队，队列满时出队，当链表遍历完毕时，队列中队首元素为倒数第N个元素。需要借助额外队列 3. 两个距离N个元素的指针。遍历一次，空间复杂度为O(1) 接下来，我们让指针P1和P2同时循环右移，每次右移一步，直到指针P2移动到链表的末尾： 此时，由于P2指向链表的尾结点，且P1和P2的距离是n-1，因此P1所指的结点就是我们要寻找的链表倒数第n个结点： .
 输出链表的倒数第N个元素-Java
快乐的大儿童附体
06-15 1242
思路，倒数第N个元素，遍历链表，构造两个指针。 第一个从头先遍历N个节点，然后停下来。 第一个也跟着继续遍历，第二个从头开始遍历，直到第一个遍历到null为止。 这时第二个指针就是第N个元素。 public class BackNNode { public static class ListNode { int val; ListNode next = null; ListNode(int val) { th
单链表取倒数第n个元素002
Tlwhisper的博客
01-09 567
1、描述 给出一个单链表，让取出倒数第n个元素， 2、思路 思路1:使用双指针， 思路1.1 ：使用一个滑动窗口，然后往后移动，当滑动窗口的右边界到链表终点时候，滑动窗口的第一个元素就是结果了！，不过滑动窗口的值要更新，操作复杂。 思路2:使用一个vector把整个链表的元素存起来，然后根据随机访问特性，根据下标把元素给取出来。此时的空间复杂度是：O（m），m是链表的长度 优化：vector的空间复杂度： 可以只开一个数组长度为n,然后循环存取，当把单链表最后一个元素存进来的时候，数组的当前元素的下一个元素
数据结构与算法-输出链表倒数第n个元素
weixin_43907316的博客
04-30 302
输入一个int类型数值n返回链表的倒数第n个元素值 public static HeroNode serch(HeroList head,int n){ //首先判断传入的n是否合法既n的值是否小于list的长度 int size = head.size; HeroList temp = head; if (size < n){ return null; } //合法后判断我们的需要遍历的次数为(size - n) for(int i=0;i<size-n;i+
Java单链表逆序操作详解及代码示例
Java单链表逆序用法代码示例 Java单链表逆序用法代码示例是一种常见的数据结构操作，主要用于将单链表的元素逆序排列。单链表是一种基本的数据结构，广泛应用于各种编程语言中。 单链表的逆序操作可以通过修改...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值