单链表反转的两种算法

代码里有两个算法，默认执行的是，对于几个链式节点数据进行反转。还有一个算法，是自己定义出一个单链表的数据结构。然后基于这个数据结构，再实现一个数据反转的算法。当然，算法移动到单链表中，就可以作为单链表的一个操作了。

package com.justalk.javademo.leetcode;

public class LinkedListReverse {

    static class LinkedList {

        private LinkedNode mLastNode;
        private int size;
        private final LinkedNode mHead = new LinkedNode(-1);

        public void put(int nodeValue) {
            LinkedNode node = new LinkedNode(nodeValue);
            if (mLastNode == null) {
                mHead.next = node;
            } else {
                mLastNode.next = node;
            }
            mLastNode = node;
            size++;
        }

        public LinkedNode get(int index) {
            if (size == 0) {
                System.out.println("链表没有数据");
                return null;
            } else if (index > size) {
                System.out.println("输入的索引大于当前的数据个数");
                return null;
            } else {
                LinkedNode searchNode = null;
                for (int i = 0; i <= index; i++) {
                    if (i == 0) {
                        searchNode = mHead;
                    } else {
                        searchNode = searchNode.next;
                    }
                }
                return searchNode;
            }
        }

        private String getLinkedListValues() {
            LinkedNode linkedNode = mHead.next;
            if (linkedNode == null) {
                throw new IllegalArgumentException("链表目前为空");
            }
            StringBuilder sb = new StringBuilder();
            while (linkedNode.next != null) {
                sb.append(linkedNode.var);
                sb.append(" ");
                linkedNode = linkedNode.next;
            }
            sb.append(linkedNode.var);
            return sb.toString();
        }

    }

    static class LinkedNode implements Cloneable {

        int var;
        LinkedNode next;

        public LinkedNode() {
        }

        public LinkedNode(int var) {
            this.var = var;
        }

        @Override
        protected LinkedNode clone() throws CloneNotSupportedException {
            LinkedNode linkedNode = (LinkedNode) super.clone();
            LinkedNode linkedNodeTwo = (LinkedNode) super.clone();
            copyNode(linkedNode, linkedNodeTwo);
            return linkedNode;
        }

        private void copyNode(LinkedNode linkedNode, LinkedNode linkedNodeTwo) throws CloneNotSupportedException {
            if (linkedNode.next != null && linkedNodeTwo.next != null) {
                linkedNode.next = linkedNodeTwo.next.clone();
                if (linkedNode.next != null && linkedNodeTwo.next != null) {
                    copyNode(linkedNode.next, linkedNodeTwo.next);
                }
            }
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(var);
            sb.append(" ");
            while (next != null) {
                sb.append(next.var);
                sb.append(" ");
                next = next.next;
            }
            return sb.toString();
        }
    }

    public static void main(String[] args) {
//        linkedTableReverse();
        LinkedNode linkedNode = rawLinkedTableReverse();
        System.out.println(linkedNode);
    }

    private static LinkedNode rawLinkedTableReverse() {
        LinkedNode linkedNode = initLinkedTableData();
        LinkedNode pre = null, child;
        while (linkedNode != null) {
            //先记录下拆分后剩下的链表
            child = linkedNode.next;
            linkedNode.next = pre;
            pre = linkedNode;
            linkedNode = child;
        }
        return pre;
    }

    private static LinkedNode deepCopyLinkedTable() {
        LinkedNode linkedNode = initLinkedTableData();
        LinkedNode linkedNodeClone = null;
        try {
            linkedNodeClone = linkedNode.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return linkedNodeClone;
    }

    private static LinkedNode initLinkedTableData() {
        LinkedNode linkedNode1 = new LinkedNode(1);
        LinkedNode linkedNode2 = new LinkedNode(2);
        LinkedNode linkedNode3 = new LinkedNode(3);
        LinkedNode linkedNode4 = new LinkedNode(4);
        LinkedNode linkedNode5 = new LinkedNode(5);
        linkedNode1.next = linkedNode2;
        linkedNode2.next = linkedNode3;
        linkedNode3.next = linkedNode4;
        linkedNode4.next = linkedNode5;
        linkedNode5.next = null;
        return linkedNode1;
    }

    private static void linkedTableReverse() {
        LinkedList linkedList = new LinkedList();
        linkedList.put(1);
        linkedList.put(2);
        linkedList.put(3);
        linkedList.put(4);
        linkedList.put(5);
        System.out.println(linkedList.getLinkedListValues());
        reverseLinkedList(linkedList);
    }

    private static void reverseLinkedList(LinkedList linkedList) {
        LinkedNode temp, changeNode;
        LinkedNode headNode = linkedList.mHead;
        for (int i = 2; i <= linkedList.size; i++) {
            LinkedNode previewNode = linkedList.get(i - 1);
            LinkedNode currNode = linkedList.get(i);
            temp = currNode.next;
            changeNode = headNode.next;
            //开始进行插入操作
            headNode.next = currNode;
            currNode.next = changeNode;
            previewNode.next = temp;
            System.out.println("反转之后的结果是：");
            System.out.println(linkedList.getLinkedListValues());
        }
    }
}