逆置一个单链表的三种方法

/**
 * 逆置一个单链表有3种方法,这里我们将完整的实现:
 * 
 * 方法 1):头插法建立新的链表 建立一个新的链表,把原来的单链表从头顺序遍历,遍历的每个结点都用头插法插入到新的链表中,这样新的链表自然就成原来
 * 的逆置得了。由于要遍历原来链表和建立新的链表,所以这种方法时间和空间复杂度都为O(n),好处是不用修改原来的链表,坏处就是多了空间复杂度。这种方
 * 法是最常用。
 *
 * 方法2): 原地逆置这种方法主要是每每修改两个相邻结点p,q的前后关系,增加一个t保存下一次的修改目标结点,既然都叫原地逆置了,所以空间复杂度为O(1)
 * ,时间同样为O(n),但是这种方法修改了原来的链表,所以要特*别注意,慎重使用。注意不要形成环了,可以在idea中跑跑。
 * 
 * 方法3): 使用递归,reverse(head),出口设置为head==null 和head.next==null ,但是特别注意递归子情况的判断,详情参见代码。
 * 
 * 方法4) :Collections.reverse(); 这个方法之后做剖析,下一篇和Arrays.asList()以及toArray()结合介绍。
 **/

import java.util.*;

//定义一个节点
class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        next = null;
    }
}
//完整实现

public class Solution {
    public static void main(String args[]) {
        int a[] = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
        Solution s = new Solution();
        System.out.print("逆置前链表为:");
        Node L = s.init(a);
        s.show(L);
        //每次逆置可能改变L,所以就重新建立一次链表
        System.out.print("逆置方法1:  ");
        L = s.init(a);
        s.show(s.reverse1(L));
        System.out.print("逆置方法2:  ");
        L = s.init(a);
        s.show(s.reverse2(L));
        //递归最好不要头结点
        System.out.print("逆置方法3:  ");
        L = s.init(a);
        Node newL = new Node(-1);
        newL.next = s.reverse3(L.next);
        s.show(newL);

    }

    //初始化,用尾插法建立链表
    private Node init(int a[]) {
        //增加一个头结点,方便操作
        Node L = new Node(-1);
        int n = a.length;
        if (n == 0)
            return L;
        Node rear = L;
        for (int i = 0; i < n; i++) {
            Node p = new Node(a[i]);
            rear.next = p;
            rear = p;
        }
        return L;
    }

    //打印一个链表
    private void show(Node L) {
        if (L.next == null) return;
        Node p = L.next;
        while (p != null) {
            System.out.print(p.data + " ");
            p = p.next;
        }
        System.out.println();
    }

    //逆置方法1:头插建立新链表
    private Node reverse1(Node L) {
        Node t = new Node(-1);
        Node p = L.next, q;
        while (p != null) {
            q = p.next;
            p.next = t.next;
            t.next = p;
            p = q;
        }
        return t;
    }

    //逆置方法2:原地逆置
    private Node reverse2(Node L) {
        Node p = L.next;
        //空链表和一个元素时候
        if (p == null || p.next == null)
            return L;
        //p,q两个相邻结点的前后关系改变,t保存下一次修改的结点
        Node q = p.next, t = q.next;
        while (q != null) {
            q.next = p;
            p = q;
            q = t;
            if (t != null)
                t = t.next;


        }
        //注意修改逆置的最后一个结点的后继为空,并且头结点指向原来的最后一个结点
        L.next.next = null;
        L.next = p;
        return L;

    }

    //递归逆置,注意这里用的是L.next
    private Node reverse3(Node head) {
        //递归出口
        if (head == null || head.next == null)
            return head;
        //递归子情况
        Node pre = reverse3(head.next);
        head.next.next = head;
        head.next = null;
        return pre;
    }


}
 
 

  • 16
    点赞
  • 55
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值