p9 翻转单链表(leetcode206)

一:解题思路

链表是递归定义的,所以关于链表的大部分问题也可以用递归来解决。当然也可以不用递归来解决这个问题。这里来介绍2种方法,一种是递归方法,一种是非递归的方法。

二:完整代码示例 (C++版和Java版)

递归版C++

class Solution
{
public:
    ListNode* reverseList(ListNode* head)
    {
        ListNode* ret = NULL;

        if (head == NULL)
        {
            ret = NULL;
        }
        else if (head->next == NULL)
        {
            ret = head;
        }
        else
        {
            ListNode* guard = head->next;
            ret = reverseList(head->next);
            guard->next = head;
            head->next = NULL;
        }

        return ret;
    }
};

递归版Java

class Solution
{
    public ListNode reverseList(ListNode head)
    {
          ListNode ret=null;

          if(head==null)
          {
              ret=null;
          }
          else if(head.next==null)
          {
              ret=head;
          }
          else
          {
              ListNode guard=head.next;
              ret=reverseList(head.next);
              guard.next=head;
              head.next=null;
          }

          return ret;
    }
}

迭代法C++:

class Solution
{
public:
    ListNode* reverseList(ListNode* head)
    {
        ListNode* cur = head;
        ListNode* pre = NULL;

        while (cur != NULL)
        {
            ListNode*  next = cur->next;
            cur->next = pre;

            pre = cur;
            cur = next;
        }

        return pre;
    }
};

迭代法Java:

class Solution
{
    public ListNode reverseList(ListNode head)
    {
          ListNode cur=head;
          ListNode pre=null;

          while(cur!=null)
          {
              ListNode next=cur.next;
              cur.next=pre;

              pre=cur;
              cur=next;
          }

          return pre;
    }
}

原文地址:https://www.cnblogs.com/repinkply/p/12445049.html

时间: 2024-11-07 11:32:04

p9 翻转单链表(leetcode206)的相关文章

让我们来写个算法吧,(1)翻转单链表

作为面试中最最最常考的链表题之一,翻转单链表.有以下两种解法: 例: 输入 1->2->3->4  输出 4->3->2->1 Node类定义如下 class Node { int value; Node next; public Node(int value, Node next) { this.value = value; this.next = next; } 1.遍历法 此方法根据链表遍历,通过拆分,刷新节点来达到翻转单链表的功能. 草稿过程 第一次遍历 主链表

Java基础之翻转单链表

/** * @author luochengcheng * 定义一个单链表 */ class Node { //变量 private int record; //指向下一个对象 private Node nextNode; public Node(int record) { super(); this.record = record; } public int getRecord() { return record; } public void setRecord(int record) { t

单链表(C++实现)

单链表的结构有多种 这里介绍的链表有头结点.有尾节点并且尾节点指向头结点 单链表的每个结点的地址存放在其直接前驱结点的指针域中.其中第一个结点没有前驱结点,因此需要一个头指针指向第一个节点,便于我们对整个链表进行操作:这里的单链表的最后一个节点的指针域存放的是头结点的地址. 单链表不能随意存取,必要的时候我们可以通过已知结点的指针域不断遍历从而获取我们要的结点. SList.h /**********************************************************

单链表的建立,插入,显示,查找删除以及反转

#include "stdafx.h" #include <iostream> #include <string> #include <stack> //二叉树遍历时使用栈 #include <queue> //二叉树层次遍历时使用 using namespace std; //单链表操作 class Node { public: Node *next; Node *front; //双向链表时指向前驱节点的指针 int data; };

玩转单链表

玩指针是许多算法的精髓,就是要像六脉神剑一样,指针乱指一通之后,内存中的数据变得井然有序. 操作指针真的是太好玩了.下面出几道题. 一.不用额外空间翻转单链表 给定一个单链表,要求翻转之. import random """ O(1)空间复杂度翻转链表 方法:one->two->three 三元组构成一个窗口,每次都翻转窗口内的元素,然后将 窗口从左往右滑动 """ list_length = 4 class Node: def __

20140428 宏定义 单链表翻转 野指针

1.宏定义swap,加括号有什么意义 #define swap(x,y) x = (x)+(y):y=(x)-(y):x=(x)-(y) 加括号是为了处理表达式参数(即宏的参数可能是个算法表达式)时不出错,因为宏替换就是文本替换,所以如果有以下情况: #define COM(A,B) (A)*(B) 那么COM(6+5,3),它会换成这样: (6+5)*(3) 但是如是去掉了定义中括号,即写成这样: #define COM(A,B) A*B 那么COM(6+5,3),它就会换成这样:6+5*3

将单链表翻转的两种方法

将一个单链表翻转的描述很简单,例如: 输入: 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实现单链表翻转

单链表翻转比如有如下链表: 需要按照C B A 输出,我们可以有好几种方法: package org.andy.test; import java.util.ArrayList; import java.util.List; /** * @author andy * @version:2015-2-4 上午9:41:12 * * */ public class LinkedReverse { /** * @param args */ public static void main(String[

(单链表)单链表的整体逆序和局部逆序

题目一:将单链表翻转. 思路:有三种方式. 一:用数组存储单链表的值,然后重新逆序赋值,效率较低. 二:利用三个指针,在原来的基础上进行逆序.这种方法比较实用,效率也高. 三:从第2个节点到第N个节点,依次逐节点插入到第1个节点(head节点)之后,最后将第一个节点挪到新表的表尾.需要新建一个链表,这种方法和第二种差不多. 这里我就写出第二种方法,比较实用. 代码(方法二): struct ListNode { int val; ListNode *next; ListNode(int x) :