剑指offer系列刷题第二篇——从尾到头打印链表和反转链表

Posted 2021-11-21 呆呆兽学编程

❤️《剑指offer》系列刷题——第二篇 ❤️
今天给大家介绍两道题目，一道是打印单链表，另一道是反转链表，题目来源与牛客网的《剑指offer》，大家可以点击下方链接去牛客网测试一下自己的代码：
题1：从尾到头打印链表
题2：反转链表

目录

• 题1——打印链表
• • 题目描述
  • 示例一
  • 示例二
  • 接口实现区
  • 解题思路
  • 代码实现
• 题2——反转链表
• • 题目描述
  • 示例1
  • 示例2
  • 接口实现区
  • 解题思路
  • 代码实现

---

题1——打印链表

题目描述

输入一个链表的头节点，按链表从尾到头的顺序返回每个节点的值（用数组返回）。

示例一

输入：{1,2,3}
返回值：[3,2,1]

示例二

输入：{67,0,24,58}
返回值：[58,24,0,67]

接口实现区

在这里插入代码片

*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
	vector<int> printListFromTailToHead(ListNode* head) {

	}
};

解题思路

1. 首先考虑特殊情况，链表为NULL时，我们应该返回一个NULL.
2. 链表不为空时，正常打印，用一个指针遍历一遍链表就可以很轻松地得到答案。
   为了方便大家理解，我给大家来一个动图演示：
   
   遍历的时候，我们选择cur是否为NULL作为判断循环是否结束的条件。用cur = cur->next 让指针走起来，计算出链表的长度，再遍历一遍把数存放到一个数组中，然后再返回这个数组即可。
   这种方法比较暴力，当然我们也可以选择递归来解决这道题，还可以用栈等一下容器来解决。

代码实现

//方法一：
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        if (head==NULL)
            return {};
        int len = 0;
        ListNode* cur = head;
        //计算长度
        while(cur)
        {
            len++;
            cur = cur->next;           
        }
        cur = head;
        vector<int> v;
       
        int i = 0;
        for (i = len-1;i>=0;i--)
        {
            arr[i] = cur->val;
            cur = cur->next;
        }
        return arr;
    }
};
//方法二：
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        if (head==NULL)
            return {};
        vector<int> v;
        ListNode* cur = head;
        while(cur)
        {
            v.insert(v.begin(),cur->val);
            cur = cur->next;
        }
        
        return v;
    }
};

题2——反转链表

题目描述

输入一个长度为n链表，反转链表后，输出新链表的表头。
数据范围： n\\leq1000n≤1000
要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。
如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。
以上转换过程如下图所示：

示例1

输入：{1,2,3}
返回值：{3,2,1}

示例2

输入：{}
返回值：{}
说明：空链表则输出空

接口实现区

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

/**
 * 
 * @param pHead ListNode类 
 * @return ListNode类
 */
struct ListNode* ReverseList(struct ListNode* pHead ) {
    // write code here
}

解题思路

方法一：
翻转所有节点的指向，给大家来一个动图演示大家就清楚了：

这里我们可以定义三个节点指针，一个记住前一个，一个记住下一个，也就是这样：

我们可以让这三个指针迭代地走起来，然后改变n2的指向。最后返回n1的位置。

特殊情况： 链表为空或者只有一个节点我们可以直接返回head。

---

方法二：
采用头插的方法，把第一个节点取下来，然后插到新的链表的头上，我们来看动图演示就比较清晰：

定义三个指针变量来进行头插即可，思路很简单。

代码实现

//方法一
typedef struct ListNode ListNode;
struct ListNode* ReverseList(struct ListNode* pHead ) {
    // write code here
    if (pHead==NULL||pHead->next==NULL)
        return pHead;
    ListNode* n1 = NULL;
    ListNode* n2 = pHead;
    ListNode* n3 = pHead->next;
    while(n2)
    {
        n2->next = n1;
        n1 = n2;
        n2 = n3;
        if (n3)
            n3 = n3->next;
    }
    return n1;
}
//方法二：
typedef struct ListNode ListNode;
struct ListNode* ReverseList(struct ListNode* pHead ) {
    // write code here
    if (pHead==NULL||pHead->next==NULL)
        return pHead;
    ListNode* newHead = NULL;
    ListNode* cur = pHead;
    ListNode* next = pHead->next;
    while(cur)
    {
        cur->next = newHead;
        newHead = cur;
        cur = next;
        if (next)
            next = next->next;
    }
    return newHead;
}