链表反转算法

闲余时间把看了一些常见的算法题,把链表对应的常见算法写了一下 如有疑问可加我QQ:1051980588共同探讨

package com.trs.codetool.sort;

/**
 * @author zheng.changgang
 * @date 2020-01-02 09:57
 * 链表的常见算法
 */
public class LianBiao {
    static Node  head = new Node(0);
    public static void main(String[] args) {
        int[] nums = {1,2,3,4,5};
        for(int i=0;i<nums.length;i++) {
            addNode(nums[i]);
        }
        //printNode(head);

     /*  // 递归反转链表
        Node invertNode = invertLinkedList(head.next);
        System.out.println();
        head.next = invertNode;
        printNode(head);
        // 非递归反转链表
        iterationInvertLinkedList(head);
        printNode(head);
        Integer from = 2;
        Integer to = 4;
        // 变形题 1：给定一个链表的头结点 head,以及两个整数 from 和 to ,在链表上把第 from 个节点和第 to 个节点这一部分进行翻转。例如：给定如下链表，from = 2, to = 4 head-->5-->4-->3-->2-->1 将其翻转后，链表变成 head-->5--->2-->3-->4-->1
        iterationInvertLinkedList(head,from,to);
        printNode(head);**/
       // 变形题 2：给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序
        iterationInvertLinkedListEveryK(2);
        printNode(head);

    }

    /**
     * 每 k 个一组翻转链表
     * @param k
     */
    public static void iterationInvertLinkedListEveryK(int k) {
        Node tmp = head.next;
        int step = 0;               // 计数，用来找出首结点和尾结点

        Node startK = null;         // k个一组链表中的头结点
        Node startKPre = head;      // k个一组链表头结点的前置结点
        Node endK;                  // k个一组链表中的尾结点
        while (tmp != null) {
            // tmp 的下一个节点,因为由于翻转，tmp 的后继结点会变,要提前保存
            Node tmpNext = tmp.next;
            if (step == 0) {
                // k 个一组链表区间的头结点
                startK = tmp;
                step++;
            } else if (step == k-1) {
                // 此时找到了 k 个一组链表区间的尾结点（endK）,对这段链表用迭代进行翻转
                endK = tmp;
                Node pre = null;
                Node cur = startK;
                if (cur == null) {
                    break;
                }
                Node endKNext = endK.next;
                while (cur != endKNext) {
                    Node next = cur.next;
                    cur.next = pre;
                    pre = cur;
                    cur = next;
                }
                // 翻转后此时 endK 和 startK 分别是是 k 个一组链表中的首尾结点
                startKPre.next = endK;
                startK.next = endKNext;

                // 当前的 k 个一组翻转完了，开始下一个 k 个一组的翻转
                startKPre = startK;
                step = 0;
            } else {
                step++;
            }
            tmp = tmpNext;
        }
    }

    /**
     * 变形题 1：给定一个链表的头结点 head,以及两个整数 from 和 to ,在链表上把第 from 个节点和第 to 个节点这一部分进行翻转。例如：给定如下链表，from = 2, to = 4 head-->5-->4-->3-->2-->1 将其翻转后，链表变成 head-->5--->2-->3-->4-->1
     * @param head
     * @param fromIndex
     * @param toIndex
     */
    private static void iterationInvertLinkedList(Node head, Integer fromIndex, Integer toIndex) {
        // from-1结点
        Node fromPre = null;
        Node from = null;
        Node to = null;
        Node toNext = null;
        Integer index = 1;
        Node temp = head.getNext();
        // 记录之前的节点
        while (temp != null) {
            if(fromIndex-1 == index) {
                fromPre = temp;
            } else if(fromIndex == index) {
                from = temp;
            } else if(toIndex+1 == index) {
                toNext = temp;
            } else if(toIndex == index) {
                to = temp;
            }
            index++;
            temp = temp.next;
        }

        Node pre = null;
        Node cur =from;
        while (cur != toNext) {
            Node next = cur.getNext();
            cur.setNext(pre);
            pre = cur;
            cur = next;
        }
        // 步骤3：将 from-1 节点指向 to 结点（如果从 head 的后继结点开始翻转，则需要重新设置 head 的后继结点），将 from 结点指向 to + 1 结点
        if (fromPre != null) {
            fromPre.next = to;
        } else {
            head.next = to;
        }
        from.next = toNext;

    }

    /**
     * 递归反转链表
     * @param node
     * @return
     */
    private static Node invertLinkedList(Node node) {
        if(node.next == null) {
            return node;
        }
        Node newHead = invertLinkedList(node.next);
        node.next.next = node;
        node.next = null;
        return newHead;
    }

    /**
     * 非递归反转
     * @param node
     */
    private static void iterationInvertLinkedList(Node node) {
        Node pre = null;
        Node cur = node.next;
        while (cur != null) {
            Node next = cur.next;
            cur.setNext(pre);
            pre = cur;
            cur = next;
        }
        node.setNext(pre);

    }

    /**
     * 打印节点
     */
    private static void printNode(Node temp) {
        Node cur = temp.next;
        while (cur != null) {
            if(cur.next != null) {
                System.out.print(cur.getValue()+"->");
            } else {
                System.out.print(cur.getValue());
            }
            cur = cur.next;
        }
    }

    /**
     * 添加节点
     * @param num
     */
    private static void addNode(int num) {
        Node cur = head;
         while (cur.next != null) {
             cur = cur.next;
         }
         cur.next = new Node(num);
    }

    static class Node {
        private Integer value;
        private Node next;

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

        public Integer getValue() {
            return value;
        }

        public void setValue(Integer value) {
            this.value = value;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }
    }
}