编程题之--链表反置

　　对链表进行反置。例如：

　　[1] -> [2] -> [3] -> [null]

变成：

　　[3] -> [2] -> [1] -> [null]。

我的思路如下：

　　顺着链表循环一次，当走到某个节点上时，把当前节点的next设为上一个节点，但是，为了不丢失下一个节点的引用，需要在设置next为上一个节点之前，用一个临时变量保存下个节点的引用，具体过程如下，链表长度为3：其中(p)、(c)、(n)下标分别表示previous，current，next，即上一个，当前和下一个节点。

参考代码：

1） LinkNode.java

public class LinkNode<T> {

    private T data;
    private LinkNode<T> next = null;

    public LinkNode(T data) {
        this.data = data;
        this.next = null;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public boolean hasNext() {
        return this.next != null;
    }

    public LinkNode<T> getNext() {
        return next;
    }

    public void setNext(LinkNode<T> next) {
        this.next = next;
    }

    public void display() {
        System.out.printf(" {%s} ", data.toString());
    }
    
}

2) LinkList.java，链表反置的函数为下面代码中的reverse()函数。

public class LinkList<T> {

    private LinkNode<T> first;

    public LinkList() {
        this.first = null;
    }

    public boolean isEmpty() {
        return this.first == null;
    }

    public LinkNode<T> getFirst() {
        return first;
    }

    public void setFirst(LinkNode<T> first) {
        this.first = first;
    }

    public void insertFirst(T newEle) {
        LinkNode<T> tLinkNode = new LinkNode<>(newEle);
        tLinkNode.setNext(first);
        first = tLinkNode;
    }

    public void displayList() {
        System.out.println("List(first-->last): ");
        LinkNode<T> current = first;
        while (current != null) {
            current.display();
            current = current.getNext();
        }
        System.out.println(" ");
    }

    public void reverse() {
        if (this.first == null) {
            return;
        }
        LinkNode<T> previous = null;
        LinkNode<T> current = this.first;
        LinkNode<T> next = current.getNext();

        while (current != null) {
            current.setNext(previous);

            previous = current;
            current = next;
            next = current != null ? current.getNext() : null;
        }
        this.first = previous;
    }

    public static void main(String[] args) {
        LinkList<Integer> linkList = new LinkList<>();
        linkList.insertFirst(5);
        linkList.insertFirst(4);
        linkList.insertFirst(3);
        linkList.insertFirst(2);
        linkList.insertFirst(1);
        linkList.displayList();

        linkList.reverse();
        linkList.displayList();

    }
}

下面介绍一下其他思路：

　　[1] -> [2] -> [3] -> [null]

变成：

　　[3] -> [2] -> [1] -> [null]。

　　思路1：创建一个新的链表，把原来链表上节点逐个拆下来，然后作为头结点插入到新链表中，新链表即为反转后的链表。

    public LinkList<T> reverseNew() {
        LinkList<T> reverse = new LinkList<>();
        LinkNode<T> current = this.first;
        while (current != null) {
            this.deleteFirst();
            reverse.insertFirst(current);
            current = this.first;
        }
        return reverse;
    }