当前位置:网站首页 > 区块链基础 > 正文

单向链表反转代码(单向链表反序)



要求很简单,输入一个链表,反转链表后,输出新链表的表头。反转链表是有2种方法(递归法,遍历法)实现的,面试官最爱考察的算法无非是斐波那契数列和单链表反转,递归方法实现链表反转比较优雅,但是对于不了解递归的同学来说还是有理解难度的。

总体来说,递归法是从最后一个Node开始,在弹栈的过程中将指针顺序置换的。递归法实现图

为了方便理解,我们以 1->2->3->4这个链表来做演示。输出的效果是4->3->2->1

首先定义Node:

 
 
   
   
  1. package cn.liuhaihua;
  2. public class Node<T> {
  3. Node next;
  4. T object;

  5. /
  6. * 构造函数
  7. * @param next
  8. * @param object
  9. */
  10. public Node(Node next,T object){
  11. this.next=next;
  12. this.object=object;
  13. }
  14. }

反转方法如下:

 
 
   
   
  1. /
  2. * 递归反转
  3. * @param node
  4. * @return
  5. */
  6. public static Node reverse(Node node){
  7. Node newnode =null;
  8. if(null==node||null==node.next)
  9. {
  10. return node;
  11. }else{
  12. Node temp = node.next;
  13. newnode = reverse(node.next);
  14. temp.next = node;
  15. node.next=null;
  16. }
  17. print(newnode);
  18. return newnode;
  19. }

递归实质上就是系统帮你压栈的过程,系统在压栈的时候会保留现场。

我们来看是怎样的一个递归过程:1->2->3->4

程序到达Node newnode = reverse(node.next);时进入递归 我们假设此时递归到了3结点,此时node=3结点,temp=3结点.next(实际上是4结点) 执行Node newnode = reverse(node.next);传入的node.next是4结点,返回的newnode是4结点。接下来就是弹栈过程了 程序继续执行 temp.next = node就相当于4->3 node.next = null 即把3结点指向4结点的指针断掉。返回新链表的头结点newnode

注意:当return后,系统会恢复2结点压栈时的现场,此时的node=2结点;temp=2结点.next(3结点),再进行上述的操作。最后完成整个链表的翻转。

遍历法就是在链表遍历的过程中将指针顺序置换

 
 
   
   
  1. public static Node reverseList(Node node) {
  2. Node pre = null;
  3. Node next = null;
  4. while (node != null) {
  5. next = node.next;
  6. node.next = pre;
  7. pre = node;
  8. node = next;
  9. }
  10. return pre;
  11. }

依旧是1->2->3->4 准备两个空结点 pre用来保存先前结点、next用来做临时变量 在头结点node遍历的时候此时为1结点 next = 1结点.next(2结点) 1结点.next=pre(null) pre = 1结点 node = 2结点 进行下一次循环node=2结点 next = 2结点.next(3结点) 2结点.next=pre(1结点)=>即完成2->1 pre = 2结点 node = 3结点 进行循环...

 
 
   
   
  1. package cn.liuhaihua;

  2. /
  3. *单链表反序
  4. */
  5. public class NodeReverse {
  6. public static void main(String args[]){
  7. Node<String> node_d = new Node<String>(null,"D");
  8. Node<String> node_c = new Node<String>(node_d,"C");
  9. Node<String> node_b = new Node<String>(node_c,"B");
  10. Node<String> node_a = new Node<String>(node_b,"A");
  11. System.out.println("反转前:");
  12. print(node_a);
  13. System.out.println("反转ing:");
  14. //Node reversenode =reverse(node_a);
  15. Node reversenode = reverseList(node_a);
  16. System.out.println("反转后:");
  17. print(reversenode);



  18. }

  19. /
  20. * 递归反转
  21. * @param node
  22. * @return
  23. */
  24. public static Node reverse(Node node){
  25. Node newnode =null;
  26. if(null==node||null==node.next)
  27. {
  28. return node;
  29. }else{
  30. Node temp = node.next;
  31. newnode = reverse(node.next);
  32. temp.next = node;
  33. node.next=null;
  34. }
  35. print(newnode);
  36. return newnode;
  37. }

  38. /
  39. * 遍历反转
  40. * @param node
  41. * @return
  42. */
  43. public static Node reverseList(Node node) {
  44. Node pre = null;
  45. Node next = null;
  46. while (node != null) {
  47. next = node.next;
  48. node.next = pre;
  49. pre = node;
  50. node = next;
  51. print(pre);
  52. }
  53. return pre;
  54. }
  55. /
  56. * 遍历节点数据
  57. * @param node
  58. */
  59. public static void print(Node node){
  60. System.out.print("node遍历:"+node.object.toString());
  61. while(node.next!=null){
  62. node = node.next;
  63. System.out.print("-->"+node.object.toString());
  64. }
  65. System.out.println("\n");
  66. }
  67. }

目前+人已关注加入我们

到此这篇单向链表反转代码(单向链表反序)的文章就介绍到这了,更多相关内容请继续浏览下面的相关推荐文章,希望大家都能在编程的领域有一番成就!

版权声明


相关文章:

  • 单链表的存储密度高于双链表(单链表和双链表的存储密度)2026-03-03 09:09:09
  • 跳转链接怎么弄excel(excel如何添加跳转链接)2026-03-03 09:09:09
  • 腾讯文档怎么跳转链接(腾讯文档里的链接不能直接打开)2026-03-03 09:09:09
  • cp1200链接电脑(cp1200连不上wifi)2026-03-03 09:09:09
  • 怎么点击图片跳转链接(怎么制作图片链接跳转)2026-03-03 09:09:09
  • 单向链表逆序输出(单链表的逆序输出)2026-03-03 09:09:09
  • 双向链表与单向链表区别(双向链表比单向链表的优点)2026-03-03 09:09:09
  • 链接跳转工具(网站链接跳转)2026-03-03 09:09:09
  • 公众号跳转链接怎么弄(公众号如何设置跳转链接)2026-03-03 09:09:09
  • 跳转链接怎么制作(跳转链接代码怎么写)2026-03-03 09:09:09
  • 全屏图片