每日一题day01

题目

BM1 反转链表

描述

给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0 ≤n≤1000

要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。

如当输入链表{1,2,3}时，

经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。

以上转换过程如下图所示：

示例1
输入：
{1,2,3}
复制
返回值：
{3,2,1}

示例2
输入：
{}
复制
返回值：
{}
复制
说明：
空链表则输出空     

题解

题目的主要信息：
·给定一个长度为的链表，反转该链表，输出表头

两种方法：迭代和递归

package com.cl.LinkedList;

import sun.util.resources.cldr.rwk.CalendarData_rwk_TZ;

import java.awt.*;
import java.util.HashSet;
import java.util.List;

class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
public class BM1反转链表 {
    /*
    给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。
     */

    public static void main(String[] args) {
        ListNode node1=new ListNode(1);
        ListNode node2=new ListNode(2);
        ListNode node3=new ListNode(3);
        node1.next=node2;
        node2.next=node3;

        for(ListNode cur=node1;cur!=null;cur=cur.next){
            System.out.println(cur.val);
        }
        ListNode head = ReverseList(node1);
        ListNode temp= head;
        while (temp!=null){
            System.out.println(temp.val);
            temp=temp.next;
        }


    }
    static  ListNode ReverseListByIteration(ListNode head){
       /*
       方法一：迭代

具体算法：

- step1:创建一个空指针
- step2：断开当前节点（用一个临时节点保存之后节点）
- step3：将当前节点指向空指针
- step4：更新链表（用当前节点替换新节点）
- step5：后移重新赋值
       */
        if (head == null) {
            return  null;
        }
        ListNode cur=null;
        ListNode pre=null;
        cur=head;
        while (cur!=null){
            ListNode temp=cur.next;
            cur.next=pre;
            pre=cur;
            cur=temp;
        }
        return pre;
    }
    static  ListNode ReverseListByRecursion(ListNode head){
//        具体做法
        //终止条件：当达到链表尾时，要么当前指针为空，要么下一个指针为空，就返回
        //返回值 每一级优先返回反转后的子问题的头节点
        //本级任务：先进入后一个节点作为子问题，继续反转，然后记录返回来的头节点，连接在本级节点在子问题后面。
//        具体步骤：
//        step1：对每个节点我们递归向下到最后
//        2、然后向上依次逆转两个节点
//        3、将逆转后的伟连接掉本级子问题后面
        if (head==null||head.next==null){
            return head;
        }
        ListNode newNode = ReverseListByRecursion(head.next);
        head.next.next=head;
        head.next=null;
        return  newNode;
    }


}

BM2 链表内指定区间反转

BM2 链表内指定区间反转

描述
将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。
例如：
给出的链表为 1→2→3→4→5→NULL, m=2,n=4,
返回  NULL1→4→3→2→5→NULL.

数据范围： 链表长度 0<size≤1000，0<m≤n≤size，链表中每个节点的值满足 ∣val∣≤1000
要求：时间复杂度 O(n) ，空间复杂度 O(n)
进阶：时间复杂度 O(n)，空间复杂度 O(1)

package com.cl.LinkedList;

import java.time.temporal.Temporal;

public class BM2区间反转 {
    /*
    头部迭代法
    具体做法：首先肯定是要找到第m个位置，然后才开始反第m到n个位置链表
    1、我们可以在链表签加一个表头，后续返回时去掉就好，
    2、使用两个指针,一个指向当前节点、一个指向前序节点
    3、遍历链表、到第m个位置
    4、对于从m到n的这些个位置的节点、依次断掉指向后面的指针、反转指向
    5、返回时去掉添加的表头
     */
    static  ListNode reverseBetween(ListNode head,int m,int n){

        //加个表头
        ListNode res = new ListNode(-1);
        res.next=head;
        ListNode pre=res;//前序节点
        ListNode cur=head;//当前节点
        for(int i=1;i<m;i++){
            pre=cur;
            cur=cur.next;
        }
        for (int i=m;i<n;i++){
            ListNode temp = cur.next;
            cur.next=temp.next;
            temp.next=pre.next;
            pre.next=temp;
        }
    return res.next;
    }
    public static void main(String[] args) {

    }
}

复杂度分析：
·时间复杂度：O(n),最坏情况下遍历全部链表
·空间复杂度：O(1),无额外空间使用

题目来源牛客网