刷题练习
链表求和
给你两个非空的链表,表示两个非负的整数。它们每位数字都是按照逆序的方式存储的,并且每个节点只能存储一位数字。请你将两个数相加,并以相同形式返回一个表示和的链表。
你可以假设除了数字 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;
}
`