单链表的反转

转载自 单链表的反转

单链表的反转是常见的面试题目。本文总结了2种方法。

1 定义

单链表node的数据结构定义如下:

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) {
        val = x;
        next = null;
    }
}

 

2 方法1:就地反转法

2.1 思路

把当前链表的下一个节点pCur插入到头结点dummy的下一个节点中,就地反转。

dummy->1->2->3->4->5的就地反转过程:

dummy->2->1->3->4->5

dummy->3->2->1->4->5

dummy->4>-3->2->1->5

dummy->5->4->3->2->1

2.2 解释

1初始状态

2 过程

pCur是需要反转的节点。

  1. prev连接下一次需要反转的节点
  2. 反转节点pCur
  3. 纠正头结点dummy的指向
  4. pCur指向下一次要反转的节点

伪代码

1 prev.next = pCur.next;
2 pCur.next = dummy.next;
3 dummy.next = pCur;
4 pCur = prev.next;

3 循环条件

pCur is not null

2.3 代码

// 1.就地反转法
    public ListNode reverseList1(ListNode head) {
        if (head == null)
            return head;
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode prev = dummy.next;
        ListNode pCur = prev.next;
        while (pCur != null) {
            prev.next = pCur.next;
            pCur.next = dummy.next;
            dummy.next = pCur;
            pCur = prev.next;
        }
        return dummy.next;
    }

2.4 总结

  • 1个头结点,2个指针,4行代码
  • 注意初始状态和结束状态,体会中间的图解过程。

 

3 方法2:新建链表,头节点插入法

3.1 思路

新建一个头结点,遍历原链表,把每个节点用头结点插入到新建链表中。最后,新建的链表就是反转后的链表。

3.2 解释

1 初始状态

2 过程

pCur是要插入到新链表的节点。

pNex是临时保存的pCur的next。

  1. pNex保存下一次要插入的节点
  2. 把pCur插入到dummy中
  3. 纠正头结点dummy的指向
  4. pCur指向下一次要插入的节点

伪代码

1 pNex = pCur.next
2 pCur.next = dummy.next
3 dummy.next = pCur
4 pCur = pNex

3 循环条件

pCur is not null

3.3 代码

// 2.新建链表,头节点插入法
    public ListNode reverseList2(ListNode head) {
        ListNode dummy = new ListNode(-1);
        ListNode pCur = head;
        while (pCur != null) {
            ListNode pNex = pCur.next;
            pCur.next = dummy.next;
            dummy.next = pCur;
            pCur = pNex;
        }
        return dummy.next;
    }

 

3.4 总结

  • 1个头结点,2个指针(包含一个临时保存节点的pNex),4行代码
  • 注意初始状态和结束状态,体会中间的图解过程。

测试:

import java.util.ArrayList;
import java.util.List;

/**
 * Created by wangchen on 2019/2/15.
 */
public class LinkedList<T> {
    //一个头结点  虚拟的指针
    private Node<T> head = new Node<>(null);
    private int size;

    /**
     * 向末尾增加一个节点
     * @param t
     */
    public void add(T t){
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
        }
        temp.next = new Node(t);
        size++;
    }

    private void add(Node<T> node){
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
        }
        temp.next = node;
    }

    /**
     * 向单链表的尾部追加元素
     * @param list
     */
    public void addList(List<T> list){
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
        }
        for(T t : list){
            temp.next = new Node(t);
            temp = temp.next;
            size++;
        }
    }

    public LinkedList<T> reverseList(){
        LinkedList<T> resultList = new LinkedList<T>();
        Node dummy = head;
        if(head.next == null){
            return resultList;
        }
        Node prev = dummy.next;
        Node pcur = prev.next;
        while(pcur != null){
            prev.next = pcur.next;
            pcur.next = dummy.next;
            dummy.next = pcur;
            pcur = prev.next;
        }
        resultList.add(dummy.next);
        return resultList;
    }


    /**
     * 输出单链表的元素  toString
     */
    public void display(){
        Node temp = head;
        StringBuilder stringBuilder = new StringBuilder("head");
        while(temp.next != null){
            temp = temp.next;
            stringBuilder.append("->").append(temp.data);
        }
        System.out.println(stringBuilder.toString());
    }

    private class Node<T> {
        T data;
        Node<T> next;
        Node (T data){
            this.data = data;
        }

    }

    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        List list = new ArrayList();
        for(int i = 10;i > 0;i--){
            list.add(i);
        }
        linkedList.addList(list);
        linkedList.display();

        linkedList.reverseList().display();
    }
}
head->10->9->8->7->6->5->4->3->2->1
head->1->2->3->4->5->6->7->8->9->10

 

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值