面试中常见的链表题目

最新推荐文章于 2023-11-18 20:36:11 发布

yongjunhe

最新推荐文章于 2023-11-18 20:36:11 发布

阅读量417

点赞数

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/yongjunhe/article/details/8488091

版权

最近参加面试遇到的一些常见的单链表题目，总结思路和实现代码。

1.单链表的反序

2.给单链表建环

3.检测单链表是否有环

4.给单链表解环

5.检测两条链表是否相交

6.不输入头节点，删除单链表的指定节点（只给定待删除节点指针）

7.合并两个有序链表

1.单链表的反序

 
//逆转链表，并返回逆转后的头节点 
 
node* reverse(node *head) 
 
{ 
 
    if(head == NULL || head->next == NULL) 
 
    { 
 
        returnhead; 
 
    } 
 
    node *cur = head; 
 
    node *pre = NULL; 
 
    node *tmp; 
 
    while(cur->next) 
 
    { 
 
        tmp = pre; 
 
        pre = cur; 
 
        cur = cur->next; 
 
        pre->next = tmp;                  //操作pre的next逆转 
 
    } 
 
    cur->next = pre;                     //结束时，操作cur的next逆转 
 
    returncur; 
 
}

 
//方法二
 
node *reverse(node *head)
 
{
 
    node *p, *q, *r;
 
     
 
    p = head;
 
    q = p->next;
 
     
 
    while(q != NULL)
 
    {
 
        r = q->next;
 
        q->next = p;
 
        p = q;
 
        q = r;
 
    }
 
 
 
    head->next = NULL;
 
    head = p;
 
     
 
    return head;
 
}

2.给单链表建环

 
//给单链表建环，让尾指针，指向第num个节点，若没有，返回false 
 
bool bulid_looplink(node *head, intnum) 
 
{ 
 
    node *cur = head; 
 
    node *tail = NULL; 
 
    inti = 0; 
 
    if(num <= 0 || head == NULL) 
 
    { 
 
        returnfalse; 
 
    } 
 
    for(i = 1; i < num; ++i) 
 
    { 
 
        if(cur == NULL) 
 
        { 
 
            returnfalse; 
 
        } 
 
        cur = cur->next; 
 
    } 
 
    tail = cur; 
 
    while(tail->next) 
 
    { 
 
        tail = tail->next; 
 
    } 
 
    tail->next = cur; 
 
    returntrue; 
 
}

3.检测单链表是否有环

 
//检测单链表是否有环，快慢指针 
 
booldetect_looplink(node *head) 
 
{ 
 
    node *quick_node = head->next, *slow_node = head; 
 
    if(head == NULL || head->next == NULL) 
 
    { 
 
        returnfalse; 
 
    } 
 
    while(quick_node != slow_node) 
 
    { 
 
        if(quick_node == NULL || slow_node == NULL) 
 
            break; 
 
        quick_node = quick_node->next->next; 
 
        slow_node = slow_node->next; 
 
    } 
 
    if(quick_node != NULL && slow_node != NULL)    //非尾节点相遇 
 
        returntrue; 
 
    returnfalse; 
 
}

4.给单链表解环

ps:为了增加节点位图的效率，本应使用hash或则红黑树，这里不造车了，直接用 set容器

 
//找到有环节点，并解环,找到并解环，返回true,无环，返回false 
 
//思路：先找到环节点：被2个节点指向的节点(一定有环的条件）ps:不考虑中间环，因为只有一个next节点，只可能是尾环 
 
boolunloop_link(node *head) 
 
{ 
 
    set<node *> node_bitmap;        //node的地址位图 
 
    unsigned intnum = 0; 
 
    node *cur = head, *pre = NULL; 
 
    while(cur != NULL) 
 
    { 
 
        if(!node_bitmap.count(cur) )              //该节点未被遍历过 
 
        { 
 
            node_bitmap.insert(cur); 
 
            ++num; 
 
        } 
 
        else                              //指向已被遍历过的节点，此时pre节点为尾节点 
 
        { 
 
            pre->next = NULL; 
 
            returntrue; 
 
        } 
 
        pre = cur; 
 
        cur = cur->next; 
 
    } 
 
    returnfalse; 
 
}

5.检测两条链表是否相交

 
//检测两条链表是否相交，是则返回第一个交点，否则返回NULL 
 
//思路：把2个链表各遍历一遍，记下长度length1和length2,若2者的尾节点指针相等，则相交。 
 
//       之后再把长的链表从abs(len1-len2)的位置开始遍历，第一个相等的指针为目标节点 
 
node* detect_intersect_links(node *first_link, node *second_link) 
 
{ 
 
    intlegnth1 = 1, length2 = 1, pos = 0; 
 
    node *cur = NULL, *longer_link = first_link, *shorter_link = second_link; 
 
    if(first_link == NULL || second_link == NULL) 
 
    { 
 
        returnNULL; 
 
    } 
 
    while(first_link->next || second_link->next)     //遍历2个链表 
 
    { 
 
        if(first_link->next) 
 
        { 
 
            first_link = first_link->next; 
 
            ++legnth1; 
 
        }
 
        if(second_link->next)
 
        {
 
            second_link = second_link->next;
 
            ++length2;
 
        }
 
    }
 
    if(first_link != second_link)                 //比较尾节点 
 
    {
 
        return NULL;
 
    }
 
    pos = legnth1 - length2; 
 
    if(legnth1 < length2)                  //保证 longer_link为长链表 
 
    { 
 
        pos = length2 - legnth1; 
 
        cur = longer_link; 
 
        longer_link = shorter_link; 
 
        shorter_link = cur; 
 
    } 
 
    while(pos-- > 0) 
 
        longer_link = longer_link->next; 
 
    while(longer_link || shorter_link) 
 
    { 
 
        if(longer_link == shorter_link)                  //找到第一个交点 
 
        { 
 
            returnlonger_link; 
 
        } 
 
        longer_link = longer_link->next; 
 
        shorter_link = shorter_link->next; 
 
    } 
 
    returnNULL; 
 
}

6.不输入头节点，删除单链表的指定节点（只给定待删除节点指针）

 
//无头节点，随机给出单链表中一个非头节点，删除该节点，当传入空节点，或者尾节点时，返回false 
 
//思路：由于没有头节点，非循环单链表，无法获取目标节点的前节点，所以只能把它的next节点数据前移，并删除next节点 
 
//ps:当传入节点为尾节点，无法用此方法删除 
 
boolwithouthead_delete_node(node *target_node) 
 
{ 
 
    node *cur = NULL; 
 
    if(target_node == NULL || target_node->next == NULL)   //空节点或者尾节点，失败 
 
    { 
 
        returnfalse; 
 
    } 
 
    cur = target_node->next; 
 
    target_node->name = cur->name; 
 
    target_node->next = cur->next; 
 
    deletecur; 
 
    returntrue; 
 
}

7.合并两个有序链表

 
/*
 
递归实现:
 
①算法思想:
 
递归终止条件:若head1为空,返回head2指针(head);若head2为空,返回head1指针(head)
 
递归过程:
 
 
 
1 若head1->data>head2->data;  head 指针应该指向head2所指向的节点,而且head->next应该指向head1和head2->next两个链表的合成序列的头指针;
 
 
 
2 否则head 指针应该指向head1所指向的节点，而且head->next应该指向head->next和head2两个链表的合成序列的头指针;
 
*/
 
#include <iostream>
 
using namespace std;
 
 
 
/*节点的类定义*/
 
class Node
 
{
 
public:
 
    int data;
 
    Node *next;
 
    Node(int data)
 
    {
 
        this->data = data;
 
    }
 
};
 
 
 
/*链表的类定义*/
 
class LinkedList
 
{
 
public:
 
    Node *head;
 
 
 
    /*用一个整形数组作为参数的构造函数*/
 
    LinkedList(int array[])
 
    {
 
        head = new Node(array[0]);
 
        Node *temp = head;
 
        int i;
 
        for( i = 1; i < 3; i++ )
 
        {
 
            temp->next = new Node(array[i]);
 
            temp = temp->next;
 
        }
 
         
 
        temp->next = NULL;
 
    }
 
};
 
 
 
/*递归的合并两个有序链表*/
 
Node * mergeLinkedList(Node *head1, Node *head2)
 
{
 
    Node *p = NULL;
 
     
 
    if(head1 == NULL && head2 == NULL)
 
        return p;
 
    else if(head1 == NULL)
 
        return head2;
 
    else if(head2 == NULL)
 
        return head1;
 
    else
 
    {
 
        if(head1->data < head2->data)
 
        {
 
            p = head1;
 
            p->next = mergeLinkedList(head1->next, head2);
 
        }
 
        else
 
        {
 
            p = head2;
 
            p->next = mergeLinkedList(head1, head2->next);
 
        }
 
         
 
        return p;
 
    }
 
}
 
 
 
/*打印链表的所有元素*/
 
void printList(Node *head)
 
{
 
    Node *temp = head;
 
    while(temp != NULL)
 
    {
 
        cout<<temp->data<<"  ";
 
        temp = temp->next;
 
    }
 
}
 
 
 
int main()
 
{
 
    int array1[3] = {2,5,8};
 
    int array2[3] = {1,6,7};
 
     
 
    /*构造两个有序链表--list1和list2*/
 
    LinkedList list1(array1);
 
    LinkedList list2(array2);
 
 
 
    /*递归的将这两个有序链表合并成一个有序链表*/
 
    Node *new_head = mergeLinkedList(list1.head, list2.head);
 
 
 
    /*打印有序链表*/
 
    printList(new_head);
 
 
 
    return 0;
 
}

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
面试中常见的链表题目

最近参加面试遇到的一些常见的单链表题目，总结思路和实现代码。1.单链表的反序2.给单链表建环3.检测单链表是否有环4.给单链表解环5.检测两条链表是否相交6.不输入头节点，删除单链表的指定节点（只给定待删除节点指针）7.合并两个有序链表1.单链表的反序01//逆转链表，并返回
复制链接

扫一扫

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

打赏作者

yongjunhe 你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20

扫码支付：¥1

获取中

扫码支付

您的余额不足，请更换扫码支付或充值

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。