数据结构与算法-链表（练习三）

刷题练习

链表求和

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例 1：
输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：
每个链表中的节点数在范围 [1, 100] 内 0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

题解代码：

#include <QCoreApplication>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct Node
{
    int m_nValue;
    Node* m_pNext;

    Node(int nValue, Node* pNext = nullptr) : m_nValue(nValue), m_pNext(pNext)
    {
        // ...
    }
};

class Solution
{
public:
    // 两个链表相加
    static Node* AddList(Node* pHeadA, Node* pHeadB)
    {
        // 创建一个虚拟头结点
        Node* pDummyHead = new Node(0);
        Node* pTemp = pDummyHead;

        Node* pCurA = pHeadA;
        Node* pCurB = pHeadB;

        // 进位标识符
        bool bCarryBit = false;

        while (nullptr != pCurA || nullptr != pCurB)
        {
            int nSum = 0;

            if (nullptr != pCurA)
            {
                nSum += pCurA->m_nValue;
                pCurA = pCurA->m_pNext;
            }

            if (nullptr != pCurB)
            {
                nSum += pCurB->m_nValue;
                pCurB = pCurB->m_pNext;
            }

            if (bCarryBit)
                ++nSum;

            if (nSum >= 10)
            {
                pTemp->m_pNext = new Node(nSum % 10);
                bCarryBit = true;
            }
            else
            {
                pTemp->m_pNext = new Node(nSum);
                bCarryBit = false;
            }

            pTemp = pTemp->m_pNext;
        }

        if (bCarryBit)
            pTemp->m_pNext = new Node(1);

        Node* pResult = pDummyHead->m_pNext;

        delete  pDummyHead;
        return pResult;
    }

    // 创建链表
    static Node* CreateList(const vector<int>& vecData)
    {
        if (vecData.empty())
            return nullptr;

        Node* pHead = new Node(vecData[0]);
        Node* pCur = pHead;

        for (size_t i = 1; i != vecData.size(); ++i)
        {
            pCur->m_pNext = new Node(vecData[i]);
            pCur = pCur->m_pNext;
        }

        return pHead;
    }

    // 打印链表
    static void PrintList(Node* pHead)
    {
        cout << "List Data : [ ";
        Node* pCur = pHead;

        while(nullptr != pCur)
        {
            cout << pCur->m_nValue;

            if (nullptr == pCur->m_pNext)
            {
                cout << " ]\n";
                return;
            }
            else
            {
                cout << ", ";
            }

            pCur = pCur->m_pNext;
        }

        cout << " ]\n";
    }


    // 测试函数
    static void Test()
    {
        /*
        vector<int> vecA = { 2, 4, 3 };
        vector<int> vecB = { 5, 6, 4 };
        */

        /*
        vector<int> vecA = { 0 };
        vector<int> vecB = { 0 };
        */


        vector<int> vecA = { 9, 9, 9, 9, 9, 9, 9 };
        vector<int> vecB = { 9, 9, 9, 9 };


        Node* pHeadA = CreateList(vecA);
        Node* pHeadB = CreateList(vecB);

        Node* pSum = AddList(pHeadA, pHeadB);
        PrintList(pSum);
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Solution::Test();

    return a.exec();
}

链表求差

题目说明：利用链表的基本运算求A-B。如果链表A中出现的元素在B中也出现，则删除A中的该元素，例如 A(22, 7, 15, 56, 89, 38, 44, 65, 109, 83),B中的元素为(15, 9, 22, 89, 33, 65, 90, 83),则执行A-B后，A中的元素为(7, 56, 38, 44, 109)

解题思路：
首先给两个链表进行好从小到大的排序，然后依次对链表从上到下进行比较，若A链表的值较小，那么说明这个节点的值一定是A独有的，若B的值较小，B链表下降一节，若两个相等，那么两个都下降一节，最后直到一个链表到尾部，若此时A不为空，那么A剩余的节点应该都是A独有的。

解题代码：

//
//  main.cpp
//  ConsoleApp
//
//  Created by Xming on 2022/2/24.
//

#include <iostream>
#include <vector>

using namespace std;

struct Node
{
    int m_nValue;
    Node* m_pNext;
    
    Node(int nValue, Node* pNext = nullptr) : m_nValue(nValue), m_pNext(pNext)
    {
        
    }
};

class Solution
{
public:
    // 链表求差
    static Node* DiffList(Node* pHeadA, Node* pHeadB)
    {
        Node* pDummyHead = new Node(0);
        Node* pTemp = pDummyHead;
        Node* pCurA = pHeadA;
        Node* pCurB = pHeadB;
        
        while (nullptr != pCurA && nullptr != pCurB)
        {
            if (pCurA->m_nValue < pCurB->m_nValue)
            {
                pTemp->m_pNext = new Node(pCurA->m_nValue);
                pCurA = pCurA->m_pNext;
                pTemp = pTemp->m_pNext;
            }
            else if (pCurA->m_nValue > pCurB->m_nValue)
            {
                pCurB = pCurB->m_pNext;
            }
            else
            {
                pCurA = pCurA->m_pNext;
                pCurB = pCurB->m_pNext;
            }
        }
        
        while (nullptr != pCurA)
        {
            pTemp->m_pNext = new Node(pCurA->m_nValue);
            pCurA = pCurA->m_pNext;
            pTemp = pTemp->m_pNext;
        }
        
        Node* pResult = pDummyHead->m_pNext;
        
        delete pDummyHead;
        return pResult;
    }
    
    // 链表排序函数（从小到大排序）
    static Node* SortList(Node* pHead)
    {
        Node* pCur = pHead;
        Node* pTemp = nullptr;
        Node* pMin = nullptr;
        
        while (nullptr != pCur)
        {
            pMin = pCur;
            pTemp = pCur->m_pNext;
            
            while (nullptr != pTemp)
            {
                if (pTemp->m_nValue < pMin->m_nValue)
                    pMin = pTemp;
                
                pTemp = pTemp->m_pNext;
            }
            
            if (pMin != pCur)
                SwapNodeValue(pCur, pMin);
            
            pCur = pCur->m_pNext;
        }
        
        return pHead;
    }
    
    static void SwapNodeValue(Node* pNodeA, Node* pNodeB)
    {
        if (nullptr == pNodeA || nullptr == pNodeB)
            return;
        
        int nTemp = pNodeA->m_nValue;
        pNodeA->m_nValue = pNodeB->m_nValue;
        pNodeB->m_nValue = nTemp;
    }
    
    // 创建链表
    static Node* CreateList(const vector<int>& vecData)
    {
        if (vecData.empty())
            return nullptr;
        
        Node* pHead = new Node(vecData[0]);
        Node* pCur = pHead;
        for(size_t i = 1; i < vecData.size(); ++i)
        {
            pCur->m_pNext = new Node(vecData[i]);
            pCur = pCur->m_pNext;
        }
        
        return pHead;
    }
    
    // 打印输出链表
    static void PrintList(Node* pHead)
    {
        Node* pCur = pHead;
        cout << "List Data:[ ";
        
        while (nullptr != pCur)
        {
            cout << pCur->m_nValue;
            
            if (nullptr == pCur->m_pNext)
            {
                cout << " ]\n";
                return;
                 
            }
            else
            {
                cout << ", ";
            }
            
            pCur = pCur->m_pNext;
        }
        
        cout << " ]\n";
    }
    
    // 测试函数
    static void Test()
    {
        vector<int> vecDataA = { 22, 7, 15, 56, 89, 38, 44, 65, 109, 83 };
        
        vector<int> vecDataB = { 15, 9, 22, 89, 33, 65, 90, 83 };
        
        Node* pHeadA = CreateList(vecDataA);
        Node* pHeadB = CreateList(vecDataB);
        
        pHeadA = SortList(pHeadA);
        pHeadB = SortList(pHeadB);
        
        Node* pResult = DiffList(pHeadA, pHeadB);
        PrintList(pResult);
    }
};

int main(int argc, const char * argv[]) {
    
    Solution::Test();
    
    return 0;
}

`