【程序员面试宝典】链表相关面试题

1、链表中的第k个节点

题目描述：

输入一个链表，输出该链表中倒数第k个结点

struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};
ListNode* FindKthToTail(ListNode* pListHead, unsigned int k)
{
if (NULL == pListHead || k <= 0)
return NULL;
ListNode* first = pListHead;
listNode* second = pListHead;
for (int i = 0; i < k - 1; i++)
{
if (NULL != first->next)
{
first = first->next;
}
else
{
return NULL;
}
}
while (NULL != first->next)
{
first = first->next;
second = second->next;
}
return second;
}

2、访问单个节点的删除

题目描述：

实现一个算法，删除单向链表中间的某个结点，假定你只能访问该结点。

给定带删除的节点，请执行删除操作，若该节点为尾节点，返回false，否则返回true

struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};

bool removeNode(ListNode* pNode) {
if (NULL == pNode || NULL == pNode->next)
return false;
ListNode* pNext = pNode->next;
pNode->val = pNext->val;
pNode->next = pNext->next;
free(pNext);
pNext = NULL;
return true;
}

3、链表分割

题目描述：

编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前

给定一个链表的头指针 ListNode* pHead，请返回重新排列后的链表的头指针。

注意：分割以后保持原来的数据顺序不变。

struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};

class Partition {
public:
ListNode* partition(ListNode* pHead, int x) {
if (NULL== pHead || NULL == pHead->next)
return pHead;
ListNode* SmallStart = new ListNode(0);
ListNode* SmallEnd = SmallStart;
ListNode* BigStart = new ListNode(0);
ListNode* BigEnd = BigStart;
while (pHead)
{
if (pHead->val < x)
{
SmallEnd->next = pHead;
SmallEnd = SmallEnd->next;
}
else
{
BigEnd->next = pHead;
BigEnd = BigEnd->next;
}
pHead = pHead->next;
}
SmallEnd->next = BigStart->next;
BigEnd->next = NULL;
delete BigStart;
BigEnd = NULL;
ListNode* result = SmallStart->next;
delete SmallStart;
SmallStart = NULL;
return result;
}
};

4、链式A+B

题目描述：

有两个用链表表示的整数，每个结点包含一个数位。这些数位是反向存放的，也就是个位排在链表的首部。编写函数对这两个整数求和，并用链表形式返回结果。

给定两个链表ListNode* A，ListNode* B，请返回A + B的结果(ListNode*)。

测试样例：

{ 1, 2, 3 }, { 3, 2, 1 }

返回：{ 4, 4, 4 }

struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
class Plus {
public:
ListNode* plusAB(ListNode* a, ListNode* b) {
int c = 0;          //用于表示进位
int sum = 0;
ListNode* result = new ListNode(0);
ListNode* cur = result;
while (NULL != a || NULL != b || c != 0)
{
int _a = (a == NULL) ? 0 : a->val;
int _b = (b == NULL) ? 0 : b->val;
sum = _a + _b + c;
c = sum / 10;
ListNode* pNode = new ListNode(sum % 10);
cur->next = pNode;
cur = pNode;
a = (a == NULL) ? 0 : a->next;
b = (b == NULL) ? 0 : b->next;
}

return result->next;
}
};

5、回文链表

题目描述：

请编写一个函数，检查链表是否为回文。

给定一个链表ListNode* pHead，请返回一个bool，代表链表是否为回文。

测试样例：

{ 1, 2, 3, 2, 1 }

返回：true

{ 1, 2, 3, 2, 3 }

返回：false

struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
class Palindrome {
public:
bool isPalindrome(ListNode* pHead) {
// write code here
string s;
if (!pHead || !(pHead->next))
return true;
while (pHead){
//s+=to_string(pHead->val);
s.push_back(pHead->val);
pHead = pHead->next;
}
string s2 = s;
reverse(s2.begin(), s2.end());
if (s == s2)
return true;
else
return false;

}
};