单链表类倒置（迭代和递归方法）--Java实现

版权声明：071623 https://blog.csdn.net/weixin_43584220/article/details/89036643

/**
 * @author Ravanla
 * @create 2019-04-04-18:12* Ctrl+D，复制行
 *  * @author Ravanla
 *  * @create 2019-04-04-15:35
 *  * 需要增加结点方法
 *  * 插入结点到指定位置
 *  * 删除指定位置结点
 *  * 通过选择排序对链表排序
 *  * 还有插入排序进行排序
 *  * 链表长度
 *  * 打印结点
 *
 */
public class reverseList {
    public static void main(String[] args){
        LinkNode head = new LinkNode();
        head.addNode(new Node(2));
        head.addNode(new Node(3));
        head.addNode(new Node(4));
        head.addNode(new Node(5));
        System.out.println(head.linkLength());
        head.print();
        head.insetNode(2,new Node(4));
        head.insetNode(3,new Node(5));
        head.insetNode(3,new Node(9));
        head.print();
        head.deleteNode(4);
        head.print();
        Node reverseList = head.reverseList();
        System.out.println("+++++++++++++++++++++");
        head.printPrev(reverseList);
    }

}

下面时单链表类需要的一些方法，没有详细写出来了

class LinkNode{
//    这里一定要创建一个头节点
    Node head = new Node(1);

//    需要增加结点方法
    public void addNode(Node node){
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = node;
    }

//    插入结点到指定位置
    public void insetNode(int Index, Node node){
        if(Index < 0 || node == null || Index > linkLength()){
            System.out.println("insetNode中的Index有错误");
            return;
        }
        else{
            Node temp = head;
            for(int i = 0; i < Index; i++){
                temp = temp.next;
            }
            Node tempNext = temp.next;
            temp.next = node;
            node.next = tempNext;
        }
    }

//    删除指定位置结点
    public void deleteNode(int Index){
        if(Index < 0 || Index > linkLength()){
            System.out.println("deleteNode中的Index有错误");
            return;
        }
        else{
            Node temp = head;
            for(int i = 1; i < Index; i++){
                temp = temp.next;
            }
            Node tempNextNext = temp.next.next;
            temp.next = tempNextNext;
        }
    }

//    链表长度
    public int linkLength(){
        int lenght = 0;
        Node temp = head;
        while (temp.next != null) {
            lenght++;
            temp = temp.next;
        }
        return ++lenght;
    }

//    打印结点
    public void print(){
        if (head != null) {
            Node temp = head;
            while (temp.next != null){
                System.out.print(temp.data + " ");
                temp = temp.next;
            }
            System.out.print(temp.data);
            System.out.println();
        }
        else {
            System.out.println("print中head为空");
            return;
        }
    }

# 下面是单链表类倒置方法（递归）

注意，这里先看代码，看了几遍都看不懂的话就看我画的”自画像“

//    递归reverseList
    public Node reverseList(Node head01){
        if(head01 == null || head01.next == null)return head01;
        Node p = reverseList(head01.next);
        head01.next.next = head01;
        head01.next = null;
        return p;
    }

head01.next.next = head01;//精辟在这段代码

下面是单链表类倒置方法（迭代）

//    迭代方法写出的reverseList
    public Node reverseList(){
        Node prev = null;
        Node curr = head;
        //最好读懂代码的方法是拿一些结点进行代码分析
        //这里我们需要curr记录当前结点，
        //第一步先把pre设置为null，然后记录头结点
        
        //第二步就是迭代了  如果当前结点不为空
        while (curr != null) {
        	//创建新的结点用来记录当前结点（curr）的下一个结点（next）
            Node tempNext = curr.next;
            //让当前结点的next指向prev（也就是调换方向了）
            curr.next = prev;
            //下一个结点要调换方向时要把prev设置为当前结点
            prev = curr;
            //然后把当前结点往下移
            curr = tempNext;
        }
        return prev;
    }

//    打印reverseList
    public void printPrev(Node prev){
        if (prev != null) {
            Node temp = prev;
            while (temp.next != null){
                System.out.print(temp.data + " ");
                temp = temp.next;
            }
            System.out.print(temp.data);
            System.out.println();
    }
}
}

class Node{
    Node next;
    int data;

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

输出结果