java 反转链表、合并链表

最新推荐文章于 2024-06-19 22:00:01 发布
最新推荐文章于 2024-06-19 22:00:01 发布
阅读量630 收藏 1
点赞数
分类专栏： 剑指offer 文章标签： java 反转链表 合并链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lilong117194/article/details/87546076
版权

第一个问题：反转链表

1. 题目描述

输入一个链表，反转链表后，输出新链表的表头。

2. 解题思路

定义三个指针：
第一个指针指向当前正在处理的节点；
第二个指针指向当前处理节点的下一个节点，该指针是为了保证正常的遍历完顺序链表的所有节点；
第三个指针指向当前处理节点的上一个节点，这里主要是为了修改当前指针的指向，也就是指向反向；

3. 代码
class ListNode {
    int val;
    ListNode next = null;
 
    public ListNode(int val) {
        this.val = val;
    }
}

public class ReverseList {
	
	public static void main(String[] args) {
		// 定义节点
		ListNode root = new ListNode(0) ;
		ListNode n1 = new ListNode(3) ;
		ListNode n2 = new ListNode(5) ;
		ListNode n3 = new ListNode(6) ;
		ListNode n4 = new ListNode(7) ;
		ListNode n5 = new ListNode(9) ;
		// 连接节点
		root.next=n1;
		n1.next=n2;
		n2.next=n3;
		n3.next=n4;
		n4.next=n5;
		
		ListNode tmpnode=root;
		while(tmpnode!=null) {
			System.out.print(tmpnode.val);
			tmpnode=tmpnode.next;
		}
		System.out.println();
		ListNode nodenew= RevList(root);
		while(nodenew!=null) {
			System.out.print(nodenew.val);
			nodenew=nodenew.next;
		}
	}
	
	public static ListNode RevList(ListNode head) {
		
		ListNode newhead=null;		
		ListNode prenode=null;
		ListNode current=head;
		ListNode nextnode=null;
		
		while(current!=null) {			
			nextnode=current.next; 	
			if(nextnode==null) {
				newhead=current;
			}			
			current.next=prenode;      
			prenode=current;
			current=nextnode;
		}		
		return newhead;
	}
	

}

运行结果：

035679
976530

第二个问题：合并两个排序的链表

1. 题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

2. 解题思路

非递归：首先新建一个头节点用来存储新的合并的链表，然后依次比较两个链表的各个节点的值大小，排序。类似于“按大小把数值一个个串起来作为新的链表”
递归：和上述非递归的值比较方法一致，只不过用的是递归的方法。

3. 代码：

非递归代码一：

class ListNode {
    int val;
    ListNode next = null;
 
    public ListNode(int val) {
        this.val = val;
    }
}

public class Merge {
	public static void main(String[] args) {
		// 定义节点
		ListNode root1 = new ListNode(0) ;
		ListNode n11 = new ListNode(1) ;
		ListNode n12 = new ListNode(3) ;
		ListNode n13= new ListNode(5) ;
		ListNode n14 = new ListNode(7) ;
		ListNode n15 = new ListNode(16) ;
		// 连接节点
		root1.next=n11;
		n11.next=n12;
		n12.next=n13;
		n13.next=n14;
		n14.next=n15;
		
		// 定义节点
		ListNode root2 = new ListNode(0) ;
		ListNode n21 = new ListNode(5) ;
		ListNode n22 = new ListNode(9) ;
		ListNode n23 = new ListNode(10) ;
		ListNode n24 = new ListNode(12) ;
		ListNode n25 = new ListNode(14) ;
		// 连接节点
		root2.next=n21;
		n21.next=n22;
		n22.next=n23;
		n23.next=n24;
		n24.next=n25;
		
		ListNode tmpnode1=root1;
		while(tmpnode1!=null) {		
			System.out.print(String.valueOf(tmpnode1.val)+',');			
			tmpnode1=tmpnode1.next;
		}
		System.out.println();		
		ListNode tmpnode2=root2;
		while(tmpnode2!=null) {
			System.out.print(String.valueOf(tmpnode2.val)+',');
			tmpnode2=tmpnode2.next;
		}
		
		System.out.println('\n');
		ListNode newhead=Mer(root1,root2);
		System.out.println('\n');		
		ListNode tmpnode3=newhead;	
		while(tmpnode3!=null) {
			System.out.print(String.valueOf(tmpnode3.val)+',');
			tmpnode3=tmpnode3.next;
		}
	}
	
	public static ListNode Mer(ListNode list1,ListNode list2) {
		if(list1==null) {
			return list2;
		}else if(list2==null){
			return list1;
		}
		
		ListNode mergehead=new ListNode(-1);
		ListNode root=mergehead;
		
		while(list1!=null && list2!=null) {
			if(list1.val<=list2.val) {
				mergehead.next=list1;
				System.out.println("h1:"+String.valueOf(mergehead.next.val));
				mergehead=list1;
				list1=list1.next;				
			}else {				
				mergehead.next=list2;			
				System.out.println("h2:"+String.valueOf(mergehead.next.val));
				mergehead=list2;
				list2=list2.next;
			}
		}
		
		if(list1!=null){
			mergehead.next=list1;
        }
        if(list2!=null){
        	mergehead.next=list2;
        }
        return root.next;
	}

}

运行：

0,1,3,5,7,16,
0,5,9,10,12,14,

h1:0
h2:0
h1:1
h1:3
h1:5
h2:5
h1:7
h2:9
h2:10
h2:12
h2:14


0,0,1,3,5,5,7,9,10,12,14,16,

非递归代码二：

class ListNode {
    int val;
    ListNode next = null;
 
    public ListNode(int val) {
        this.val = val;
    }
}

public class Merge {
	public static void main(String[] args) {
		// 定义节点
		ListNode root1 = new ListNode(0) ;
		ListNode n11 = new ListNode(1) ;
		ListNode n12 = new ListNode(3) ;
		ListNode n13= new ListNode(5) ;
		ListNode n14 = new ListNode(7) ;
		ListNode n15 = new ListNode(16) ;
		// 连接节点
		root1.next=n11;
		n11.next=n12;
		n12.next=n13;
		n13.next=n14;
		n14.next=n15;
		
		// 定义节点
		ListNode root2 = new ListNode(0) ;
		ListNode n21 = new ListNode(5) ;
		ListNode n22 = new ListNode(9) ;
		ListNode n23 = new ListNode(10) ;
		ListNode n24 = new ListNode(12) ;
		ListNode n25 = new ListNode(14) ;
		// 连接节点
		root2.next=n21;
		n21.next=n22;
		n22.next=n23;
		n23.next=n24;
		n24.next=n25;
		
		ListNode tmpnode1=root1;
		while(tmpnode1!=null) {		
			System.out.print(String.valueOf(tmpnode1.val)+',');			
			tmpnode1=tmpnode1.next;
		}
		System.out.println();		
		ListNode tmpnode2=root2;
		while(tmpnode2!=null) {
			System.out.print(String.valueOf(tmpnode2.val)+',');
			tmpnode2=tmpnode2.next;
		}
		
		System.out.println('\n');
		ListNode newhead=Mer(root1,root2);
		System.out.println('\n');		
		ListNode tmpnode3=newhead;	
		while(tmpnode3!=null) {
			System.out.print(String.valueOf(tmpnode3.val)+',');
			tmpnode3=tmpnode3.next;
		}
	}
	
	public static ListNode Mer(ListNode list1,ListNode list2) {
		if(list1==null) {
			return list2;
		}else if(list2==null){
			return list1;
		}
		
		ListNode mergeHead = null;
        ListNode current = null;     
        
        while(list1!=null && list2!=null){
            if(list1.val <= list2.val){
                if(mergeHead == null){
                   mergeHead = current = list1;
                }else{
                   current.next = list1;
                   current = current.next;
                }
                list1 = list1.next;   
                
            }else {
            	if(mergeHead == null){
                    mergeHead = current = list2;
                 }else{
                    current.next = list2;
                    current = current.next;
                 }
                 list2 = list2.next;
            }
            
        }
        
        if(list1 == null){
            current.next = list2;
        }else{
            current.next = list1;
        }
        
        return mergeHead;
        
	}
}

运行：

0,1,3,5,7,16,
0,5,9,10,12,14,


0,0,1,3,5,5,7,9,10,12,14,16,

递归代码：

public ListNode Mer(ListNode list1,ListNode list2) {
       if(list1 == null){
           return list2;
       }
       if(list2 == null){
           return list1;
       }
       
       if(list1.val <= list2.val){
           list1.next = Merge(list1.next, list2);
           return list1;
       }else{
           list2.next = Merge(list1, list2.next);
           return list2;
       }       
   }

这样看来还是递归厉害，但基本思路还是上述的非递归中的思想。

仅作为自己学习的笔记。。

lilong117194
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实现链表的常见操作算法详解
08-25
7. **reverseList()**：反转链表。这个操作需要三个指针，分别指向当前节点、前一个节点和临时节点，依次更新节点的`next`指向其前一个节点，直至遍历结束。 8. **mergeSortedList(LinkedListOperator list1, ...
Java算法实例-双向链表操作
08-22
除了上述基本操作，还可以实现查找特定值的节点、反转链表、合并两个有序链表等高级操作。例如，反转链表可以使用迭代或递归的方式实现。 双向链表因其特性，在很多算法问题中都有所应用，如LRU缓存淘汰策略、实现...
【算法面试必刷Java版四】合并两个排序的链表
莫安逸无风雪
08-31 3668
输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。
Java 实现反转一个链表
超烦豆先森
06-16 2781
如何用 Java 实现反转一个链表
坚持刷题｜反转链表
最新发布
weixin_44435110的博客
06-19 420
Hello，大家好，我是阿月。坚持刷题，老年痴呆追不上我，今天继续链表：反转链表。
JAVA之反转链表
weixin_63331779的博客
09-10 4038
java之反转链表
Java 算法篇-深入了解单链表的反转（实现：用 5 种方式来具体实现）
小扳手
11-13 4668
单链表的反转是指将链表中的节点顺序逆转，即原先的链表尾部变成了头部，头部变成了尾部。比如，[1,2,3,4,5,6,7] 将这个链表的值反转得到的结果为：[7,6,5,4,3,2,1]，需要注意的是，可以用值打印出来会更好观察链表反转后的结果。 具体的创建思路：首先要把节点进行封装成单独的类，该类中的成员包括：int value 存放值，Node next 引用下一个节点。由于该节点类为链表中的一个组成部分，因此，将该类设为静态内部类，外部类的成员为哨兵节点。
算法-反转链表(java)
无简介！！
06-06 237
【代码】算法-反转链表(java)
java单链表反转
花生日记
05-04 1519
这两种方法都可以进行链表头节点定位操作，下面我们就来分别了解一下这两种方法： 我们来看一下上面给出的代码： 上面给出的代码只给出了一种方式来确定一个链表结构是有序还是无序的，如果不知道该如何判断的话，那么我们就可以通过上面给出的代码进行判断；在上面的代码中，我们首先定义了一个指针变量x来存储哈希表中的1和3,然后我们在哈希表中增加了一个变量 xmode来存储哈希表中的元素。下面是使用哈希表来反转 double [3]（）的代码： 这个代码中，我们首先在哈希表中建立了一个数组，然后我们创建了一个哈希表对象。
java-leetcode题解之第148题排序链表.zip
06-17
3. **合并子链表**：将两个已排序的子链表合并成一个有序链表。这是归并排序的核心，我们需要一个辅助函数来比较两个节点并构建新的有序链表。 在Java中，我们可以创建一个`ListNode`类表示链表节点，然后编写一个`...
算法链表.docx
09-11
本文将深入探讨链表的几个关键操作：链表反转、合并有序列表、新增节点、删除节点、判断链表是否有环以及找到链表的中间节点。我们将使用Java语言进行讨论。 首先，链表不同于数组，它不依赖于内存中的连续空间。每...
Java链表-合并两个有序链表
m0_52012606的博客
12-09 3911
定义一个新链表，定义一个新链表的指针tempNode。当合并的两个链表的头节点指针都不指向空时，比较两个链表节点的值，找到里面较小的值的地址。让新链表的指针tempNode下一个节点指向该最小值的地址，然后让该较小值的地址头指针指向下个地址。当一个链表的头指针指向空时，把另一个链表剩下的地址都填到新链表后边。这样链表就合并成功。...
java 反转链表
weixin_45632897的博客
09-14 422
java反转链表
合并两个有序链表（java）
intmainreturn的博客
12-30 1098
新链表是通过拼接给定的两个链表的所有节点组成的。重写toString方法，便于观察链表数据（可有可无）；将两个升序链表合并为一个新的。1、# 自定义链表类；
Java反转链表
weixin_42608318的博客
01-25 81
反转链表可以使用三个指针来实现。首先，定义三个指针pre、cur和next，分别指向当前节点的前驱、当前节点和当前节点的后继。然后，遍历链表，将当前节点的next指针指向pre，并将pre、cur和next依次向后移动一个位置。 具体代码如下: public ListNode reverseList(ListNode head) { ListNode pre = null; Lis...
Java实现单链表反转操作
热门推荐
WeekenLin的博客
08-24 3万+
          单链表是一种常见的数据结构，由一个个节点通过指针方式连接而成，每个节点由两部分组成：一是数据域，用于存储节点数据。二是指针域，用于存储下一个节点的地址。在Java中定义如下： public class Node { private Object data;//数据域 private Node next;//指针域 public Node(...
java 判断两个单链表是否相交
憧憬的专栏
10-22 4150
题目单链表可能有环,也可能无环。给定两个单链表的头节点 head1 和 head2, 这两个链表可能相交,也可能不相交。请实现一个函数,如果两个链表相交,请返回相交的第一个节点;如果不相交,返回 null 即可。思考链表分有环链表和无环链表，如果两个链表存在相交，则只有两种可能，两个链表都无环或者都有环。 1. 如果链表都无环，则先判断链表的尾指针是否一样，如果不一样，则没有相交。如果一样，则找出
合并两个有序链表(Java)
LrvingTc的博客
03-14 1896
题目描述 将两个有序链表合并成一个有序链表 解决 递归 代码： //递归 public ListNode mergeTwoLists(ListNode l1, ListNode l2) { if(l1 == null) return l2; if(l2 == null) return l1; if(l1.val &lt; l2.val){ ...
Java链表面试题详解：创建、遍历到反转
将两个已排序的链表合并成一个有序链表，可以采用迭代或递归的方式，比较当前节点的值，将较小的一方作为新节点的next，直到某一个链表为空，然后将另一个链表剩余的部分连接到新链表的末尾。 6、单链表的反转： ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值