链表的反转

1、思路：

就地反转：

首先设置两个变量：pre: 当前节点的前一个节点，currentNode: 当前节点，nextNode: 当前节点的后一个节点。

 

 

2、代码分享

 

package com.ethjava;

class Node {
    //节点内容
    int data;
    //下一个节点
    Node next;//注意存储的下一个节点是Node;

    Node(int data) {
        this.data = data;
    }

    //向后追加节点，只要找到火车头，就可以加到链表的最后一个节点
    void append(Node n1) {
        Node currentNode = this;
        while (true) {
            Node nextNode = currentNode.next;
            if (nextNode != null) {
                currentNode = nextNode;
            } else {
                currentNode.next = n1;
                break;
            }
        }
    }

    Node append3(Node n1) {
        Node currentNode = this;
        while (true) {
            Node nextNode = currentNode.next;
            if (nextNode != null) {
                currentNode = nextNode;
            } else {
                currentNode.next = n1;
                break;
            }
        }
        return currentNode.next;
    }

    //向后追加节点，依次追加，2追加在1后面，3追加在2后面
    void append2(Node n1) {
        this.next = n1;
    }

    //获得节点的数据
    int getData() {
        return this.data;
    }

    //获得节点存储的下一个节点
    Node getNext() {
        return this.next;
    }

    //判断当前节点是否为最后的节点
    boolean lastNode() {
        boolean forture = this.next == null ? true : false;
        return forture;
    }

    //增加节点，把n2节点增加在当前节点之后
    void addNode(Node n2) {
        Node currentNode = this;
        Node n3 = currentNode.next;
        currentNode.next = n2;
        n2.next = n3;
    }

    //删除当前节点不可能，因为无法获得上个节点的信息，把自己之后的节点给了自己上一个节点
    //删除下一个节点
    void removeNextNode() {
        Node currentNode = this;
        Node n2 = currentNode.next;
        Node n3 = n2.next;
        currentNode.next = n3;
    }

    //链表的反转,传入参数原来的头结点，返回参数：反转后的头结点
    static Node reverseLianbiao(Node Head) {
        Node pre = null;//当前节点的前一个节点
        Node nextNode = null;//当前节点的后一个节点
        Node currentNode = Head;//当前节点
        while (currentNode != null) { //注意while
            nextNode = currentNode.next;
            currentNode.next = pre;//反转
            pre = currentNode;
            currentNode = nextNode;
            // System.out.println("此时当前节点的值为："+currentNode.getData());
        }
        return pre;
    }

    void display() {
        Node currNode = this;
        while (currNode != null) {
            System.out.print(currNode.getData() + " ");
            currNode = currNode.next;
        }
    }
}

public class lianbiao {
    public static void main(String[] args) {

        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        //这里我们创建了3个节点，每个节点是独立的，没有连起来，值分别是1，2，3，next都是null。

        node1.append2(node2);
        node2.append2(node3);
        System.out.println(node1.getNext().getNext().getData());
        //3

        //希望三个节点连起来，把node2放在node1后面，

        Node n4 = new Node(4);
        Node n5 = new Node(5);
        Node n6 = new Node(6);
        Node n7 = new Node(7);
        n4.append(n5);
        n4.append(n6);
        n4.append(n7);

        System.out.println(n4.getNext().getNext().getNext().getData());
        //7

        Node n8 = new Node(8);
        Node n9 = new Node(9);
        Node n10 = new Node(10);
        Node n11 = new Node(11);
        n8.append3(n9).append3(n10).append(n11);

        System.out.println(n8.getNext().getNext().getNext().getData());
        //11

        boolean f = n10.lastNode();
        System.out.println(f);
        //false

        boolean t = n11.lastNode();
        System.out.println(t);
        //true

        Node node12 = new Node(12);
        n10.addNode(node12);
        System.out.println(n10.getNext().getData());//12
        System.out.println(n10.getNext().getNext().getData());//11
        //此时将12增加到了10的后面，10后面的原本的11增加到了12后面。10-12-11

        n10.removeNextNode();
        System.out.println(n10.getNext().getData());//11
        //把10后面的12删除了

        //输出；链表的所有的数据
        n8.display();
        System.out.println();
        //8 9 10 11

        Node n = Node.reverseLianbiao(n8);
        System.out.println(n.getData());//11
        System.out.println(n.getNext().getNext().getNext().getData());//8
        //反转成功，11成为新的头结点，8成为新的尾节点


    }
}