链表的翻转

链表的翻转分为部分翻转和全部翻转。本文，实现了一种通用的链表翻转程序，其时间复杂度为n。

链表如下：

程序中包含如下类：
１、Node类，即链表的节点，节点中只有一个属性iData；

class Node {    public int iData;    Node nextNode = null;    public Node(int iData) {        this.iData = iData;    }}

２、链表类，链表类中仅实现了插入和打印链表的方法，并且链表具有表头节点root具体如下：

class Link {    public Node root = null;    public void insert(int iData) {        Node newNode = new Node(iData);        if (root == null) {            root = newNode;        } else {            Node current = root;            Node pre = root;            while (current != null) {                pre = current;                current = current.nextNode;            }            pre.nextNode = newNode;        }    }    public void display() {        Node current = root;        while (current != null) {            System.out.print(current.iData + " ");            current = current.nextNode;        }        System.out.println();    }}

３、翻转链表的实现
链表从0开始计数，例如要翻转１到４中的元素（包含边界节点），那么输出应该是：

0 4 3 2 1 5 6 7

如果链表要翻转０到７的所有元素输出应该是

7 6 5 4 3 2 1 0

采用头插法，定义三个指针（这里只java的引用，因为类似c语言中的指针，因此这里借用指针之一概念，但是java里面是没有指针概念的），
pre：用来指向要翻转的节点的前一个节点，例如当要翻转１到４节点时，pre指向第０个节点
current：用来指向需要操作的节点
next：用来指向原链表中的下一个要操作的节点
tmp：指向第一个要操作的节点，当全部的节点翻转完后该节点需要链上剩余的节点（没有被要求翻转的节点），例如当要翻转１到４节点时tmp指向的是第一个节点。
翻转n到m节点，翻转的过程，以翻转１到４节点为例（n=1，m=4），
首先链表的pre空转０步（空转就是pre遍历沿着节点向下走，什么也不做，空转是为了将pre指向需要翻转的节点之前的节点这里时节点０）使pre指向０号节点，从该节点的下一个节点开始翻转；然后将current指向pre节点的下一个节点，接下来需要断开current在原链表中所指向的下一个节点，在断开之前需要将next节点指向current的下一个节点即current.nextNode节点，因此next指向current的下一个节点；然后将current节点的从原链表中断掉，使current的下一个节点（current.netNode）指向pre的下一个节点（pre.nextNode）；断掉pre的下一个节点pre.nextNode的原指向，使pre.nextNode指向current节点，这样第一次翻转成功（注意当执行第一次翻转的时候会发现pre.nextNode和current是同一个节点，因此第一次会使current的下一个节点指向自身）。然后将current从新指向next节点。重复步骤直到翻转了n-m次；最后将剩下的不需要翻转的节点链上，当循环结束后next保存的就是剩下的第一个不需要翻转的节点，而如前所述tmp保存的是第一个被翻转的节点，因此将tmp.nextNode指向next节点。
如图：

将操作步骤罗列如下：
（１）、链表的pre空转０步使pre指向０号节点；
（２）、将current指向pre节点的下一个节点；
（３）、将next节点指向current的下一个节点 ；
（４）、断开current在原链表中所指向的下一个节点；
（５）、将current的下一个节点指向pre节点的下一个节点；
（６）、断掉pre的下一个节点pre.nextNode的原指向，使pre.nextNode指向current节点;
（７）、将current指向next指向的节点；
（８）、重复步骤３到７，指导翻转了n-m次；
（９）、将tmp.nextNode指向next节点。
注意:当从节点０开始翻转时，上面的步骤需要适当的修改，因为当需要从０号节点开始翻转时，pre是　无法指向０节点之前的节点的，因此如果需要从０　号开始翻转，可以在链表的头部加一个节点，然后在进行翻转，在翻转完成后将链表的root节点从新指向pre.nextNode即可。
翻转操作的代码：

public class LinkFlip {    public static void main(String[] args) {        Link myLink = new Link();        myLink.insert(0);        myLink.insert(1);        myLink.insert(2);        myLink.insert(3);        myLink.insert(4);        myLink.insert(5);        myLink.insert(6);        myLink.insert(7);        flip(myLink, 0, 7);        myLink.display();    }    public static void flip(Link mylink, int m, int n) {        Node pre = mylink.root;        Node current = mylink.root;        Node next = mylink.root;        Node tmp = null;        if (m == 0) {            pre = new Node(-1);            pre.nextNode = mylink.root;        } else {            for (int i = 0; i < m - 1; i++) {                pre = pre.nextNode;            }        }        current = pre.nextNode;        tmp = current;        pre.nextNode = null;        for (int i = 0; i <= (n - m); i++) {            next = current.nextNode;            current.nextNode = pre.nextNode;            System.out.println(current.iData);            pre.nextNode = current;            current = next;        }        if (m == 0) {            mylink.root = pre.nextNode;        }        tmp.nextNode = next;    }}

写了个更简单的

  public ListNode ReverseList(ListNode head) {        ListNode pre = null;        ListNode current = head;        ListNode next = null;        while(current!=null){            next = current.next;            current.next = pre;            pre= current;            current = next;        }        return pre;    }