刷题过程中链表基本问题

一级目录

二级目录

三级目录

递归反转链表

链表节点数据结构定义

    class ListNode{
        int val;
        ListNode next;
        
        ListNode(int x){
            val = x;
        }
    }

反转链表

    ListNode reverse(ListNode head){
        if(head.next == null){
            return head;
        }
        ListNode last = reverse(head.next);
        head.next.next = head;
        head.next = null;
        return last;
    }

反转链表前N个结点

    //successor记录未反转部分的第一个结点
    ListNode successor = null;
    
    //以head为起点的n个结点，返回新的头结点
    ListNode reverseN(ListNode head, int x){
        if(x == 1){
            //记录第x+1个结点
            successor = head.next;
            return head;
        }
        //以head.next为起点，返回前n-1个结点
        ListNode last = reverseN(head.next, x - 1);
        head.next.next = head;
        head.next = successor;
        return last;
    }

反转链表指定区间结点
思考过程:起始索引为1，反转索引[m,n]的链表结点

 思考过程:
 起始索引为1，反转索引[m,n]的链表结点
 m=1 --> head的索引为1，反转区间从m开始
 m=2 --> head.next索引为1，反转区间从m-1开始
 m=3 --> head.next.next索引为1，反转区间从m-2开始

    ListNode reverseBetween(ListNode head, int m, int n){
        //终止条件
        if(m == 1){
            return reverseN(head, n);
        }
        head = reverseBetween(head.next, m - 1, n - 1);
        return head;
    }

非递归实现反转链表

ListNode reverseUnrecur(ListNode head){
        ListNode pre, cur, nxt;
        pre = null;
        cur = head;
        nxt = head;
        while (cur != null){
            nxt = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }

反转链表：反转head到null的节点
反转部分链表，反转[a,b)的节点

ListNode reverseUnrecurBetween(ListNode a, ListNode b){
        ListNode pre, cur, nxt;
        pre = null;
        cur = a;
        nxt = a;
        //while的终止条件修改
        while(cur != b){
            nxt = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nxt;
        }
        //返回反转后的头节点
        return pre;
    }

    ListNode reverseKGroup(ListNode head, int k){
        if(head == null){
            return null;
        }
        ListNode a = head;
        ListNode b = head;
        
        for (int i = 0; i < k; i++){
            if(b == null){
                return head;
            }
            b = b.next;
        }
        
        ListNode newHead = reverseUnrecurBetween(a, b);
        a.next = reverseKGroup(b, k);
        return newHead;
    }

判断回文串

    boolean isPalindrome(String str){
        char[] s = str.toCharArray();
        int left = 0, right = str.length() - 1;
        while (left < right){
            if(s[left] != s[right]){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }

树是特殊的链表结构
逆向输出链表，其实就是链表的递归遍历，输出语句的位置不同

    void traverse(ListNode head){
        if(head == null){
            return;
        }
        traverse(head.next);
        System.out.println(head.value);
    }

正向输出链表

    void traverse(ListNode head){
        if(head == null){
            return;
        }
        System.out.println(head.value);
        traverse(head.next);
    }

用递归思想判断链表是否回文

    ListNode left; //左侧指针
    boolean isPalindrome(ListNode head){
        left = head;
        return traverse(head);

    }

    boolean traverse(ListNode right){
        if(right == null){
            return true;
        }
        boolean res = traverse(right.next);
        res = res && (left.value == right.value);
        left = left.next;
        return res;
    }