链表笔试面试题（二）

本博客内容：
一、以链表的每2个为单位，对调二者的位置，如果原链表是1-2-3-4-null，对调之后就是2-1-4-3-null
二、判断链表的总结点是偶数还是奇数？
三、将循环链表分成二等分，如果节点总数为奇数，就定第一个小的循环链表，比第2个多一个节点
四、寻找与模除（modular）有关的节点。编写函数，以便根据整数常量k，在包含n个元素的单链表中，寻找序号最大，且给序号又能为k所整除的那个节点。
如果n=19，k=3，那么就返回第18个节点
五、单链表有环，求进入环的第一个节点
六、给出一个链表头指针，O(1)时间内删除节点
七、删除链表中的重复节点，返回新链表的节点

一、以链表的每2个为单位，对调二者的位置，如果原链表是1-2-3-4-null，对调之后就是2-1-4-3-null

//递归版本
ListNode* ReversePair(ListNode * head)
{
ListNode * temp;
if(head==NULL|| head->next=NULL)
    return;
else
{
temp=head->next;
head->next=temp->next;
temp->next=head;
head=temp;
head->next->next=ReversePair(head->next->next);
return head;
}

二、判断链表的总结点是偶数还是奇数？

int IsLinkedListLengthEven(ListNode * head)
{
while(head&&head->next)
    head=head->next;
if(!head)
    return 0; 
return 1; //每次移动2个，如果指向链表的最后一个节点，就是奇数

三、将循环链表分成二等分，如果节点总数为奇数，就定第一个小的循环链表，比第2个多一个节点

void SplitList（ListNode * head，ListNode **head1,ListNode**head2）
{
    ListNode * slowNode=head;
    ListNode * fastNode=head;
    if(head==NULL)
        return ;
        while(fastNode->next!=head &&fastNode->next->next!=head)
            {
            fastNode=fastNode->next->next;
            slowNode=slowNode->next;
            }
        if(fastNode->next->next=NULL)
            fastNode=fastNode->next;
        *head1=head;
        if(head->next!=head)
            *head2=slowNode->next;
        fastNode->next=slowNode->next;
        slowNode->next=head;
}

四、寻找与模除（modular）有关的节点。编写函数，以便根据整数常量k，在包含n个元素的单链表中，寻找序号最大，且给序号又能为k所整除的那个节点。
如果n=19，k=3，那么就返回第18个节点

ListNode * modularNode(ListNode *head,int k)
{
int i=1;
if(k<=0)
return NULL;
while(head)
{
if(i%k==0)
    modularNode=head;
i++;
}
return modularNode;
}

五、单链表有环，求进入环的第一个节点

ListNode * GetFirstNodeInCircle(ListNode * pHead)
{
    if(pHead==NULL)
        return NULL;
    ListNode *fast=pHead;
    ListNode *last=pHead;
    while(fast &&fast->m_pNext)
    {
        fast=fast->m_pNext->m_pNext;
        last=last->m_pNext;
        if(fast==NULL)
            return NULL;  //链表不成环
        if(fast==last)
        {
            ListNode * last2=pHead;
            while(last2!=fast)
            {
                last2=last2->m_pNext;
                fast=fast->m_pNext;
            }
        }
    return   NULL;
}

六、给出一个链表头指针，O(1)时间内删除节点

void DeleteListNode(ListNode * pHead,ListNode * pToBeDelted)
{
    if(pToBeDeleted==NULL) return ;
    if(pToBeDeleted->m_pNext!=NULL)
    {   //将删除节点的下一个节点值copy到待删除结点
        pToBeDeleted->m_nValue=pToBeDeted->m_pNext->m_pValue;
        ListNode * temp=pToBeDeleted->m_pNext;
        pToBeDeleted->m_pNext=pToBeDeleted->m_pNext->m_pNext;
        delete temp;
    }
    else
    {
    if(pToBeDeleted==pHead)
        delete pHead;
    if(pToBeDeleted->m_pNext==NULL)
        {
        ListNode * pNode=pHead;  //使用普通方法删除
        while(pNode->m_pNext!=pToBeDeleted)
            pNode=pNode->m_pNext;
        pNode->m_pNext=NULL;
        delete pToBeDeleted;
        }
    }
}

七、删除链表中的重复节点，返回新链表的节点

ListNode * deleteDuplication(ListNode * pHead)
{
    if(pHead==NULL) return NULL;
    if(pHead&&!pHead->m_pNext) return pHead;
    ListNode * current;
    if(pHead->m_nValue==pHead->m_pNext->m_nValue)
        {        //如果第一个值和第二值相同
            current=pHead->m_pNext;
            wihle(current&&current->m_nValue==pHead->m_nValue)
                current=current->m_pNext;
            return deleteDuplication(current);
        }
    else
    {
        current=pHead->m_pNext;  //第一个和第二值不同
        pHead->m_pNext=deleteDuplication(current);
    }
    return pHead;