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

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;

    }
};