剑指offer_JZ6 从尾到头打印链表 JZ24 反转链表

最新推荐文章于 2023-03-11 11:55:32 发布

诶你爱我吗

最新推荐文章于 2023-03-11 11:55:32 发布

阅读量470

点赞数

分类专栏： LeetCode 文章标签：链表数据结构

本文链接：https://blog.csdn.net/weixin_44244154/article/details/126248970

版权

LeetCode 专栏收录该内容

60 篇文章 1 订阅

订阅专栏

JZ6 从尾到头打印链表

在这里插入图片描述

解法一使用栈

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        stack<int> s;
        vector<int> result;
        ListNode* node = head;
        while(node != NULL){
            s.push(node->val);
            node = node ->next;
        }
        while(!s.empty()){
            result.push_back(s.top());
            s.pop();
        }
        return result;
    }
};

解法二递归

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    void recursion(ListNode* node,vector<int>& result){
        if(node != NULL){
            recursion(node->next, result);
            result.push_back(node->val);
        }
    }
    vector<int> printListFromTailToHead(ListNode* head) {    
        vector<int> result;
        recursion(head,result);
        return result;
    }
};

JZ24 反转链表

在这里插入图片描述

解法一使用栈，构造新链表

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:

    ListNode* ReverseList(ListNode* pHead) {
        stack<ListNode*> s;

        ListNode* node = pHead;
        while(node != NULL){
            s.push(node);
            node = node ->next;
        }
        if(s.empty()){return NULL;}
        ListNode* ans = s.top();
        s.pop();
        ListNode* head = ans;
        while(!s.empty()){
            head->next = s.top();           
            s.pop();
            head = head ->next;
        }
        head->next = NULL;
        return ans;
    }
};

解法二双指针

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode* ans = NULL;
        while(pHead != NULL){
            ListNode* tmp = pHead->next;
            pHead->next = ans;
            ans = pHead;
            pHead = tmp;
        }
        return ans;
    }
};

解法三递归

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
       if(pHead == NULL|| pHead ->next == NULL){
           return pHead;
       }
        ListNode* ans = ReverseList(pHead->next);
        pHead->next->next = pHead;
        pHead->next = NULL;
        return ans;
    }
};