C++链表相关算法题_c++链表的编程题目练习

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、从尾到头打印链表&链表反转

题目描述：输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
输入：head = [1,3,2]
输出：[2,3,1]

思路：使用栈的FILO特点实现
代码如下（示例）：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> vectorResult;
        stack<ListNode*> nodes;
        ListNode* pNode=head;//保护作用
        while(pNode!=NULL){
            nodes.push(pNode);
            pNode=pNode->next;
        }
        while(!nodes.empty()){
            pNode=nodes.top();
            vectorResult.push_back(pNode->val);
            nodes.pop();
        }
        return vectorResult;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

剑指 Offer 24. 反转链表
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur=NULL;
        ListNode* pre=head;
        while(pre!=NULL){
            ListNode* t=pre->next;
            pre->next=cur;
            cur=pre;
            pre=t;
        }
        return cur;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

二、倒数第K个节点

题目：
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

涉及的知识点：快慢指针法

优点：可以避免遍历两次
代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        if(head==NULL || k==0){
            return NULL;
        }
        ListNode* pAHead=head;
        ListNode* pBehind=head;
        for(int i=0;i<k-1;i++){
            if(pAHead->next!=NULL){
                pAHead=pAHead->next;
            }else{
                return NULL;
            }
        }
        while(pAHead->next){
            pAHead=pAHead->next;
            pBehind=pBehind->next;
        }
        return pBehind;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

三、合并两个排序的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

涉及到的知识点：链表，递归

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1==NULL){
            return l2;
        }else if (l2==NULL){
            return l1;
        }

        ListNode* mergeList=NULL;
        if (l1->val<l2->val){
            mergeList=l1;
            mergeList->next=mergeTwoLists(l1->next,l2);
        }else{
            mergeList=l2;
            mergeList->next=mergeTwoLists(l1,
            l2->next);
        }
        return mergeList;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

总结

以上是自己目前接触到的链表算法题目，未来会进行更多的扩充。