递归专项-链表反转与回文链表

题目

可以以递归的思路解决问题， 实际上递归到最后一个节点开始翻转指向，然后逐步递归处理上一个节点，即可完成所有节点的逆转

代码：

/**
  * 题目Id：剑指 Offer II 024
  * 题目：反转链表
  * 内容: //给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。 
//
// 
// 
// 
//
// 示例 1： 
//
// 
//输入：head = [1,2,3,4,5]
//输出：[5,4,3,2,1]
// 
//
// 示例 2： 
//
// 
//输入：head = [1,2]
//输出：[2,1]
// 
//
// 示例 3： 
//
// 
//输入：head = []
//输出：[]
// 
//
// 
//
// 提示： 
//
// 
// 链表中节点的数目范围是 [0, 5000] 
// -5000 <= Node.val <= 5000 
// 
//
// 
//
// 进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？ 
// 
// 
//
// 
//
// 注意：本题与主站 206 题相同： https://leetcode-cn.com/problems/reverse-linked-list/ 
// Related Topics 递归 链表 
// 👍 20 👎 0
	
  * 日期：2021-10-17 13:07:01
*/
//给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。 
//
// 
// 
// 
//
// 示例 1： 
//
// 
//输入：head = [1,2,3,4,5]
//输出：[5,4,3,2,1]
// 
//
// 示例 2： 
//
// 
//输入：head = [1,2]
//输出：[2,1]
// 
//
// 示例 3： 
//
// 
//输入：head = []
//输出：[]
// 
//
// 
//
// 提示： 
//
// 
// 链表中节点的数目范围是 [0, 5000] 
// -5000 <= Node.val <= 5000 
// 
//
// 
//
// 进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？ 
// 
// 
//
// 
//
// 注意：本题与主站 206 题相同： https://leetcode-cn.com/problems/reverse-linked-list/ 
// Related Topics 递归 链表 
// 👍 20 👎 0

package leetcode.editor.cn;

import common.ListNode;
import common.NodeUtils;

public class P剑指OfferII024反转链表UHnkqh {
    public static void main(String[] args) {
        Solution solution = new P剑指OfferII024反转链表UHnkqh().new Solution();
        int[] arr = new int[]{1,2,3,4};
        ListNode head = NodeUtils.condtructList(arr);


        solution.reverseList(head);

        ListNode listNode = solution.tailHead;

        while (listNode != null) {
            System.out.println(listNode.val);
            listNode = listNode.next;
        }

        System.out.println("Hello world");
    }


    //leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {

        return reverse_dg(head);
    }

    private ListNode tailHead;

    private ListNode reverse_dg(ListNode head) {
        if (head != null) {
            ListNode listNode = reverse_dg(head.next);
            if (listNode != null) {
                head.next = null;
                listNode.next = head;
            } else {
                tailHead = head;
            }

            return head;
        }

        return null;


    }
}
//leetcode submit region end(Prohibit modification and deletion)

} 

同上一题目，递归到最后一个节点往前走分别同头结点往后走进行递归处理

代码如下：

/**
  * 题目Id：剑指 Offer II 027
  * 题目：回文链表
  * 内容: //给定一个链表的 头节点 head ，请判断其是否为回文链表。 
//
// 如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。 
//
// 
//
// 示例 1： 
//
// 
//
// 
//输入: head = [1,2,3,3,2,1]
//输出: true 
//
// 示例 2： 
//
// 
//
// 
//输入: head = [1,2]
//输出: false
// 
//
// 
//
// 提示： 
//
// 
// 链表 L 的长度范围为 [1, 105] 
// 0 <= node.val <= 9 
// 
//
// 
//
// 进阶：能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 
//
// 
//
// 注意：本题与主站 234 题相同：https://leetcode-cn.com/problems/palindrome-linked-list/ 
// Related Topics 栈 递归 链表 双指针 
// 👍 8 👎 0
	
  * 日期：2021-10-17 01:45:12
*/
//给定一个链表的 头节点 head ，请判断其是否为回文链表。 
//
// 如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。 
//
// 
//
// 示例 1： 
//
// 
//
// 
//输入: head = [1,2,3,3,2,1]
//输出: true 
//
// 示例 2： 
//
// 
//
// 
//输入: head = [1,2]
//输出: false
// 
//
// 
//
// 提示： 
//
// 
// 链表 L 的长度范围为 [1, 105] 
// 0 <= node.val <= 9 
// 
//
// 
//
// 进阶：能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 
//
// 
//
// 注意：本题与主站 234 题相同：https://leetcode-cn.com/problems/palindrome-linked-list/ 
// Related Topics 栈 递归 链表 双指针 
// 👍 8 👎 0

package leetcode.editor.cn;

import common.ListNode;
import common.NodeUtils;

public class P剑指OfferII027回文链表AMhZSa {
    public static void main(String[] args) {
        Solution solution = new P剑指OfferII027回文链表AMhZSa().new Solution();

        int[] arr = new int[]{1,2,3,3,2,1};
        ListNode head = NodeUtils.condtructList(arr);

        boolean palindrome = solution.isPalindrome(head);

        System.out.println(palindrome);


        arr = new int[]{1,2,3};
        head = NodeUtils.condtructList(arr);

        palindrome = solution.isPalindrome(head);

        System.out.println(palindrome);

        System.out.println("Hello world");
    }
    //leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {

        recordHead = head;
        return reverse_dg(head);

    }

    private ListNode recordHead;
    private boolean reverse_dg(ListNode head) {

        if (head != null) {


            boolean result = reverse_dg(head.next);



            /*if (result) {
                if (head.val == recordHead.val) {
                    recordHead = recordHead.next;
                    return true;
                } else {
                    recordHead = recordHead.next;
                    return false;
                }
            } else {
                return false;
            }*/
            if (!result) {
                return false;
            }

            if (head.val != recordHead.val) {
                return false;
            }

            recordHead = recordHead.next;

        }

        return true;

    }
}
//leetcode submit region end(Prohibit modification and deletion)

}