算法-26反转部分单向链表

标签：Node 26 单向 head next 链表 node1 节点

描述

给定一个单链表，在链表中把第 L 个节点到第 R 个节点这一部分进行反转。

输入描述：

n 表示单链表的长度。

val 表示单链表各个节点的值。

L 表示翻转区间的左端点。

R 表示翻转区间的右端点。

输出描述：

在给定的函数中返回指定链表的头指针。

示例1

输入：
5
1 2 3 4 5
1 3

输出：
3 2 1 4 5

 

思路

想要反转第from到第to这部分的链表，必须要找到from节点前一个fPre节点，以及to节点后一个节点tPos节点。找到后，对第from到第to这部分的链表进行反转，再接上fPre节点和tPos节点。

实现过程：

1、利用len记录链表的长度，每走一个节点就加一。如果当len等于from-1，就说明此时的fPre就是当前node1，同理，tPos等于to+1时，tPos就是当前node1。

while(node1 != null) {
    len++;
    // 找到反转部分的前一个结点
    begin = len == from -1 ? node1:begin;
    // 找到反转部分的后一个结点
    end = len == to+1?node1:end;
    node1 = node1.next;
}

2、判断边界条件

if(from>to||from<1||to>len) {
    return head;
}

3、初始化node1和node2位置

node1初始化是反转部分链表的第一个节点。

node2初始化为反转部分链表的第二个节点。

fPre等于空的话，就将head作为node1，否则就将fPre的下一个节点作为node1

node1的下一个节点就是node2

•  反转前先将node1指向tPos节点（反转后就是部分链表的最后一个节点）
• 进行反转
• 反转后将fPre节点指向部分链表最后一个节点node1（反转后就是部分链表的第一个节点）

 

代码如下：

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    public static class Node {
        public int value;
        public Node next;

        public Node(int value) {
            this.value = value;
        }
    }

    public static Node createList(int length,String[] numbers) {
        Node head = new Node(Integer.parseInt(numbers[0]));
        Node cur = head;
        for(int i=1;i<length;i++) {
            cur.next = new Node(Integer.parseInt(numbers[i]));
            cur = cur.next;
        }
        cur.next = null;
        return head;
    }

    public static Node reversePart(Node head,int from,int to) {
        int len = 0;
        Node node1 = head;
        Node begin = null;
        Node end = null;
        while(node1 != null) {
            len++;
            // 找到反转部分的前一个结点
            begin = len == from -1 ? node1:begin;
            // 找到反转部分的后一个结点
            end = len == to+1?node1:end;
            node1 = node1.next;
        }
        if(from>to||from<1||to>len) {
            return head;
        }
        node1 = begin == null ? head : begin.next;
        Node node2 = node1.next;
        node1.next = end;
        Node next = null;
        while(node2 != end) {
            next = node2.next;
            node2.next = node1;
            node1 = node2;
            node2 = next;
        }
        if(begin != null) {
            begin.next = node1;
            return head;
        }else {
            return node1;
        }
    }

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();

        scanner.nextLine();
        String[] listStr = scanner.nextLine().trim().split(" ");
        
        int from = scanner.nextInt();
        int to = scanner.nextInt();

        Node head = createList(n,listStr);
        head = reversePart(head,from,to);

        while(head != null) {
            System.out.print(head.value + " ");
            head = head.next;
        }
        System.out.println();
    }
}

 

标签：Node,26,单向,head,next,链表,node1,节点
From： https://www.cnblogs.com/sfnz/p/16870037.html