Java链表基础

最新推荐文章于 2022-05-17 22:13:11 发布
最新推荐文章于 2022-05-17 22:13:11 发布
阅读量471 收藏 4
点赞数 2
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42011443/article/details/111830757
版权

这次来学习下单链表的一些常见操作，链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

创建链表

public class test {
	public static void main(String[] args) {
	     int[] arr = {5,2,7,4,9,3,1};
	     SingleLinkedList singleLinkedList = new SingleLinkedList();
	     for(int i=0;i<arr.length;i++){
	    	 singleLinkedList.add(arr[i]);
	     }
	     singleLinkedList.deleteNode(1);
	     singleLinkedList.printLink();
	     System.out.println();
	     //int len = singleLinkedList.length();
	     //System.out.println(len);
	}
}

class SingleLinkedList{
	public Node head = new Node();  //head为头节点不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用
	
	class Node{
		public int value;
		public Node next;
		public Node() {}
		public Node(int value) {
			this.value = value;
			this.next = null;
		}
	}
	
	public void add(int value) {//增加节点 尾插法
		if(head.next == null) {
			head.next = new Node(value);
			return;
		}
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
		}
		tempNode.next = new Node(value);
	}
	
	public void printLink() {//遍历链表
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
			System.out.print(tempNode.value+" ");
		}
	}
	
	public void deleteNode(int value) {//根据值删除节点
		Node tempNode = head;
		while(tempNode.next!=null) {
			if(tempNode.next.value == value) {
				tempNode.next = tempNode.next.next;
			}else {
				tempNode = tempNode.next;
			}
		}
	}
	
	public int length(){
	    int length = 0;
	    Node temp = head;
	    while (temp.next!=null){
	        length++;
	        temp = temp.next;
	    }
	    return length;
	}
}

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

翻转链表

public class test {
	public static void main(String[] args) {
	     int[] arr = {5,2,7,4,9,3,1};
	     SingleLinkedList singleLinkedList = new SingleLinkedList();
	     for(int i=0;i<arr.length;i++){
	    	 singleLinkedList.add(arr[i]);
	     }
	     singleLinkedList.reverseList();
	     singleLinkedList.printLink();
	}
}

class SingleLinkedList{
	public Node head = new Node();  //head为头节点不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用
	
	class Node{
		public int value;
		public Node next;
		public Node() {
			this.next = null;
		}
		public Node(int value) {
			this.value = value;
			this.next = null;
		}
	}
	
	public void add(int value) {//增加节点 尾插法
		if(head.next == null) {
			head.next = new Node(value);
			return;
		}
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
		}
		tempNode.next = new Node(value);
	}
	
	public void printLink() {//遍历链表
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
			System.out.print(tempNode.value+" ");
		}
	}
	
	public void reverseList() {
		Node preNode = null;
		Node curNode = head;
		while(curNode!=null) {
			Node tempNode = curNode.next;
			curNode.next = preNode;
			preNode = curNode;
			curNode = tempNode;
		}
		Node newHeadNode = new Node();
		newHeadNode.next = preNode;
		head = newHeadNode;
	}
	
}

中间元素

public class test {
	public static void main(String[] args) {
	     int[] arr = {5,2,7,4,9,3,1};
	     SingleLinkedList singleLinkedList = new SingleLinkedList();
	     for(int i=0;i<arr.length;i++){
	    	 singleLinkedList.add(arr[i]);
	     }
	     int midvalue = singleLinkedList.findMiddle();
	     System.out.println(midvalue);
	}
}

class SingleLinkedList{
	public Node head = new Node();  //head为头节点不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用
	
	class Node{
		public int value;
		public Node next;
		public Node() {
			this.next = null;
		}
		public Node(int value) {
			this.value = value;
			this.next = null;
		}
	}
	
	public void add(int value) {//增加节点 尾插法
		if(head.next == null) {
			head.next = new Node(value);
			return;
		}
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
		}
		tempNode.next = new Node(value);
	}
	
	public int findMiddle(){
		Node slowNode = head;
		Node fastNode = head;
		while(fastNode!=null&&fastNode.next!=null) {
			fastNode = fastNode.next.next;
		    slowNode = slowNode.next;
		} 
	    return slowNode.value;
	}
}

运行如下：
在这里插入图片描述

判断是否为循环链表

public class test {
	public static void main(String[] args) {
	     int[] arr = {5,2,7,4,9,3,1};
	     SingleLinkedList singleLinkedList = new SingleLinkedList();
	     for(int i=0;i<arr.length;i++){
	    	 singleLinkedList.add(arr[i]);
	     }
	     Boolean hasCycle = singleLinkedList.hasCycle();
	     System.out.println(hasCycle);
	}
}

class SingleLinkedList{
	public Node head = new Node();  //head为头节点不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用
	
	class Node{
		public int value;
		public Node next;
		public Node() {
			this.next = null;
		}
		public Node(int value) {
			this.value = value;
			this.next = null;
		}
	}
	
	public void add(int value) {//增加节点 尾插法
		if(head.next == null) {
			head.next = new Node(value);
			return;
		}
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
		}
		tempNode.next = new Node(value);
	}
	
	public void printLink() {//遍历链表
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
			System.out.print(tempNode.value+" ");
		}
	}
	
	public boolean hasCycle() {
		 if(head == null) {
			 return false;
		 }
		 Node slowNode = head;
		 Node fastNode = head;
		 while(slowNode!=null&&fastNode!=null&&fastNode.next!=null) {
			 slowNode = slowNode.next;
			 fastNode = fastNode.next.next;
			 if(slowNode == fastNode) {
				 return true;
			 }
		 }
		 return false;
	}	
}

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

链表排序

public class test {
	public static void main(String[] args) {
	     int[] arr = {5,2,7,4,9,3,1};
	     SingleLinkedList singleLinkedList = new SingleLinkedList();
	     for(int i=0;i<arr.length;i++){
	    	 singleLinkedList.add(arr[i]);
	     }
	     singleLinkedList.sortList();
	     singleLinkedList.printLink();
	}
}

class SingleLinkedList{
	public Node head = new Node();  //head为头节点不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用
	
	class Node{
		public int value;
		public Node next;
		public Node() {
			this.next = null;
		}
		public Node(int value) {
			this.value = value;
			this.next = null;
		}
	}
	
	public void add(int value) {//增加节点 尾插法
		if(head.next == null) {
			head.next = new Node(value);
			return;
		}
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
		}
		tempNode.next = new Node(value);
	}
	
	public void printLink() {//遍历链表
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
			System.out.print(tempNode.value+" ");
		}
	}
	
	public void sortList() {
		quickSort(head, null);
	}

	private void quickSort(Node low, Node high) {
		if(low == high) {
			return;
		}
		Node pt = partition(low,high);
		quickSort(low,pt);
		quickSort(pt.next,high);
	}

	private Node partition(Node low, Node high) {
		int pivotKey = low.value;
		Node p1 = low; Node p2 = low.next;
		while(p2!=high) {
			if(p2.value < pivotKey) {
				p1 = p1.next;
				
				int temp = p1.value;
				p1.value = p2.value;
				p2.value = temp;
			}
			p2 = p2.next;
		}
		if(p1!=low) {
			int temp = p1.value;
			p1.value = low.value;
			low.value = temp;
		}
		return p1;
	}
}

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

合并两个已排序链表

public class test {
	public static void main(String[] args) {
	     int[] arr1 = {1,4,7};
	     int[] arr2 = {2,3,5};
	     SingleLinkedList singleLinkedList1 = new SingleLinkedList();
	     SingleLinkedList singleLinkedList2 = new SingleLinkedList();
	     for(int i=0;i<arr1.length;i++){
	    	 singleLinkedList1.add(arr1[i]);
	     }
	     for(int i=0;i<arr2.length;i++){
	    	 singleLinkedList2.add(arr2[i]);
	     }
	     Node newNode = singleLinkedList1.merge(singleLinkedList1.head.next,singleLinkedList2.head.next);
	     while(newNode!=null) {
	    	 System.out.print(newNode.value+" ");
	    	 newNode = newNode.next;
		 }
	}
}
class Node{
	public int value;
	public Node next;
	public Node() {
		this.next = null;
	}
	public Node(int value) {
		this.value = value;
		this.next = null;
	}	
}

class SingleLinkedList{
	public Node head = new Node();  //head为头节点不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用
	public void add(int value) {//增加节点 尾插法
		if(head.next == null) {
			head.next = new Node(value);
			return;
		}
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
		}
		tempNode.next = new Node(value);
	}
	
	public Node merge(Node head1,Node head2) {
	    if(head1 == null){
	        return head2;
	    }
	    if(head2 == null){
	        return head1;
	    }
	    Node newhead = null;
	    if(head1.value <= head2.value){
	    	newhead = head1;
	    	newhead.next = merge(head1.next,head2);
	    }else{
	    	newhead = head2;
	    	newhead.next = merge(head1,head2.next);
	    }
	    return newhead;
	}
	
}

运行结果为：
在这里插入图片描述

删除倒数第N个节点

public class test {
	public static void main(String[] args) {
	     int[] arr = {5,2,7,4,9,3,1};
	     SingleLinkedList singleLinkedList = new SingleLinkedList();
	     for(int i=0;i<arr.length;i++){
	    	 singleLinkedList.add(arr[i]);
	     }
	     singleLinkedList.removeNthFromEnd(2);
	     singleLinkedList.printLink();
	}
}

class SingleLinkedList{
	public Node head = new Node();  //head为头节点不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用
	
	class Node{
		public int value;
		public Node next;
		public Node() {
			this.next = null;
		}
		public Node(int value) {
			this.value = value;
			this.next = null;
		}
	}
	
	public void add(int value) {//增加节点 尾插法
		if(head.next == null) {
			head.next = new Node(value);
			return;
		}
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
		}
		tempNode.next = new Node(value);
	}
	
	public void printLink() {//遍历链表
		Node tempNode = head;
		while(tempNode.next!=null) {
			tempNode = tempNode.next;
			System.out.print(tempNode.value+" ");
		}
	}
	
	public void removeNthFromEnd(int n) {
		if(n<=0) {
			return;
		}
		Node dummyNode = head.next;
		Node preDeleteNode = head;
		
		for(int i=0;i<n;i++) {
			if(dummyNode == null) {
				return;
			}
			dummyNode = dummyNode.next;
		}
		while(dummyNode!=null) {
			dummyNode = dummyNode.next;
			preDeleteNode = preDeleteNode.next;
		}
		preDeleteNode.next = preDeleteNode.next.next;
	}
}

运行结果：
在这里插入图片描述

判断两个链表是否相交

public Node getIntersectionNode(Node headA, Node headB) {
    if (headA == null || headB == null) {
        return null;
    }

    Node currA = headA;
    Node currB = headB;
    int lengthA = 0;
    int lengthB = 0;

    // 让长的先走到剩余长度和短的一样
    while (currA != null) {
        currA = currA.next;
        lengthA++;
    }
    while (currB != null) {
        currB = currB.next;
        lengthB++;
    }

    currA = headA;
    currB = headB;
    while (lengthA > lengthB) {
        currA = currA.next;
        lengthA--;
    }
    while (lengthB > lengthA) {
        currB = currB.next;
        lengthB--;
    }
    
    // 然后同时走到第一个相同的地方
    while (currA != currB) {
        currA = currA.next;
        currB = currB.next;
    }
    // 返回交叉开始的节点
    return currA;
}
iriris
关注
专栏目录
合并两个单链表 java
qq_41863211的博客
11-26 1500
main函数里面写了定义的两个链表，可以直接跑 //结构体 class ListNode { private int Data; ListNode Next; ListNode(int i){ this.Data=i; this.Next=null; } public int getData() { return Data; } ...
Java链表
weixin_53244209的博客
12-20 3049
链表一、链表1、什么是链表2、链表共分几类？1、单链表2、双向链表3、循环链表 一、链表 1、什么是链表 链表 [Linked List]：链表是由一组不必相连（不必相连：可以连续也可以不连续）的内 存结构（节点），按特定的顺序链接在一起的抽象数据类型。 补充： 抽象数据类型（Abstract Data Type [ADT]）：表示数学中抽象出来的一些操作的集合。 内存结构：内存中的结构，如：struct、特殊内存块…等等之类； 数组和链表的区别和优缺点： 数组是一种连续存储线性结构，元素类型相同
Java实现有序单链表合并
lucklydog123的博客
10-04 941
leetcode单链表合并： 要求： 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 单链表的合并并不难 ，要考虑的情况是排序，以及若其中的一条链表被遍历完毕之后，则不需要在进行遍历，直接将其放到新链表的后端即可。 /** * Definition for singly-linked list. * public
Java数据结构-线性表之单链表应用-单链表合并
十六子
07-19 1016
问题详细描述：  将递增有序A、B两链表归并成一个按元素值非递增（允许有相同值）有序的链表C。解题思路：  利用A、B两表递增有序的特点，依次取出当前结点进行比较，将当前值较小者摘下，插入到C表的头部，由于采用的是头插法，最先找到的最小值结点将会在C表的尾部，依次类推，所以得到的C表则为非递增有序的。这里的递增递减性质需要根据代码具体修改实现。已在代码中给出提示。/** * @TODO 两
java实现合并两个有序单链表
qq_34792830的博客
03-12 1674
public class MergeLink { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String str1 = scanner.nextLine(); String str2 = scanner.nextLine(); NodeList node...
java线性表合并_单链表的合并（Java实现）
weixin_39996478的博客
02-16 379
C语言能做的，Java照样可以做。但是没有指针的操作，可能使人看起来“不舒服”。这个博客是为了个人学习算法和数据结构而开的，以后凡是涉及到这方面的内容，我会尽量用Java和C同时实现。大家一起学习，共同进步。以下为Java源码：import java.util.Scanner;//节点类声明class Node {intdata;Nodenext;}public class Linklist {p...
Java链表基础：定义、创建与操作详解
这段代码展示了Java链表的基本概念，包括如何定义链表结构、节点操作（如添加、删除和查询），以及处理链表的特点（如非线性访问）。理解链表在Java中的运用有助于程序员设计高效的算法和优化数据结构，特别是在需要...
Java链表基础：定义、实例与操作详解
Java链表是一种数据结构，它在Java编程中主要用于存储一系列有序的元素，这些元素通过引用（即指针或地址）连接在一起，而非像数组那样连续存储在内存中。链表提供了动态内存管理的优势，可以方便地进行插入、删除...
图解链表 —— JAVA中的单链表基本操作
AlinaQ05的博客
05-17 2211
文章目录1. 什么是链表2. 链表的种类3. 创建单链表3.1 创建 Node 类（车厢类）3.2 创建 MySingleList (火车类）4. 单链表的基本操作4.1 增加链表元素4.1.1 在链表头部添加元素4.1.2 在链表任意位置添加元素4.1.3 在链表尾部添加元素4.2 删除链表元素4.2.1 删除第一个节点元素4.2.2 删除任意位置 index 元素4.2.3 删除链表中指定元素的第一个节点4.2.4 删除链表的所有指定元素4.3 查找链表元素4.3.1 判断链表中是否包含元素 data4
Java模拟单链表和双端链表数据结构的实例讲解
09-02
在Java中，双端链表可以在单链表的基础上添加一个指向前一个节点的引用，例如`previous`。这样，我们不仅可以访问下一个节点，还可以访问前一个节点。 双端链表的一个特性是在单链表的基础上保存对最后一个链接点的...
Java合并两个单链表，要求合并后的链表保持有序
一个噗噗的博客
07-07 671
课程：尚硅谷 韩顺平老师《数据结构》 语言：Java 课后练习题目要求：合并两个有序链表，且合并后的链表仍保持有序。 题解： public class withTwoLinkedList { public static void main(String[] args){ Node node1 = new Node(1,"jack"); Node node2 = new Node(3,"mike"); Node node3 = new Nod.
Java数据结构与算法———（14）单链表应用实例，合并两个降序单链表
GTboy100的博客
07-10 492
合并两个降序单链表，合并后仍然是降序。 一、代码 import java.util.Scanner; import java.util.Stack;//使用栈逆序打印单链表 import java.util.ArrayList; public class SingleLinkedListDemo { public static void main(String[] args) { //开始测试 System.out.println("开始测试... ... ... ... ...");
Java实现单链表的合并
Lyuwalle的博客
01-06 1236
首先定义一个节点类： class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = null; } public int getVal(){return val;} public void setVal(int v...
尚硅谷Java合并两个单链表，要求合并后的链表保持有序
qq_47224591的博客
03-04 560
Java合并两个单链表，要求合并后的链表保持有序
java合并两个单链表
先冲一冲看看
04-15 558
首先 这是第一次的代码，然后还有很多不足，跟后面的比起来，还是有差距的 创建节点类 public class Node { int value; //数值 Node next; public Node(int value) { this.value = value; this.next=null; } public int compare(Node n) { //比较两个节点值大...
java实现两个有序单链表合并
apple_4872330的专栏
10-15 924
本次分享的事两个有序单链表的合并， 遍历方法 递归 非递归 节点类 /** * @auther: lawt * @date: 2018/11/4 08 * @Description: 结点信息 */ public class Node { /** * 为了方便，这两个变量都使用public，而不用private就不需要编写get、set方法了。 * 存放数据的变量，简单点，直接为int型 */ public int data...
实现两个有序单链表合并（java）
qq_35082516的博客
12-05 433
/** * 递归方式合并两个单链表 * * @param head1 有序链表1 * @param head2 有序链表2 * @return 合并后的链表 */ public static Node mergeTwoList(Node head1, Node head2) { //递归结束条件 i...
用Java语言实现单向链表的方法
黑白程序的博客
10-09 587
1.先定义一个节点类 package com.buren; public class IntNode { //定义一个节点类 int info; //定义属性，节点中的值 IntNode next; //定义指向下一个节点的属性 public IntNode(int i){ //构造一个next为空的节点 this(i,null); } publ
Java单链表：输入两个有序链表合成为一个有序链表（最笨的办法）
u012545728的博客
06-23 1100
一个比较常见的算法题：合并两个已知排序的单链表，合并后保持有序。网上有很多解法，都是什么所谓的并轨排序，将一个链表合并插入到另一个链表中。自己想出个最笨的方法，维护第三个resultSingleLink。从两个输入的链表中取值比较并插入到resultSingleLink中。先看下我定义的SingleLink，其中提供了很多API方便调用，顺便可以复习一下单链表写法。如下：/** * Create...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值