leetCode 25 K个一组翻转链表

学习目标：掌握链表的使用

掌握链表的使用和实现以及相关算法题目

---

学习内容： 实现链表， 完成leetCode 25 K个一组翻转链表

1、 实现链表 2、 完成leetCode 25 K个一组翻转链表 题目：给你一个链表，每K个节点一组锦绣翻转，请你返回翻转后的链表。 K是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是K的整数倍，那么请将最后剩余的节点保持原有顺序。 说明： 你的算法只能使用常数的额外空间 你不能只是单纯的改变节点内部的值，而是需要实际的锦绣节点的交换。

---

学习时间：2天

2天

---

学习产出：链表实现代码，K个一组翻转链表代码

例如： 1、 链表实现代码 2、K个一组翻转链表代码

---

一、链表实现

分析：单链表：存储数据；记录下一个节点。
代码实现

/**
 * @author   
 * @create 2020-08-23 16:21
 */
public class Node<T> {
    Node next = null;//下一个结点
    T data;//结点数据
    public Node(T data){
        this.data = data;
    }
}

因为是自己练习使用就只实现，添加添加元素，长度，获取最后一个节点，删除节点这四个方法

/**
 * @author 
 * @create 2020-08-27 10:51
 */
public interface LinkedListInterface<T> {
    // 新增
void addNode(T t);
    // 长度
int length();
    // 最后一个节点
 Node getLastNode();
    // 删除
boolean deleteNode(int k);
}

链表类

/**
 * @author zhangcl  912037857@qq.com.cn
 * @create 2020-08-23 16:19
 */
public class MyLinkedList<T> implements LinkedListInterface<T> {
    /**链表的头结点*/
    Node head;

    public MyLinkedList() {
        head = null;
    }
    }

新增

/**
     * 链表添加结点:
     * 找到链表的末尾结点，把新添加的数据作为末尾结点的后续结点
     * @param data
     */
    @Override
    public void addNode(T data){
        Node newNode = new Node(data);
        if(head == null){
            head = newNode;
            return;
        }
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
        }
        temp.next = newNode;
    }

长度

 /**
     * 求链表的长度
     * @return
     */
    @Override
    public int length(){
        int length = 0;
        Node curNode = head;
        while(curNode != null){
            length++;
            curNode = curNode.next;
        }
        return length;
    }

获取最后一个节点

    /**
     * 返回链表的最后一个结点
     */
    @Override
    public Node getLastNode(){
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
        }
        return temp;
    }

删除节点

  /**
     * 链表删除结点:
     * 把要删除结点的前结点指向要删除结点的后结点，即直接跳过待删除结点
     * @param index
     * @return
     */
    @Override
    public boolean deleteNode(int index){
        if(index<1 || index>length()){//待删除结点不存在
            return false;
        }
        if(index == 1){//删除头结点
            head = head.next;
            return true;
        }
        Node preNode = null;
        Node curNode = head;
        int i = 1;
        while(curNode != null){
            if(i==index){//寻找到待删除结点
                preNode.next = curNode.next;//待删除结点的前结点指向待删除结点的后结点
                return true;
            }
            //当先结点和前结点同时向后移
            preNode = curNode;
            curNode = curNode.next;
            i++;
        }
        return true;
    }

大佬的实现–包含一些其他的方法

package learn.stack;

import java.util.Hashtable;

/**
 * @author 
 * @create 2020-08-23 16:19
 */
public class MyLinkedList<T> implements LinkedListInterface<T> {
    /**链表的头结点*/
    Node head;

    public MyLinkedList() {
        head = null;
    }

    /**
     * 链表添加结点:
     * 找到链表的末尾结点，把新添加的数据作为末尾结点的后续结点
     * @param data
     */
    @Override
    public void addNode(T data){
        Node newNode = new Node(data);
        if(head == null){
            head = newNode;
            return;
        }
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
        }
        temp.next = newNode;
    }

    /**
     * 链表删除结点:
     * 把要删除结点的前结点指向要删除结点的后结点，即直接跳过待删除结点
     * @param index
     * @return
     */
    @Override
    public boolean deleteNode(int index){
        if(index<1 || index>length()){//待删除结点不存在
            return false;
        }
        if(index == 1){//删除头结点
            head = head.next;
            return true;
        }
        Node preNode = null;
        Node curNode = head;
        int i = 1;
        while(curNode != null){
            if(i==index){//寻找到待删除结点
                preNode.next = curNode.next;//待删除结点的前结点指向待删除结点的后结点
                return true;
            }
            //当先结点和前结点同时向后移
            preNode = curNode;
            curNode = curNode.next;
            i++;
        }
        return true;
    }

    /**
     * 求链表的长度
     * @return
     */
    @Override
    public int length(){
        int length = 0;
        Node curNode = head;
        while(curNode != null){
            length++;
            curNode = curNode.next;
        }
        return length;
    }

//    /**
//     * 链表结点排序,并返回排序后的头结点:
//     * 选择排序算法,即每次都选出未排序结点中最小的结点，与第一个未排序结点交换
//     * @return
//     */
//    public Node linkSort(){
//        Node curNode = head;
//        while(curNode != null){
//            Node nextNode = curNode.next;
//            while(nextNode != null){
//                if(curNode.data > nextNode.data){
//                    int temp = curNode.data;
//                    curNode.data = nextNode.data;
//                    nextNode.data = temp;
//                }
//                nextNode = nextNode.next;
//            }
//            curNode = curNode.next;
//        }
//        return head;
//    }

    /**
     * 打印结点
     */
    public void printLink(){
        Node curNode = head;
        while(curNode !=null){
            System.out.print(curNode.data+" ");
            curNode = curNode.next;
        }
        System.out.println();
    }

    /**
     * 去掉重复元素:
     * 需要额外的存储空间hashtable，调用hashtable.containsKey()来判断重复结点
     */
    public void distinctLink(){
        Node temp = head;
        Node pre = null;
        Hashtable<Object, Integer> hb = new Hashtable<>();
        while(temp != null){
            if(hb.containsKey(temp.data)){//如果hashtable中已存在该结点，则跳过该结点
                pre.next = temp.next;
            }else{//如果hashtable中不存在该结点，将结点存到hashtable中
                hb.put(temp.data, 1);
                pre=temp;
            }
            temp = temp.next;
        }
    }

    /**
     * 返回倒数第k个结点,
     * 两个指针，第一个指针向前移动k-1次，之后两个指针共同前进，
     * 当前面的指针到达末尾时，后面的指针所在的位置就是倒数第k个位置
     * @param k
     * @return
     */
    public Node findReverNode(int k){
        if(k<1 || k>length()){//第k个结点不存在
            return null;
        }
        Node first = head;
        Node second = head;
        for(int i=0; i<k-1; i++){//前移k-1步
            first = first.next;
        }
        while(first.next != null){
            first = first.next;
            second = second.next;
        }
        return second;
    }

    /**
     * 查找正数第k个元素
     */
    public Node findNode(int k){
        if(k<1 || k>length()){//不合法的k
            return null;
        }
        Node temp = head;
        for(int i = 0; i<k-1; i++){
            temp = temp.next;
        }
        return temp;
    }

    /**
     * 反转链表，在反转指针钱一定要保存下个结点的指针
     */
    public void reserveLink(){
        Node curNode = head;//头结点
        Node preNode = null;//前一个结点
        while(curNode != null){
            Node nextNode = curNode.next;//保留下一个结点
            curNode.next = preNode;//指针反转
            preNode = curNode;//前结点后移
            curNode = nextNode;//当前结点后移
        }
        head = preNode;
    }

    /**
     * 反向输出链表，三种方式：
     * 方法一、先反转链表，再输出链表，需要链表遍历两次
     * 方法二、把链表中的数字放入栈中再输出，需要维护额外的栈空间
     * 方法三、依据方法2中栈的思想，通过递归来实现，递归起始就是将先执行的数据压入栈中，再一次出栈
     */
    public void reservePrt(Node node){
        if(node != null){
            reservePrt(node.next);
            System.out.print(node.data+" ");
        }
    }

    /**
     * 寻找单链表的中间结点：
     * 方法一、先求出链表的长度，再遍历1/2链表长度，寻找出链表的中间结点
     * 方法二、：
     * 用两个指针遍历链表，一个快指针、一个慢指针，
     * 快指针每次向前移动2个结点，慢指针一次向前移动一个结点，
     * 当快指针移动到链表的末尾，慢指针所在的位置即为中间结点所在的位置
     */
    public Node findMiddleNode(){
        Node slowPoint = head;
        Node quickPoint = head;
        //quickPoint.next == null是链表结点个数为奇数时，快指针已经走到最后了
        //quickPoint.next.next == null是链表结点数为偶数时，快指针已经走到倒数第二个结点了
        //链表结点个数为奇数时,返回的是中间结点；链表结点个数为偶数时，返回的是中间两个结点中的前一个
        while(quickPoint.next != null && quickPoint.next.next != null){
            slowPoint = slowPoint.next;
            quickPoint = quickPoint.next.next;
        }
        return slowPoint;
    }


    /**
     * 判断链表是否有环：
     * 设置快指针和慢指针，慢指针每次走一步，快指针每次走两步
     * 当快指针与慢指针相等时，就说明该链表有环
     */
    public boolean isRinged(){
        if(head == null){
            return false;
        }
        Node slow = head;
        Node fast = head;
        while(fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
            if(fast == slow){
                return true;
            }
        }
        return false;
    }

    /**
     * 返回链表的最后一个结点
     */
    @Override
    public Node getLastNode(){
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
        }
        return temp;
    }

    /**
     * 在不知道头结点的情况下删除指定结点：
     * 删除结点的重点在于找出其前结点，使其前结点的指针指向其后结点，即跳过待删除结点
     * 1、如果待删除的结点是尾结点，由于单链表不知道其前结点，没有办法删除
     * 2、如果删除的结点不是尾结点，则将其该结点的值与下一结点交换，然后该结点的指针指向下一结点的后续结点
     */
    public boolean deleteSpecialNode(Node n){
        if(n.next == null){
            return false;
        }else{
            //交换结点和其后续结点中的数据
            T temp = (T) n.data;
            n.data = n.next.data;
            n.next.data = temp;
            //删除后续结点
            n.next = n.next.next;
            return true;
        }
    }

    /**
     * 判断两个链表是否相交：
     * 两个链表相交，则它们的尾结点一定相同，比较两个链表的尾结点是否相同即可
     */
    public boolean isCross(Node head1, Node head2){
        Node temp1 = head1;
        Node temp2 = head2;
        while(temp1.next != null){
            temp1 = temp1.next;
        }
        while(temp2.next != null){
            temp2 = temp2.next;
        }
        if(temp1 == temp2){
            return true;
        }
        return false;
    }

    /**
     * 如果链表相交，求链表相交的起始点：
     * 1、首先判断链表是否相交，如果两个链表不相交，则求相交起点没有意义
     * 2、求出两个链表长度之差：len=length1-length2
     * 3、让较长的链表先走len步
     * 4、然后两个链表同步向前移动，没移动一次就比较它们的结点是否相等，第一个相等的结点即为它们的第一个相交点
     */
    public Node findFirstCrossPoint(MyLinkedList linkedList1, MyLinkedList linkedList2){
        //链表不相交
        if(!isCross(linkedList1.head,linkedList2.head)){
            return null;
        }else{
            int length1 = linkedList1.length();//链表1的长度
            int length2 = linkedList2.length();//链表2的长度
            Node temp1 = linkedList1.head;//链表1的头结点
            Node temp2 = linkedList2.head;//链表2的头结点
            int len = length1 - length2;//链表1和链表2的长度差

            if(len > 0){//链表1比链表2长，链表1先前移len步
                for(int i=0; i<len; i++){
                    temp1 = temp1.next;
                }
            }else{//链表2比链表1长，链表2先前移len步
                for(int i=0; i<len; i++){
                    temp2 = temp2.next;
                }
            }
            //链表1和链表2同时前移,直到找到链表1和链表2相交的结点
            while(temp1 != temp2){
                temp1 = temp1.next;
                temp2 = temp2.next;
            }
            return temp1;
        }
    }
}

二、实现K个一组翻转链表

分析：

1 翻转链表
2 K 个一组

翻转链表：
将头结点变成尾部节点，尾部节点变成头部节点。
类似 1->2->3->4->5->6->''
翻转 ''<-1<-2<-3<-4<-5<-6    正过来就是 6->5->4->3->2->1->''
判断出停止条件为 current->next ==null 为停止节点
翻转逻辑： current->next=前一个节点
指针移动：current =后一个节点  前一个节点=current
得出公式为： 后一个节点=current->next   // 翻转前记录后一个节点位置
            current->next=前一个节点
            前一个节点=current 
            current =后一个节点 
K 个-组：
设 k=2 链表长度 5 ，就是 1->2 翻转  3->4 翻转  5 不翻转。
也就是说这是一个范围翻转。起始节点翻转到结束节点。
看成1->2   3->4 5 
反复调用是一个递归过程。
结束条件为： 最后的构成不了一个k 元素构成的链表了，也就是说循环的起始节点到结束节点的过程中节点为空了。

实现代码

代码如下：反转

  public static Node reverseListNode(Node head){
        //单链表为空或只有一个节点，直接返回原单链表
        if (head == null || head.next == null){
            return head;
        }
        //前一个节点指针
        Node preNode = null;
        //当前节点指针
        Node curNode = head;
        //下一个节点指针
        Node nextNode = null;
        while (curNode != null){
            nextNode = curNode.next;//nextNode 指向下一个节点
            curNode.next=preNode;//将当前节点next域指向前一个节点
            preNode = curNode;//preNode 指针向后移动
            curNode = nextNode;//curNode指针向后移动
        }

        return preNode;
    }

代码如下：反转区间【a,b)

 /** 反转区间 [a, b) 的元素，注意是左闭右开 */
    public static Node reverseListNode(Node headNode,Node endNode){
        //单链表为空或只有一个节点，直接返回原单链表
        if (headNode == null || headNode.next == null){
            return headNode;
        }
        //前一个节点指针
        Node preNode = null;
        //当前节点指针
        Node curNode = headNode;
        //下一个节点指针
        Node nextNode = null;
        while (curNode != endNode){

            nextNode = curNode.next;//nextNode 指向下一个节点
            curNode.next=preNode;//将当前节点next域指向前一个节点
            preNode = curNode;//preNode 指针向后移动
            curNode = nextNode;//curNode指针向后移动
        }
        return preNode;
    }

代码如下：反转K个一组元素

public static Node reverseListNode(Node headNode,int k){
        if (headNode == null) {return null;}
        // 区间 [a, b) 包含 k 个待反转元素
        Node a, b;
        a = b = headNode;
        for (int i = 0; i < k; i++) {
            // 不足 k 个，不需要反转，base case
            if (b == null) {return headNode;}
            b = b.next;
        }
        // 反转前 k 个元素
        Node newHead = reverseListNode(a, b);
        // 递归反转后续链表并连接起来
        a.next = reverseListNode(b, k);
        return newHead;
    }

代码如下：方法调用

   public static void main(String[] args) {
     MyLinkedListP linkedList=new MyLinkedListP();
        linkedList.addNode(1);
        linkedList.addNode(2);
        linkedList.addNode(3);
        linkedList.addNode(4);
        linkedList.addNode(5);
        linkedList.addNode(6);
        linkedList.addNode(7);
        linkedList.addNode(8);
        linkedList.addNode(9);
        linkedList.printLink();
       linkedList.head= reverseListNode(linkedList.head,10);
      // linkedList.reserveLink();
        linkedList.printLink();
    }

---

总结

对于链表的反转主要是确定指针的指向，以及先记录当前指针的下一个节点。对于单链表来说当前节点是唯一知道下一个节点的节点。当前节点变化后如不记录，则链表就断了。关于区间反转确定反转范围，结束条件，同时这也是递归的思想，一个依靠自己的循环，递归在树中应用较多，学习到树时进行总结。