单链表的常见面试题１

最新推荐文章于 2024-05-02 17:23:00 发布

原创最新推荐文章于 2024-05-02 17:23:00 发布 · 338 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#单链表 #面试题 #链表 #反转单链表 #遍历

数据结构专栏收录该内容

9 篇文章

订阅专栏

本文探讨了单链表的一些基础操作，包括从尾到头打印链表、不遍历删除非尾节点、在非头节点前插入、实现约瑟夫环、反转链表以及找到链表的中间节点等常见面试题。这些题目要求在有限的条件下高效地处理单链表结构。

☞单链表的基础操作

单链表创建面试题：
1. 从尾到头打印单链表
2. 删除一个无头单链表的非尾节点（不能遍历链表）
3. 在无头单链表的一个非头节点前插入一个节点（不能遍历链表）
4. 单链表实现约瑟夫环(JosephCircle)
5. 逆置/反转单链表
6. 查找单链表的中间节点，要求只能遍历一次链表

void PrintListTail2Head(pNode head)//倒着打印
{
    if(head)
    {
        PrintListTail2Head(head->next);
        printf("%d-->",head->data);
    }
}

void DelNotTailNode(pNode head,pNode pos)//不遍历删除非尾节点
{
    pNode del;
    if(!head || !pos || !pos->next)
        return;
    del = pos->next;
    pos->data = del->data;
    pos->next = del->next;
    free(del);
}

void InsterNotErg(pNode *head,pNode pos,DateType e)//不遍历在结点前插入
{
    pNode nd;
    assert(head);
    if(!pos)
        return;
    nd = BuyNode(pos->data);
    if(nd)
    {
        pos->data = e;
        nd->next = pos->next;
        pos->next = nd;
    }
}

pNode DeathRing(pNode *head,int m)//约瑟夫环
{
    int tmp;
    pNode del,cur;
    assert(head);
    if((*head)->next == NULL)
        return(*head);

    //构环
    cur= *head;
    while(cur->next)
        cur = cur->next;
    cur->next = *head;

    cur = *head;
    while(cur->next != cur)
    {
        //报数
        tmp = m;
        while(--tmp)
        {
            cur = cur->next;
        }
        //删除
        del = cur->next;
        cur->data = del->data;
        cur->next = del->next;
        free(del);
        *head = cur;
    }
    //解环
    cur->next = NULL;
    *head = cur;
    return (*head);
}

pNode FindMidNode(pNode head)//返回中间结点
{
    pNode fast,low;
    assert(head);
    if(!head->next)
        return head;

    fast = head,low = head;
    while(fast && fast->next)
    {
        low = low->next;
        fast = fast->next->next;
    }
    return low;
}

pNode ReverseList(pNode *head)//非递归逆转
{
    pNode first,second,third;
    assert(head);
    if(!(*head)->next)
        return (*head);
    first = *head;
    second = first->next;
    third = second->next;

    first->next = NULL;
    while(third)
    {
        second->next = first;

        first = second;
        second = third;
        third = third->next;
    }
    second->next = first;
    *head = second;
    return (*head);
}

//
/************测试代码***************/
void test5()
{
    pNode list;
    InitList(&list);

    PushBack(&list,1);
    PushBack(&list,2);
    PushBack(&list,3);
    PushBack(&list,4);
    PushBack(&list,5);
    PushBack(&list,6);
    ReverseList(&list);
    PrintList(list);

}

void test4()
{
    pNode list;
    InitList(&list);

    PushBack(&list,1);
    PushBack(&list,2);
    PushBack(&list,3);
    PushBack(&list,4);
    PushBack(&list,5);
    PushBack(&list,6);

    DeathRing(&list,3);
    PrintList(list);


}

void test3()
{
    pNode list;
    pNode pos;
    InitList(&list);

    PushBack(&list,1);//1->NULL
    PushBack(&list,2);//1->2->NULL
    PushBack(&list,3);//1->2->3->NULL
    PushFront(&list,0);//0->1->2->3->NULL

    pos = Find(list,2);
    DelNotTailNode(list,pos);//0->1->3->NULL
    PrintList(list);

    pos = Find(list,3);
    InsterNotErg(&list,pos,2);//0->1->2->3->NULL
    PrintList(list);
}

void test2()
{
    pNode list;
    InitList(&list);

    PushBack(&list,1);//1->NULL
    PushBack(&list,2);//1->2->NULL
    PushBack(&list,3);//1->2->3->NULL
    PushFront(&list,0);//0->1->2->3->NULL

    PrintListTail2Head(list);

}

int main()
{
    test5();
    return 0;
}