单链表反转的2种方法

 1 public class ReverseDemo {
 2
 3     /**
 4      *  单链表反转的两种方法
 5      */
 6     public static void main(String[] args) {
 7         Node head =new Node("a");
 8         Node node2=new Node("b");
 9         Node node3=new Node("c");
10         head.setNext(node2);
11         node2.setNext(node3);
12         Node p=head;
13         System.out.print("链表反转前");
14         while(p!=null){
15             System.out.print(p.getData());
16             p=p.getNext();
17         }
18          Node q=reverse2(head);
19         System.out.print("链表反转后");
20         while(q!=null){
21             System.out.print(q.getData());
22             q=q.getNext();
23         }
24
25     }
26     public static Node reverse1(Node head){
27         if(head ==null||head.getNext()==null)        //递归,找到尾节点,
28             return head;
29         Node reversehead=reverse1(head.getNext());    //将尾节点设置成新头结点
30         head.getNext().setNext(head);              //改变指向
31         head.setNext(null);
32         return reversehead;
33
34     }
35     public static Node reverse2(Node head){    //遍历
36         if(head==null)
37             return head;
38
39         Node pre=head;
40         Node cur=head.getNext();
41         Node tmp;
42         while(cur!=null){
43             tmp=cur.getNext();              //遍历结点,让该结点的后驱结点指向该结点
44             cur.setNext(pre);
45             pre=cur;
46             cur=tmp;
47
48         }
49         head.setNext(null);              //最早的头结点设置指向null成为尾节点
50         return pre;                     //pre为新的头结点
51
52
53     }
54
55
56 }

链表反转前abc链表反转后cba

时间: 2024-10-11 11:33:18

单链表反转的2种方法的相关文章

剑指offer—单链表反转的三种实现方法

单链表的反转可以用递归.非递归和栈的方法实现 链表节点定义: struct ListNode{ int val; Node* next; ListNode(int x):val(x),next(nullptr){} } 1.栈 ListNode* reverseList(ListNode* head) { if(!head || !head->next) return head; stack<ListNode*>stk; //将链表的结点全部压进栈 while(head){ stk.pu

将单链表排序的两种方法

对单链表排序,通常有两种方法.(PS:考察一个程序员的C语言编程功底,通常看他是否能娴熟的操作链表就知道了.) 方法1:将每一个结点保存到额外的数组中,对数组进行排序,然后根据有序的数组重新构建链表. 方法2:直接对链表进行插入排序,但是实现起来比较复杂一些. 显然,方法1最为简单,因为将链式存储L先转化为顺序存储a[],对顺序存储a[]排序,就避免了较为复杂的链接指针操作.一旦对顺序存储a[]排好序后,根据a[]重新构建一个链表是易如反掌的事情. 1. 单链表的定义如下 typedef str

将单链表翻转的两种方法

将一个单链表翻转的描述很简单,例如: 输入: NODE1->NODE2->NODE3->NODE4->NODE5->NULL 输出: NODE5->NODE4->NODE3->NODE2->NODE1->NULL 那么,定义单链表如下: (为简单起见,将data字段定义为int, 当然实际应用中data很可能是一个复杂的结构体) typedef struct list_s { int data; struct list_s *next; } li

Java实现单链表反转

本文主要介绍单链表反转的两种方法,记录如下: 1. package com.leetcode; public class ListReverse { public static void main(String[] args) { Node node1 = new Node(1); Node node2 = new Node(2); Node node3 = new Node(3); Node node4 = new Node(4); node1.next = node2; node2.next

单链表反转java代码

据说单链表反转问题面试中经常问,而链表这个东西相对于数组的确稍微难想象,因此今天纪录一下单链表反转的代码. 1,先定义一个节点类. 1 public class Node { 2 int index; 3 Node next; 4 5 public Node(int index, Node next) { 6 this.index = index; 7 this.next = next; 8 } 9 } 2,我一共写了三种方法 (1)迭代法.先将下一节点纪录下来,然后让当前节点指向上一节点,再将

单链表反转(2)

今天会介绍另外一种反转单链表的方法,对于单链表反转这一类的算法,最重要的思想就是用临时变量来记住需要记住的节点.一个不够,那就用两个,或者用三个临时变量. 这次还是以图表来表现算法的过程,不同于上一篇,这次的头节点使用链表中的第一个节点. 该方法的思想就是遍历每个节点,将其插入到第一个节点之后. 如下图为链表的初始状态: 为了不断链,先将 P2 的后驱节点指向 P3 的后驱节点. 将P3插入 P1 和 P2 之间,也就是 将 P1 的后驱指向 P3.将 P3 的后驱指向 P2 P3 指向 P2

单链表反转总结篇

单链表反转总结篇 转自https://www.cnblogs.com/byrhuangqiang/p/4311336.html 单链表的反转是常见的面试题目.本文总结了2种方法. 1 定义 单链表node的数据结构定义如下: class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = null; } } 2 方法1:就地反转法 2.1 思路 把当前链表的下一个节点pCur插入到头结点dummy的下一个节点中

图解单链表反转

仅一家之言,望多交流,如有错漏,还请指教! 另,做图不易,转发请注明出处 https://www.cnblogs.com/luego/p/11421590.html 本文有要以图的方式,来呈现链表反转推演的具体过程,以助于理解,保持思路的清晰. 主要采用两种方法实现单链表反转: (1)通过循环,通过三个指针对链表进行遍历,并逐个反转: (2)使用递归的方法进行反转.  1. 循环反转 废话不多说,先上图: 操作过程: ① 初始化pNext至当前节点的下一个节点,为断链做准备② 判断下一个节点是否

单链表反转C语言实现

单链表的反转可以使用循环,也可以使用递归的方式 1.循环反转单链表 循环的方法中,使用pre指向前一个结点,cur指向当前结点,每次把cur->next指向pre即可. 代码: # include <iostream> # include <cstdlib> using namespace std; struct linkNode { int val; linkNode *next; linkNode(int x):val(x),next(NULL){} }; linkNod