反转链表

最新推荐文章于 2020-10-19 13:13:40 发布
最新推荐文章于 2020-10-19 13:13:40 发布
阅读量487 收藏 2
点赞数 2
分类专栏： 面试算法 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oneby1314/article/details/107577923
版权

反转链表

1、题目

  • 题目要求：
    • 反转一个单链表。
  • 示例：
    • 输入: 1->2->3->4->5->NULL
    • 输出: 5->4->3->2->1->NULL
  • 进阶：你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

2、代码(实现 1)

2.1、思路图解

  • 单链表翻转思路图解：遍历链表，让 nextNode 指向 curNode ，大致流程如下

    • 初始状态

    image-20200723083137957

    • nextNode 指向 curNode ，实现翻转

    image-20200723083502608

    • curNode、nextNode、nNextNode 指针后移

    image-20200723083512573

    • 指针后移后 nexNode != null ，继续执行反转

    image-20200723083648448

    • 翻转完毕，注意，最后需要让 curNode 成为新的首节点，即让 head 指向 curNode

    image-20200723083747976

  • 如果数组中只有两个元素时，程序也是可以执行翻转滴

image-20200722212649996

2.2、链表节点的定义

// 节点
class Node{   
    public Integer data;
    public Node next;
    
    public Node(Integer data){
        this.data = data;
    }
    
    public String toString(){
        return data.toString();
    }
}

2.3、翻转链表

// 链表类
class SingleLinkedList{
    
    private Node head = new Node(0);
    
    public void add(Node node){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node preNode = head;
        while(preNode.next != null){            
            preNode = preNode.next;
        }
        preNode.next = node;
    }
    
    public void show(){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node curNode = head.next;
        while(curNode != null){
            System.out.print(curNode.data + "-->");
            curNode = curNode.next;
        }
        System.out.println();
    }
    
    public int length(){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node curNode = head.next;      
        // 链表长度
        int len = 0;
        while(curNode != null){
            len++;
            curNode = curNode.next;
        }
        return len;
    }
    
    public void reverse(){        
        // 链表中没有元素或者只有一个元素
        if (head.next == null || head.next.next == null) {
            return;
        }
        
        // 当前节点
        Node curNode = head.next;        
        // 下个节点
        Node nextNode = curNode.next;    
        // 下下个节点
        Node nNextNode = nextNode.next;
        
        // 首节点翻转后是尾节点
        curNode.next = null;
        
        // 执行翻转
        while(nextNode != null) {
        	// 保存 nNextNode
        	nNextNode = nextNode.next;
        	// nextNode 指向 curNode
        	nextNode.next = curNode;
        	// 指针后移
        	curNode = nextNode;
        	nextNode = nNextNode;
        }
        
        // head 指向新的首节点
        head.next = curNode;
    }
}

2.4、代码测试

  • 代码
public static void main(String[] args) {

    SingleLinkedList singleLinkedList = new SingleLinkedList();

    singleLinkedList.add(new Node(1));
    singleLinkedList.add(new Node(2));
    singleLinkedList.add(new Node(3));
    singleLinkedList.add(new Node(4));
    singleLinkedList.add(new Node(5));

    System.out.println("翻转前~~~");
    singleLinkedList.show();

    System.out.println("翻转后~~~");
    singleLinkedList.reverse();
    singleLinkedList.show();

}
  • 程序运行结果
翻转前~~~
1-->2-->3-->4-->5-->
翻转后~~~
5-->4-->3-->2-->1-->

2.5、全部代码

public class ReverseList {
    public static void main(String[] args) {
        
    	SingleLinkedList singleLinkedList = new SingleLinkedList();
        
    	singleLinkedList.add(new Node(1));
    	singleLinkedList.add(new Node(2));
    	singleLinkedList.add(new Node(3));
    	singleLinkedList.add(new Node(4));	
    	singleLinkedList.add(new Node(5));
    	singleLinkedList.add(new Node(6));
        
        System.out.println("翻转前~~~");
        singleLinkedList.show();
        
        System.out.println("翻转后~~~");
        singleLinkedList.reverse();
        singleLinkedList.show();
        
    }
}

// 链表类
class SingleLinkedList{
    
    private Node head = new Node(0);
    
    public void add(Node node){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node preNode = head;
        while(preNode.next != null){            
            preNode = preNode.next;
        }
        preNode.next = node;
    }
    
    public void show(){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node curNode = head.next;
        while(curNode != null){
            System.out.print(curNode.data + "-->");
            curNode = curNode.next;
        }
        System.out.println();
    }
    
    public int length(){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node curNode = head.next;      
        // 链表长度
        int len = 0;
        while(curNode != null){
            len++;
            curNode = curNode.next;
        }
        return len;
    }
    
    public void reverse(){        
        // 链表中没有元素或者只有一个元素
        if (head.next == null || head.next.next == null) {
            return;
        }
        
        // 当前节点
        Node curNode = head.next;        
        // 下个节点
        Node nextNode = curNode.next;    
        // 下下个节点
        Node nNextNode = nextNode.next;
        
        // 首节点翻转后是尾节点
        curNode.next = null;
        
        // 执行翻转
        while(nextNode != null) {
        	// 保存 nNextNode
        	nNextNode = nextNode.next;
        	// nextNode 指向 curNode
        	nextNode.next = curNode;
        	// 指针后移
        	curNode = nextNode;
        	nextNode = nNextNode;
        }
        
        // head 指向新的首节点
        head.next = curNode;
    }
}

// 节点
class Node{   
    public Integer data;
    public Node next;
    
    public Node(Integer data){
        this.data = data;
    }
    
    public String toString(){
        return data.toString();
    }
}

3、代码(实现 2)

3.1、思路图解

  • 定义一个新的头结点，每次遍历原链表中的节点，取出来作为 reverseHead 的首节点，即每取出一个节点就放在 reverseHead 的后面，这样就实现了链表的反转

    • 原链表

    image-20200723083845355

    • 将 curNode 指向的节点插入在 reverseHead 之后

    image-20200723083918888

    • curNode、nextNode 指针后移，curNode != null ，可以继续执行翻转操作，将 curNode 指向的节点插入在 reverseHead 之后

    image-20200723084008767

    • 执行完最后一次翻转后，curNode 指针后移，此时 curNode == null ，翻转结束

    image-20200725134420146

    • 注意：此时 head 仍然指向之前的首节点，需对其重新赋值：head.next = reverseHead.next;

    image-20200725134435492

3.2、链表节点定义

// 节点
class Node{   
    public Integer data;
    public Node next;
    
    public Node(Integer data){
        this.data = data;
    }
    
    public String toString(){
        return data.toString();
    }
}

3.3、翻转链表

// 链表类
class SingleLinkedList{
    
    private Node head = new Node(0);
    
    public void add(Node node){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node preNode = head;
        while(preNode.next != null){            
            preNode = preNode.next;
        }
        preNode.next = node;
    }
    
    public void show(){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node curNode = head.next;
        while(curNode != null){
            System.out.print(curNode.data + "-->");
            curNode = curNode.next;
        }
        System.out.println();
    }
    
    public int length(){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node curNode = head.next;      
        // 链表长度
        int len = 0;
        while(curNode != null){
            len++;
            curNode = curNode.next;
        }
        return len;
    }
    
    public void reverse(){        
        // 链表中没有元素或者只有一个元素
        if (head.next == null || head.next.next == null) {
            return;
        }
        
        // 新的头结点
        Node reverseHead = new Node(0);       
        // 当前待插入的节点
        Node curNode = head.next;     
        // 当前节点的下一个节点
        Node nextNode = curNode.next;
        
        // 执行翻转
        while(curNode != null) {
        	// 保存 curNode 的下一个节点指针
        	nextNode = curNode.next;
        	// 在 preNode 之后插入 curNode
        	curNode.next = reverseHead.next;
        	reverseHead.next = curNode;
        	// 指针后移
        	curNode = nextNode;
        }
        
        head.next = reverseHead.next;
    }
}

3.4、代码测试

  • 代码
public static void main(String[] args) {

    SingleLinkedList singleLinkedList = new SingleLinkedList();

    singleLinkedList.add(new Node(1));
    singleLinkedList.add(new Node(2));
    singleLinkedList.add(new Node(3));
    singleLinkedList.add(new Node(4));	
    singleLinkedList.add(new Node(5));
    singleLinkedList.add(new Node(6));

    System.out.println("翻转前~~~");
    singleLinkedList.show();

    System.out.println("翻转后~~~");
    singleLinkedList.reverse();
    singleLinkedList.show();

}
  • 程序运行结果
翻转前~~~
1-->2-->3-->4-->5-->6-->
翻转后~~~
6-->5-->4-->3-->2-->1-->

3.5、全部代码

public class ReverseList {
    public static void main(String[] args) {
        
    	SingleLinkedList singleLinkedList = new SingleLinkedList();
        
    	singleLinkedList.add(new Node(1));
    	singleLinkedList.add(new Node(2));
    	singleLinkedList.add(new Node(3));
    	singleLinkedList.add(new Node(4));	
    	singleLinkedList.add(new Node(5));
    	singleLinkedList.add(new Node(6));
        
        System.out.println("翻转前~~~");
        singleLinkedList.show();
        
        System.out.println("翻转后~~~");
        singleLinkedList.reverse();
        singleLinkedList.show();
        
    }
}

// 链表类
class SingleLinkedList{
    
    private Node head = new Node(0);
    
    public void add(Node node){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node preNode = head;
        while(preNode.next != null){            
            preNode = preNode.next;
        }
        preNode.next = node;
    }
    
    public void show(){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node curNode = head.next;
        while(curNode != null){
            System.out.print(curNode.data + "-->");
            curNode = curNode.next;
        }
        System.out.println();
    }
    
    public int length(){
        // 首节点指针不能移动哦，需要定义辅助指针
        Node curNode = head.next;      
        // 链表长度
        int len = 0;
        while(curNode != null){
            len++;
            curNode = curNode.next;
        }
        return len;
    }
    
    public void reverse(){        
        // 链表中没有元素或者只有一个元素
        if (head.next == null || head.next.next == null) {
            return;
        }
        
        // 新的头结点
        Node reverseHead = new Node(0);       
        // 当前待插入的节点
        Node curNode = head.next;     
        // 当前节点的下一个节点
        Node nextNode = curNode.next;
        
        // 执行翻转
        while(curNode != null) {
        	// 保存 curNode 的下一个节点指针
        	nextNode = curNode.next;
        	// 在 preNode 之后插入 curNode
        	curNode.next = reverseHead.next;
        	reverseHead.next = curNode;
        	// 指针后移
        	curNode = nextNode;
        }
        
        head.next = reverseHead.next;
    }
}

// 节点
class Node{   
    public Integer data;
    public Node next;
    
    public Node(Integer data){
        this.data = data;
    }
    
    public String toString(){
        return data.toString();
    }
}

4、代码(实现 3)

4.1、思路图解

  • 因为翻转后，原链表的首节点变为新链表的尾节点，所以初始化 preNode = null ，

image-20200725133230909

  • 首先，递归至最深层，curNode == null ，preNode 为原链表的尾节点，此时将原链表的尾节点变为新链表的首节点

image-20200725133917194

  • 回溯至上一步，执行翻转

image-20200725133933706

  • 回溯至最后一步，链表翻转完毕

image-20200725134134887

4.2、链表节点定义

//节点
class Node {
	public Integer data;
	public Node next;

	public Node(Integer data) {
		this.data = data;
	}

	public String toString() {
		return data.toString();
	}
}

4.3、翻转链表

//链表类
class SingleLinkedList {

	private Node head = new Node(0);

	public void add(Node node) {
		// 首节点指针不能移动哦，需要定义辅助指针
		Node preNode = head;
		while (preNode.next != null) {
			preNode = preNode.next;
		}
		preNode.next = node;
	}

	public void show() {
		// 首节点指针不能移动哦，需要定义辅助指针
		Node curNode = head.next;
		while (curNode != null) {
			System.out.print(curNode.data + "-->");
			curNode = curNode.next;
		}
		System.out.println();
	}

	public int length() {
		// 首节点指针不能移动哦，需要定义辅助指针
		Node curNode = head.next;
		// 链表长度
		int len = 0;
		while (curNode != null) {
			len++;
			curNode = curNode.next;
		}
		return len;
	}

	public void reverse() {
		// 翻转后，首节点变成尾节点，所以其 preNode 为 null
		reverse(null, head.next);
	}

	public void reverse(Node preNode, Node curNode) {
		// 首先需要递归至原链表的尾节点
		if (curNode != null) {
			reverse(curNode, curNode.next);
		} else {
			// 递归至最后一个节点，将 head 指向最后一个节点
			head.next = preNode;
			return;
		}
		// 原链表下一个节点直向前一个节点，实现翻转
		curNode.next = preNode;
	}
}

4.4、代码测试

  • 代码
public static void main(String[] args) {

    SingleLinkedList singleLinkedList = new SingleLinkedList();

    singleLinkedList.add(new Node(1));
    singleLinkedList.add(new Node(2));
    singleLinkedList.add(new Node(3));
    singleLinkedList.add(new Node(4));
    singleLinkedList.add(new Node(5));
    singleLinkedList.add(new Node(6));

    System.out.println("翻转前~~~");
    singleLinkedList.show();

    System.out.println("翻转后~~~");
    singleLinkedList.reverse();
    singleLinkedList.show();

}
  • 程序运行结果
翻转前~~~
1-->2-->3-->4-->5-->6-->
翻转后~~~
6-->5-->4-->3-->2-->1-->

4.5、全部代码

public class RecursionReverse {

	public static void main(String[] args) {

		SingleLinkedList singleLinkedList = new SingleLinkedList();

		singleLinkedList.add(new Node(1));
		singleLinkedList.add(new Node(2));
		singleLinkedList.add(new Node(3));
		singleLinkedList.add(new Node(4));
		singleLinkedList.add(new Node(5));
		singleLinkedList.add(new Node(6));

		System.out.println("翻转前~~~");
		singleLinkedList.show();

		System.out.println("翻转后~~~");
		singleLinkedList.reverse();
		singleLinkedList.show();

	}

}

//链表类
class SingleLinkedList {

	private Node head = new Node(0);

	public void add(Node node) {
		// 首节点指针不能移动哦，需要定义辅助指针
		Node preNode = head;
		while (preNode.next != null) {
			preNode = preNode.next;
		}
		preNode.next = node;
	}

	public void show() {
		// 首节点指针不能移动哦，需要定义辅助指针
		Node curNode = head.next;
		while (curNode != null) {
			System.out.print(curNode.data + "-->");
			curNode = curNode.next;
		}
		System.out.println();
	}

	public int length() {
		// 首节点指针不能移动哦，需要定义辅助指针
		Node curNode = head.next;
		// 链表长度
		int len = 0;
		while (curNode != null) {
			len++;
			curNode = curNode.next;
		}
		return len;
	}

	public void reverse() {
		// 翻转后，首节点变成尾节点，所以其 preNode 为 null
		reverse(null, head.next);
	}

	public void reverse(Node preNode, Node curNode) {
		// 首先需要递归至原链表的尾节点
		if (curNode != null) {
			reverse(curNode, curNode.next);
		} else {
			// 递归至最后一个节点，将 head 指向最后一个节点
			head.next = preNode;
			return;
		}
		// 原链表下一个节点直向前一个节点，实现翻转
		curNode.next = preNode;
	}
}

//节点
class Node {
	public Integer data;
	public Node next;

	public Node(Integer data) {
		this.data = data;
	}

	public String toString() {
		return data.toString();
	}
}
OnebyWang
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java语言实现反转链表代码示例
08-29
Java语言实现反转链表代码示例 Java是一种广泛应用于软件开发的编程语言，而链表是编程中的一种重要数据结构。反转链表是链表操作中的一种基本操作，它可以应用于各种实际场景中。下面我们将详细介绍Java语言实现...
反转链表详解
最新发布
Weirdo的博客
06-14 1507
这些数据项通常以链表的形式组织起来，其中最近使用的数据项位于链表的头部，最久未使用的数据项位于链表的尾部。反转链表指的是将链表的头尾节点对调，使得原本链表的第一个节点变为最后一个节点，原本链表的最后一个节点变为第一个节点，其他节点的相对位置也进行相应调整。通过对反转链表算法的深入理解和实践应用，我们可以更好地掌握链表的基本操作和指针的使用，并提高编程能力和解决问题的能力。然而，锁的使用会降低程序的性能。在实际应用中，我们可能需要在反转链表的同时进行其他操作，例如计算链表长度、检查链表中的重复元素等。
【反转链表】
这个人很蓝
10-19 113
题目 输入一个链表，反转链表后，输出新链表的表头。 题解 遍历一遍链表，在遍历的过程中不断将指向关系反转，可以想到需要两个指针fast和slow，fast在前，slow在后，两个指针一同前进，每一次fast将其next指向slow，即反转指向关系，为了保证fast后面的所有节点不失效，还需要第3个指针tmp保存fast的下一个节点。 public class Solution { public ListNode ReverseList(ListNode head) { if (he
LeetCode解题心得——反转链表（python）
12-21
在LeetCode中，反转链表是一个常见的数据结构问题，它主要考察了对链表操作的理解以及递归或迭代解决问题的能力。本题的目标是反转给定的单链表，例如，对于输入1->2->3->4->5->NULL，期望得到的输出是5->4->3->2->1...
Python实现数据结构与算法——反转链表
12-21
反转链表是数据结构与算法领域中的一个经典问题，它要求我们改变链表节点的指向，使得原本顺着一个方向的链表变成逆序。在这个问题中，我们可以采用两种方法来解决：迭代和递归。 首先，让我们详细讲解迭代的解题...
基于Python实现2种反转链表方法代码实例
09-16
在某些问题中，我们可能需要反转链表，即将链表的顺序颠倒过来。本篇文章将详细介绍如何使用Python实现两种不同的链表反转方法。 ### 方法一：迭代法（Two-Pointer Approach） 这种方法使用两个指针，`prev` 和 `...
huashanqitu#labuladong-python3#递归思维：k 个一组反转链表1
07-25
反转链表 迭代法## 逐个节点反转## 更新指针位置## 返回反转后的头结点反转 a 到 b 之间的结点反转区间 [a, b) 的元素，注意是左闭右开K 个一组
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值