第十三题：反转链表与排序

最新推荐文章于 2024-08-14 21:59:29 发布

yongwan5637

最新推荐文章于 2024-08-14 21:59:29 发布

阅读量198

点赞数

文章标签：链表查找排序 java代码的鲁棒性递归

本文详细介绍了链表的两种核心操作——反转与合并的方法。针对链表反转，提供了非递归（迭代）与递归两种实现方式，并通过图文解析帮助理解。此外，还探讨了两个递增链表的合并策略，利用递归实现简洁高效。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

输入一个链表，反转链表后，输出链表的所有元素。:

参考答案

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
       if(head==null) return null;//head为当前节点，如果当前节点为空返回null；
        ListNode pre = null;
        ListNode next = null;
        //当前节点是head，pre为当前节点的前一节点，next为当前节点的下一节点
        //需要pre和next的目的是让当前节点从pre->head->next1->next2变成pre<-head next1->next2
        //即pre让节点可以反转所指方向，但反转之后如果不用next节点保存next1节点的话，此单链表就此断开了
        //所以需要用到pre和next两个节点
        //1->2->3->4->5
        //1<-2<-3 4->5
        while(head!=null){
            //做循环，如果当前节点不为空的话，始终执行此循环，此循环的目的就是让当前节点从指向next到指向pre
            //如此就可以做到反转链表的效果
            //先用next保存head的下一个节点的信息，保证单链表不会因为失去head节点的原next节点而就此断裂
            next = head.next;
            //保存完next，就可以让head从指向next变成指向pre了，代码如下
            head.next = pre;
            //head指向pre后，就继续依次反转下一个节点
            //让pre，head，next依次向后移动一个节点，继续下一次的指针反转
            pre = head;
            head = next;
        }
        //如果head为null的时候，pre就为最后一个节点了，但是链表已经反转完毕，pre就是反转后链表的第一个节点
        //直接输出pre就是我们想要得到的反转后的链表
        return pre;
    }
}

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

解题思路

首先判断两个连表是否为空，如果为空其中一个链表为空则直接返回另一个链表；如果都不为空，新建一个链表，通过比较两个链表的值决定插入顺序，整个过程使用递归实现，参考代码如下：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1 ==null && list2 == null) return null;
        else if(list1 == null) return list2;
        else if (list2 == null) return list1;
        ListNode pMergeHead = null;
        if(list1.val < list2.val){
            pMergeHead = list1;
            pMergeHead.next = Merge(list1.next,list2);
        }else{
            pMergeHead = list2;
            pMergeHead.next = Merge(list1,list2.next);
        }
        return pMergeHead;
    }
}

迭代是从前往后依次处理，直到循环到链尾；而递归恰恰相反，首先一直迭代到链尾也就是递归基判断的准则，然后再逐层返回处理到开头。总结来说，链表翻转操作的顺序对于迭代来说是从链头往链尾，而对于递归是从链尾往链头。下面我会用详细的图文来剖析其中实现的细节。 
1、非递归（迭代）方式 
　　迭代的方式是从链头开始处理，如下图给定一个存放5个数的链表。

　　首先对于链表设置两个指针：

　　然后依次将旧链表上每一项添加在新链表的后面，然后新链表的头指针NewH移向新的链表头，如下图所示。此处需要注意，不可以上来立即将上图中P->next直接指向NewH，这样存放2的地址就会被丢弃，后续链表保存的数据也随之无法访问。而是应该设置一个临时指针tmp，先暂时指向P->next指向的地址空间，保存原链表后续数据。然后再让P->next指向NewH，最后P=tmp就可以取回原链表的数据了，所有循环访问也可以继续展开下去。

　　指针继续向后移动，直到P指针指向NULL停止迭代。

　　最后一步：

2、非递归实现的程序

/**
	 * 迭代实现
	 * @param root
	 * @return
	 */
	public static ListNode reverseListNode(ListNode root) {
		if (root == null || root.next == null) {
			return root;
		}
		ListNode p = root;
		ListNode newP = null;
		ListNode temp = p;
		while(p != null) {
			temp = p.next;  //暂存p下一个地址，防止变化指针指向后找不到后续的数
			p.next = newP;//p->next指向前一个空间
			newP = p;//新链表的头移动到p，扩长一步链表
			p = temp;//p指向原始链表p指向的下一个空间
		}
		return newP;
	}

3、递归方式
　　我们再来看看递归实现链表翻转的实现，前面非递归方式是从前面数1开始往后依次处理，而递归方式则恰恰相反，它先循环找到最后面指向的数5，然后从5开始处理依次翻转整个链表。
　　首先指针H迭代到底如下图所示，并且设置一个新的指针作为翻转后的链表的头。由于整个链表翻转之后的头就是最后一个数，所以整个过程NewH指针一直指向存放5的地址空间。

　　然后H指针逐层返回的时候依次做下图的处理，将H指向的地址赋值给H->next->next指针，并且一定要记得让H->next =NULL，也就是断开现在指针的链接，否则新的链表形成了环，下一层H->next->next赋值的时候会覆盖后续的值。
这里写图片描述

　　继续返回操作：

　　上图第一次如果没有将存放4空间的next指针赋值指向NULL，第二次H->next->next=H，就会将存放5的地址空间覆盖为3，这样链表一切都大乱了。接着逐层返回下去，直到对存放1的地址空间处理。
这里写图片描述

　　返回到头：

4、迭代实现的程序

/**
	 * 递归实现
	 * @param root
	 * @return
	 */
	public static ListNode reverseListNode1(ListNode root) {
		if (root == null || root.next == null) {
			return root;
		}
		ListNode newH = reverseListNode1(root.next);//一直循环到链尾 
		root.next.next = root;//翻转链表的指向
		root.next = null;//记得赋值NULL，防止链表错乱
		return newH;//新链表头永远指向的是原链表的链尾
	}
	
  public static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.value + "->");
            head = head.next;
        }
        System.out.println("null");
    }

public static void main(String[] args) {
      ListNode head = new ListNode();
      head.value = 1;

      head.next = new ListNode();
      head.next.value = 2;

      head.next.next = new ListNode();
      head.next.next.value = 3;

      head.next.next.next = new ListNode();
      head.next.next.next.value = 4;

      head.next.next.next.next = new ListNode();
      head.next.next.next.next.value = 5;

      head.next.next.next.next.next = new ListNode();
      head.next.next.next.next.next.value = 6;

      head.next.next.next.next.next.next = new ListNode();
      head.next.next.next.next.next.next.value = 7;

      head.next.next.next.next.next.next.next = new ListNode();
      head.next.next.next.next.next.next.next.value = 8;

      head.next.next.next.next.next.next.next.next = new ListNode();
      head.next.next.next.next.next.next.next.next.value = 9;

      printList(head);
      head = reverseListNode1(head);
      printList(head);
      head = reverseListNode1(head);
      printList(head);

  }