递归逆置带头结点的单链表_C/C++&Java

这周的算法作业之一，逆置这步倒不是很难想。

逆置这步就先递归到最深层，让尾巴指向自己的父节点，然后返回到父节点，让node.next.next指向node就可以实现指向父节点，之后每返回到上层就这样执行，所以递归调用代码要在node.next.next = node 这行代码之前执行。
但是昨晚有两个问题没想出来，就一直困扰着我。

1. 怎么让头结点去指向尾结点？
2. 怎么能让原来的第一个结点的next为空？

之后上网查了一下怎么解决，发现了一个方法。
针对第一个问题，在不断递归的情况下，指针是越走越深的，到尾结点时早就过了头结点了，怎么在变化的指针下获得不变的头结点呢？发现参数是在递归函数中可以始终不发生改变的。
那么我们将头结点作为一个参数，每次递归我们不对其进行操作，只传入，等到最后一次，我们将头结点next去指向尾结点。

第二个问题，其实是之前少想了一步。之前就想这node.next.next = node，实现了逆置即可。但是对于node.next，并没有考虑太多。原因是因为在返回上层函数后，还是会被上述那行代码所改变。但是当返回到最上层（第一个结点时），并没有他的父节点了，不可能再往上层返回，所以在执行完子节点指针的逆置操作后，将自己的指针置为null，就是为了让逆置后的尾结点next能为null而不是指向自己的父结点。

上代码！！！

Java代码

结点类Node

/**
 * @author 滑技工厂
 * @version 1.0
 * @ClassName Node
 * @Description 结点类
 * @date 2020/2/25
 */
public class Node {
    Integer data;
    Node next;

    public Node() {
    }

    public Node(Integer data, Node next) {
        this.data = data;
        this.next = next;
    }
    /*
     * @Title reverse
     * @Description 逆置单链表
     * @author 滑技工厂
     * @Date 2020/2/25
     * @param [node, head]
     * @return void
     * @throws 
     */
    public static void reverse(Node node, Node head) {
        //如果子节点为空（到了最后一个结点，尾巴），将头结点的next指向尾巴，返回上个结点（倒数第二个）
        if (node.next == null) {
            head.next = node;
            return;
        }
        //一直往下递归，直到尾巴
        reverse(node.next, head);
        //向上返回之后，让node的子节点的next指向node自己
        node.next.next = node;
        //这步对于除第一个结点外的其他结点无用，是为了让逆置之后的尾结点的next为null而写，其他结点的next会因上一步指向自己的父节点
        node.next = null;
    }
    /*
     * @Title print
     * @Description 打印单链表
     * @author 滑技工厂
     * @Date 2020/2/25
     * @param [node]
     * @return void
     * @throws 
     */
    public static void print(Node node) {
		//node为空时（此时node=rear.next），不执行
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }

    }
    /*
     * @Title create
     * @Description 根据数组创建单链表
     * @author 滑技工厂
     * @Date 2020/2/25
     * @param [head, a]
     * @return void
     * @throws 
     */
    public static void create(Node head, int a[]) {

        Node tmp = head;
        for (int i = 0; i < a.length; i++) {
            tmp.next = new Node(a[i], null);
            tmp = tmp.next;
        }
    }
}

主类Main

/**
 * @ClassName 
 * @Description 入口类
 * @author 滑技工厂
 * @date 2020/2/25
 * @version 1.0
 */
public class Main {

    public static void main(String[] args) {

        Node head = new Node();

        int[] arr = new int[9];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }

        Node.create(head, arr);

        Node.print(head.next);
        
        System.out.println();
        
        Node.reverse(head.next, head);
        
        Node.print(head.next);
    }

}

C++代码

下面是网上找的一个c++代码

static void reverse_list(LinkNode *p, LinkNode *&L)
{
    if(p->next == NULL) // 以p为首结点指针的单链表只有一个结点时
    {
        L->next = p; // p结点变为尾结点
        return;
    }
    reverse_list(p->next, L);
    p->next->next = p; // 将结点链接在尾结点之后
    p->next = NULL; // 尾结点next域置为NULL
}
————————————————
版权声明：本文为CSDN博主「静能生悟」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xiezhi123456/article/details/86583167

本篇到此结束。其实是不太想发这篇的，因为我室友会看我博客馋我代码（作业），但是还是发出来算了，刚得到的知识拿出来分享总有满满的成就感呢！

如果这篇对你有帮助请点击下方一键三连谢谢大家（拿错台词）