面试考题之9.2:链表(C/C++版)

最新推荐文章于 2023-11-11 16:09:25 发布
最新推荐文章于 2023-11-11 16:09:25 发布
阅读量3.4k 收藏 3
点赞数
分类专栏： C++之悟 数据结构(C语言版)记录 文章标签： 面试 递归 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JohnnyHu90/article/details/46401605
版权

2.1 编写代码，移除未排序链表中的重复结点。进阶：如果不得使用临时缓冲区，该怎么解决？

解决方案：

方案1： 使用散列表

暂略

方案2：不借助额外缓冲区

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include <iostream>
#include <cstring>
#include <cstdio>    // getchar()
 #include <cstdlib>   // free()
#include  "LinkedList.h"

using  namespace std;

void printData(LinkedList aList)
{
    cout << aList->data <<  "  ";
     return;
}


/************************************************************************/
// 函数名称：deleteDups
// 函数目的：移除链表中重复的节点
// 函数参数：myList: 待操作的链表
// 函数返回：无
// 使用条件：
/************************************************************************/
void deleteDups(LinkedList theList)
{
     if (theList ==  NULL)  return;

    LinkedList current = theList;
     while(current !=  NULL){
         // 移除后续值相同的所有结点
        LinkedList runner = current;
         while (runner->next !=  NULL){
             if (runner->next->data == current->data){
                LinkedList nextNode = runner->next;
                runner->next = runner->next->next;
                freeNode(nextNode);
            }
             else
                runner = runner->next;
        }
        current = current->next;
    }

     return;
}

int main()
{
     int arr[] = {  12,  13,  2,  4,  12,  6,  6,  8,  10,  4,  4,  2 };

     for (size_t i =  0; i <  sizeof(arr) /  sizeof( int); i++){
         //insert( makeNode(arr[i]) );
        insertBack( makeNode(arr[i]) );
    }

    traverse(printData);
    cout << endl;

    LinkedList theList = getHead();
    deleteDups(theList);
    cout <<  "调用deleteDups()函数后：" << endl;

    traverse(printData);
    cout << endl;

    destroy();  // 释放链表
    getchar();
     return  0;
}

运行结果：


思考体会：

1、散列表怎样解决该问题？


2.2 实现一个算法，找出单向链表中倒数第K个结点。

解决方案：

方案1：递归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <iostream>
#include <cstring>
#include <cstdio>    // getchar()
#include  "LinkedList.h"

using  namespace std;

void printData(LinkedList aList)
{
    cout << aList->data <<  "  ";
     return;
}

/************************************************************************/
// 函数名称：nthToLast
// 函数目的：求倒数第K个结点
// 函数参数：aList: 待操作的链表， k:第K个结点、i:计数器
// 函数返回：无
// 使用条件：
/************************************************************************/
LinkedList nthToLast(LinkedList aList, size_t k, size_t& i)
{
     if ( NULL == aList) {
         return  NULL;
    }

    LinkedList theList = nthToLast(aList->next, k, i);
    i +=  1;
     if (i == k){
         return aList;
    }

     return theList;
}


int main()
{
     int arr[] = {  12,  13,  2,  4,  12,  6,  6,  8,  10,  4,  4,  2 };

     for (size_t i =  0; i <  sizeof(arr) /  sizeof( int); i++){
        insertBack( makeNode(arr[i]) );
    }

    traverse(printData);
    cout << endl;

    LinkedList theList = getHead();
    size_t k1 =  1, k2 =  4, i1 =  0, i2 =  0;
    LinkedList alist1 = nthToLast(theList, k1, i1);
    LinkedList alist2 = nthToLast(theList, k2, i2);

    cout <<  "K1 = " << alist1->data << endl;
    cout <<  "K2 = " << alist2->data << endl;
    destroy(); // 释放链表
    getchar();
     return  0;
}

其他方案：

运行结果：


思考体会：

1、链表与递归的关系总是那么若影若离，本题主要考查递归在链表中的使用。
2、其他高效方案？


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

示例

输入：单向链表a->b->c->d->e中的结点c.

输出：不返回任何数据，但该链表变为：a->b->d->e.

解决方案：

解法：将后继结点的数据复制到当前结点，然后删除这个后继结点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>
#include <cstring>
#include <cstdio>    // getchar()
#include  "LinkedList.h"

using  namespace std;

void printData(LinkedList aList)
{
    cout << aList->data <<  "  ";
     return;
}

/************************************************************************/
// 函数名称：deletNode2
// 函数目的：删除单链表中的某个结点
// 函数参数：pNode:链表结点
// 函数返回：true:删除成功
// 使用条件：pNode为非尾结点
/************************************************************************/
bool deletNode2(LinkedList pNode)
{
     if (pNode ==  NULL || pNode->next ==  NULL)
         return  false;

    LinkedList nextNode = pNode->next;
    pNode->data = nextNode->data;
    pNode->next = nextNode->next;
    freeNode(nextNode);

     return  true;
}

int main()
{
     int arr[] = {  12,  13,  2,  4,  12,  6,  6,  8,  10,  4,  4,  2 };

     for (size_t i =  0; i <  sizeof(arr) /  sizeof( int); i++){
        insertBack( makeNode(arr[i]) );
    }

    traverse(printData);
    cout << endl;

    LinkedList theList = getHead();

    LinkedList pNode = search( 8);
    deletNode2(pNode);

    traverse(printData);

    destroy();  // 释放链表
    getchar();
     return  0;
}

运行结果：


思考体会：

1、只要考查特殊情况。

2、在C++中删除后继结点时要手动删除。


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

解决方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
#include <iostream>
#include <cstring>
#include <cstdio>    // getchar()
#include  "LinkedList.h"

using  namespace std;

void printData(LinkedList aNode)
{
    cout << aNode->data <<  "  ";
     return;
}

/************************************************************************/
// 函数名称：partition
// 函数目的：以定值X分割pList
// 函数参数：pList:待操作链表首结点
// 函数返回：
// 使用条件：
/************************************************************************/
LinkedList partition(LinkedList pList,  int x)
{
    LinkedList beforeStart  =  NULL;
    LinkedList beforeEnd    =  NULL;
    LinkedList afterStart   =  NULL;
    LinkedList afterEnd     =  NULL;

     if (pList ==  NULL)  return  NULL;

     // 分割链表
    LinkedList current = pList;   // 指向第一个元素
     while (current !=  NULL){
         // current结点要插入before或after表
        LinkedList nextNode = current->next;
        current->next =  NULL;

         if (current->data < x){
             // 将结点插入before链表
             if (beforeStart ==  NULL){
                beforeStart = current;
                beforeEnd   = beforeStart;
            } else {
                beforeEnd->next = current;
                beforeEnd   = current;
            }
        } else {
             // 将结点插入before链表
             if (afterStart ==  NULL){
                afterStart  = current;
                afterEnd    = afterStart;
            } else {
                afterEnd->next = current;
                afterEnd = current;
            }
        }

        current = nextNode;
    }  // end while()
     if (beforeStart ==  NULL) {
         return afterStart;
    }

     // 合并before和after链表
    beforeEnd->next = afterStart;
     return beforeStart;
}

int main()
{
     int arr[] = {  12,  13,  2,  4,  12,  6,  6,  8,  10,  4,  4,  2 };

     for (size_t i =  0; i <  sizeof(arr) /  sizeof( int); i++){
        insertBack( makeNode(arr[i]) );
    }

    traverse(printData);
    cout << endl;

    LinkedList theList = getHead();
    theList = partition(theList,  8);

    sethead(theList);

    traverse(printData);
    cout << endl;

    destroy();  // 释放链表
    getchar();
     return  0;
}


运行结果：


思考体会：

1、没有重新分配内存存放新的链表，靠移动指针来完成题设要求。

2、注意处理时一些细节。


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

示例：

输入：(7->1->6) + (5->9->2), 即：617 + 295.

输出：2->1->9,即：912.

进阶：假设这些数位是正向存放的，请在做一遍。

示例：(6->1->7) + (2->9->5), 即：617 + 295.

输出：9->1->2, 即：912。

解决方案：

方案1：数位反向存放

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#include <iostream>
#include <cstring>
#include <cstdio>    // getchar()
#include  "LinkedList.h"

using  namespace std;

void printData(LinkedList aNode)
{
    cout << aNode->data <<  "  ";
     return;
}

/************************************************************************/
// 函数名称：addLists
// 函数目的：两个链表相加
// 函数参数：list1、ist2
// 函数返回：相加之后的链表
// 使用条件: 数位反向存放
/************************************************************************/
LinkedList addLists(LinkedList list1, LinkedList list2)
{
    LinkedList lt1 = list1, lt2 = list2, newList =  NULL;

     int addData =  0;     // 相加和
     int carryI  =  0;     // 进位值
     while ( lt1 !=  NULL || lt2 !=  NULL ){

         if (lt1 !=  NULL && lt2 !=  NULL){
            addData = lt1->data + lt2->data;
            lt1 = lt1->next;
            lt2 = lt2->next;
        } else  if (lt1 ==  NULL && lt2 !=  NULL){
            addData = lt2->data;
            lt2 = lt2->next;
        } else {
            addData = lt1->data;
            lt1 = lt1->next;
        }

         int totalData = addData + carryI;
        newList = insertBack( newList, makeNode(totalData %  10) );
         //newList = insert( newList, makeNode(totalData % 10) );
        carryI = totalData /  10;
    }

     if (carryI >  0){
        newList = insertBack( newList, makeNode(carryI) );
         //newList = insert( newList, makeNode(carryI) );
    }

     return newList;
}


int main()
{
     int arr1[] = { 6,  1,  7};
     int arr2[] = { 2,  9,  5};

    LinkedList list1 =  NULL, list2 =  NULL, newList =  NULL;

     for (size_t i =  0; i <  sizeof(arr1) /  sizeof( int); i++){
         //list1 = insertBack( list1, makeNode(arr1[i]) );
        list1 = insert( list1, makeNode(arr1[i]) );
    }

     for (size_t i =  0; i <  sizeof(arr2) /  sizeof( int); i++){
         //list2 = insertBack( list2, makeNode(arr2[i]) );
        list2 = insert( list2, makeNode(arr2[i]) );
    }

    newList = addLists(list1, list2);

    cout <<  "list1 = ";   traverse(list1, printData);    cout << endl;
    cout <<  "list2 = ";   traverse(list2, printData);    cout << endl;
    cout <<  "newList = "; traverse(newList, printData);  cout << endl;

    getchar();
     return  0;
}

运行结果：


方案2：数位正向存放

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <iostream>
#include <cstring>
#include <cstdio>    // getchar()
#include  "LinkedList.h"

using  namespace std;

void printData(LinkedList aNode)
{
    cout << aNode->data <<  "  ";
     return;
}

/************************************************************************/
// 函数名称：addLists
// 函数目的：两个链表相加
// 函数参数：list1、ist2
// 函数返回：相加之后的链表
// 使用条件: 数位反向存放
/************************************************************************/
LinkedList addLists(LinkedList list1, LinkedList list2)
{
    LinkedList lt1 = list1, lt2 = list2, newList =  NULL;

     int addData =  0;     // 相加和
     int carryI  =  0;     // 进位值
     while ( lt1 !=  NULL || lt2 !=  NULL ){

         if (lt1 !=  NULL && lt2 !=  NULL){
            addData = lt1->data + lt2->data;
            lt1 = lt1->next;
            lt2 = lt2->next;
        } else  if (lt1 ==  NULL && lt2 !=  NULL){
            addData = lt2->data;
            lt2 = lt2->next;
        } else {
            addData = lt1->data;
            lt1 = lt1->next;
        }

         int totalData = addData + carryI;
        newList = insertBack( newList, makeNode(totalData %  10) );
        carryI = totalData /  10;
    }

     if (carryI >  0){
        newList = insertBack( newList, makeNode(carryI) );
    }

     return newList;
}


int main()
{
     int arr1[] = { 6,  1,  7};
     int arr2[] = { 3,  9,  5};

    LinkedList list1 =  NULL, list2 =  NULL, newList =  NULL;

     for (size_t i =  0; i <  sizeof(arr1) /  sizeof( int); i++){
        list1 = insertBack( list1, makeNode(arr1[i]) );
    }

     for (size_t i =  0; i <  sizeof(arr2) /  sizeof( int); i++){
        list2 = insertBack( list2, makeNode(arr2[i]) );
    }

    list1 = reverse(list1);
    list2 = reverse(list2);
    newList = addLists(list1, list2);

     // 转换回原来的顺序
    list1 = reverse(list1);
    list2 = reverse(list2);
    newList = reverse(newList);
    cout <<  "list1 = ";   traverse(list1, printData);    cout << endl;
    cout <<  "list2 = ";   traverse(list2, printData);    cout << endl;
    cout <<  "newList = "; traverse(newList, printData);  cout << endl;

    getchar();
     return  0;
}

运行结果：


思考体会：

1、正向存放题设解决这里用一个函数reverse来反转链表，在通过原来的addList计算，再把得到结果反转回去。

2、其他更高效简洁方法？

3、递归求解？


2.6  给定一个有环链表，实现一个算法返回环路的开头结点。有环链表定义：

在链表中某个结点的next元素指向在它前面出现过的结点，则表明该链表存在环路。

示例：

输入：A->B->C->D->E->C(C结点出现两次)。

输出：C 

解决方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#include <iostream>
#include <cstring>
#include <cstdio>    // getchar()
#include  "LinkedList.h"

using  namespace std;


/************************************************************************/
// 函数名称：findBegining
// 函数目的：找到有环链表的开头结点
// 函数参数：head:有环链表
// 函数返回：环开头结点
// 使用条件:
/************************************************************************/
Node* findBegining(LinkedList head)
{
    LinkedList slow = head;
    LinkedList fast = head;

     /* 找出碰撞处，将处于链表中LOOP_SIZE-k步的位置 */
     while (fast !=  NULL && fast->next !=  NULL){
        slow = slow->next;
        fast = fast->next->next;

         if (slow == fast) {   // 碰撞
             break;
        }
    }

     /* 错误检查，没有碰撞处，也即没有环路*/
     if (fast ==  NULL || fast->next ==  NULL){
         return  NULL;
    }

     /* 将slow指向首部，fast指向碰撞处，两者
     * 距离环路起始处k步，若两者以相同的速度移动，
     * 则必定会在环路处碰撞在一起 */
     slow = head;
      while (slow != fast){
        slow = slow->next;
        fast = fast->next;
     }

     /* 至此两者均指向环路起始处 */
     return fast;
}


int main()
{
     int arr[] = {  1,  2,  3,  4,  5,  6,  7,  8,  9};

     for (size_t i =  0; i <  sizeof(arr) /  sizeof( int); i++){
        insertBack( makeNode(arr[i]) );
    }

     // 插入后形成环路
    Node* pNode = search( 5);
    insertBack( pNode );

    LinkedList  head = getHead();
    Node* nodeBegin = findBegining( head );

    cout <<  "回环开头结点是：" << ((nodeBegin !=  NULL) ? nodeBegin :  NULL ) << endl;
    cout <<  "回环开头结点值是：" << ((nodeBegin !=  NULL) ? nodeBegin->data :  0 ) << endl;

    getchar();
     return  0;
}

运行结果：


思考体会：

1、解答该题找到条件成立的点，得到规律。

2、经典面试题：检测链表是否有环路，的变体。


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

解决方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#include <iostream>
#include <cstring>
#include <cstdio>    // getchar()
#include  "LinkedList.h"

using  namespace std;


/************************************************************************/
// 函数名称：isPalindromes (递归实现)
// 函数目的：判断一个链表是否是回文
// 函数参数：head: 链表
// 函数返回：true: 是回文
// 使用条件:
/************************************************************************/
bool isPalindrome(LinkedList head, size_t length, Node** nextNode)
{
     bool success =  false;
     if (  NULL == head || length ==  0){
         return  false;
    }
     else  if (length ==  2){   // 偶数
        *nextNode = head->next;
    }
     else  if (length ==  3 ) {  // 链表有奇数个元素，跳过中间元素
        *nextNode = head->next->next;
    }
     else {
         success =  isPalindrome(head->next, length -  2, nextNode);
          if (!success)   return  false;
    }

     if ( nextNode ==  NULL || (*nextNode) ==  NULL) {
         return  false;
    }

     // test
    cout << head->data <<  "\t" << (*nextNode)->data << endl;

     if (head->data != (*nextNode)->data) {
         return  false;
    }

    *nextNode = (*nextNode)->next;   // 后移一位
     return  true;
}

int main()
{
     int arr1[] = { 6,  1,  7,  1,  6};
     int arr2[] = { 3,  9,  5,  5,  9,  3};

    LinkedList list1 =  NULL, list2 =  NULL;

     for (size_t i =  0; i <  sizeof(arr1) /  sizeof( int); i++){
        list1 = insertBack( list1, makeNode(arr1[i]) );
    }

     for (size_t i =  0; i <  sizeof(arr2) /  sizeof( int); i++){
        list2 = insertBack( list2, makeNode(arr2[i]) );
    }

    Node** theNode = &list1;
    cout <<  "list1 = " << (isPalindrome(list1, size(list1), theNode) ?
                            "true" :  "false") << endl;
    cout <<  "list2 = " << (isPalindrome(list2, size(list2), theNode) ?
                            "true" :  "false") << endl;

    getchar();
     return  0;
}

运行结果：


思考体会：

1、理解递归的的的巧妙运用.

2、仔细体会指针的指针的应用.





JohnnyHu90
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
判断链表是否为回文链表leetcode-C_CPP_PROJECTS:学习C/C++
07-01
判断链表是否为回文链表 leetcode C/C++编程以及Git操作练习(使用VSCode) 效果预览 1. VSCode配置C/C++编译 .vscode\c_cpp_properties.json配置includePath .vscode\tasks.json配置gcc/g++编译指令 .vscode\launch....
链表常见面试题C/C++
zhangsy_csdn的博客
06-08 2373
链表 文章目录链表1. 链表反转题目思路代码2. 链表反转（部分反转）题目思路代码3. 链表交点题目思路方法1方法2代码3.环形链表交点题目思路代码4. 复杂链表复制题目思路方法1方法2代码5.两个排序链表的合并题目 （Leetcode21）思路代码6.K个排序链表合并题目 （Leetcode23）思路代码 leetcode部分链表题目笔记 1. 链表反转 题目 反转一个单链表。 示例:输入: ...
链表操作函数 C
荣子的专栏
06-03 1817
#include #include typedef struct tagNode { struct tagNode *fwd; struct tagNode *bwd; int value; }DDL_S; int valuePrint(DDL_S *rootp) { DDL_S *current; DDL_S *next; int i = 0; pri
力扣第24题
qq_39939541的博客
11-23 149
力扣第24题 24. 两两交换链表中的节点
双向链表
WWIandMC的博客
07-12 551
在单链表的基础上，给每个物理结点增加一个指向后继结点的指针域 优点： 从任一结点出发可以快速找到其前趋结点和后继结点 从任一结点出发可以访问其他结点 typedef struct Dnode{ int data; struct Dnode *prior; struct Dnode *next; }dnode; 成员 作用 data 数据域 prior 指针域，指向前趋结点 next 指针域，指向后继结点 双链表中结点的插入 在p指向的结点之后插入s指向的结点 s
【C++】面试101，链表相加，单链表排序，删除链表的重复元素，链表奇偶重排，判断链表是否回文
weixin_71138261的博客
03-15 180
【C++】面试101，链表相加，单链表排序，删除链表的重复元素，链表奇偶重排，判断链表是否回文
数据结构模板源代码（图、栈、队列、链表、二叉树），C语言/C++
08-24
各位好，这里是太阳终于出来啦，之前有考408的朋友觉得数据结构的算法题无从下手，我给他的建议是多去上手实操，毕竟有实时的输出反馈对于初学者而言帮助很大，但是他又和我抱怨对着空白的编译器无从下手，这才想到...
C/C++ 双链表之逆序的实例详解
08-30
主要介绍了C/C++ 双链表之逆序的实例详解的相关资料,需要的朋友可以参考下
链表c/c++教学课件
11-22
c++链表问题汇总(代码及解析)
祥瑞的技术博客
09-01 1699
目录 一、链表与指针 1.1 单向双向表 1.2 数组指针 1.3 链表的合并 二、链表应用汇总 2.1 链表中的值倒序 2.2 链表的倒数第k个节点 2.3 反转链表 2.4 链表的公共节点 2.5 链表环的入口节点 三、复杂链表的复制 3.1 题干 3.2 思路及注意事项 3.3 正确答案 3.4 错误代码找错 四、二叉树转为双向链表 相应oj链接： htt...
常见的链表面试题大汇总
09-05
常见的链表面试题大汇总： 1，创建一个链表结点 2，遍历链表中的所有结点 3，倒序打印链表 4，往链表末尾添加结点 5，往链表前端添加结点, 6，获取链表的节点数目 7，销毁链表 8，求链表中倒数第K个节点 9，反转链表 10，查找链表中间节点 11，判断链表是否有环 12，判断链表是否有环，并返回环上的节点数目
C/C++数据结构之链表题目答案与解析
最新发布
Infernal_Puppet的博客
11-11 1655
在前面我们讲解了一些关于链表的内容，其中还有一些关于链表的习题，今天我们主要对这些题目进行解析。数据结构的学习非常的重要，我们想要学习好数据结构需要我们多多的刷题，希望大家可以在平时多多刷题来提升自己，最后希望大家可以三连一下。
链表面试常见考题（C++实现）
Melo琦
05-31 634
链表 2: 单链表实现约瑟夫环约瑟夫环问题： 围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。思路：利用单链表数据结构，每次找到目标节点，之后将该节点从链表移除。更新当前的头节点，再次遍历寻找目标节点，之后剩下一个节点为止。 3: 逆置/反转单链表反转链表： 1 2 3 4 5 反转
C++链表基本用法及LeetCode经典链表题目汇总
whocare的博客
05-02 3110
链表基本用法： 目录 链表基本用法： C++链表及基本操作 LeetCode链表经典题目汇总： 2. 两数相加 19. 删除链表的倒数第 N 个结点 21. 合并两个有序链表 23. 合并K个升序链表 24. 两两交换链表中的节点 25. K 个一组翻转链表 61. 旋转链表 92. 反转链表 II 141. 环形链表 142. 环形链表 II 160. 相交链表 328. 奇偶链表 C++链表及基本操作 1 2 ...
C++之链表
gghhb12的博客
04-05 2914
C++之链表
链表面试题(图文详解)
qq_61688804的博客
07-05 585
链表面试题超赞合集！ Leetcode传送门，点击这里！！ 【图示：第一种方法】【图示：第二种方法】Leetcode传送门，点击这里！！ 【图示：】牛客传送门，点击这里！！ 【图示：】 5，合并两个有序链表 Leetcode传送门，点击这里！！ 【图示：】牛客传送门，点击这里！！ 【图示：】牛客传送门，点击这里！！ 【图示：】Leetcode传送门，点击这里！！ 【图示：】Leetcode传送门，点击这里！！ 答案是：快指针一次走两步，慢指针一次走一步。......
常见的链表面试题(上)
罗舒淇的博客
05-01 513
本博客详细讲解了常见的链表面试题
C++ ---- 链表题 ---- 持续更新中。
huanfei8895的博客
08-17 682
链表题：一个链表的结点结构 复制代码 struct Node { int data ; Node *next ; }; typedef struct Node Node ; (1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel) Node * ReverseList(Node *head) //链表逆序 { if ( head == NULL || head->next == NULL ) return head; Node *p1 = head ; Node *p2 = p1-&
C++ 链表入门习题
weixin_42455006的博客
12-21 573
在注释中找到程序 2（在列表的 FRONT 插入几个节点）。修改 程序在列表的前面仅插入三 (3) 个节点。测试程序。 Q1的解决方案： 类和功能都保持不变。这是使用函数的主要原因之一， 也就是说，我们可以更改一个函数（或主函数），而保持其他一切不变。将主要更改为： int main() { // insert at the FRONT of the list Node *temp; int number, i; listpointer = NULL; for (i = 0; i < 3;.
c/c++数据结构面试题
06-23
### 回答1： C/C++ 是应用广泛的编程语言，其在数据结构应用方面也十分重要。...以上这三个问题分别从二分法、堆排序和链表三个方面介绍了常见的C/C++数据结构面试题，希望能帮助面试者更好地准备面试。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值