嵌入式面试题 C/C++ 链表面试题总结

已于 2024-02-15 03:12:27 修改
阅读量546 收藏 2
点赞数
分类专栏： 面试 文章标签： 数据结构 链表
于 2023-10-03 21:56:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49303682/article/details/133530176
版权

1.单链表

https://blog.csdn.net/qq_36806987/article/details/79858957

 1 #include<stdio.h>
  2 #include<stdlib.h>
  3 
  4 /*结构体部分*/
  5 typedef struct Node
  6 {
  7     int data;   //数值域
  8     struct Node *next;  //指针域
  9 }N;
 10 
 11 N *Init()    //初始化单链表
 12 {
 13     N *n;
 14     n = (N *)malloc(sizeof(N));
 15     n->next = NULL;
 16     return n;
 17 }
 18 
 19 N* Create(N* n)
 20 {
 21     /*通过输入n个数据，创建一个单链表*/
 22     int x;
 23     N *p,*r,*l;
 24     l = r = n;
 25     printf("输入-1结束\n");
 26     scanf("%d",&x);
 27     while(-1 != x )
 28     {
 29         p = (N *)malloc(sizeof(N));
 30         p -> data = x;
 31         p -> next = NULL;
 32         r->next = p;
 33         r = r->next;    //指针r始终指向链表中末数据元素所在位置
 34         scanf("%d",&x);
 35     }
 36     return l;
 37 }
 38 
 39 void output(N* n) //输出
 40 {
 41     N *p;
 42     p = n->next;
 43     while(p)
 44     {
 45         printf("%d ",p->data);
 46         p = p->next;
 47     }
 48     printf("\n");
 49 }
 50 
 51 int InsItem(N *L,int item,int x) /*给定的序号来插入*/
 52 {
 53     int i = 1;
 54     N *p,*t;
 55     p = L;
 56     t = (N *)malloc(sizeof(N));
 57     t ->data = item;
 58     if(L->next==NULL)
 59     {   /*若L为空表且要求将新结点插入到第0个位置*/
 60         if(x==1)
 61             {
 62                 L->next=t;
 63                 t->next=NULL;
 64                 return 1;
 65             }
 66     }
 67     while(p->next!=NULL&&i<x)/*查找第i个节点*/
 68     {
 69         p = p->next;
 70         i++;
 71     }
 72     if(p->next==NULL&&i<x)/*在表中不存在插入位置i ，找不到，则插入操作失败*/
 73     {
 74         return 0;
 75     }
 76     else
 77     {
 78         t->next = p->next;
 79         p->next = t;
 80         return 1;
 81     }
 82 }
 83 
 84 int DelItem(N *L,int x)//在单链表中删除数据元素
 85 {
 86     int i = 1;
 87     N *p,*q;
 88     p = L;
 89     if(L->next==NULL) /*L为空表，无结点可删除*/
 90     {
 91         return 0;
 92     }
 93     while(p->next!=NULL&&i<x)
 94     {
 95         p = p->next;
 96         i++;
 97     }
 98     if(p->next==NULL)/*若没有第i个结点，则删除操作失败*/
 99     {
100         return 0;
101     }
102     else
103     {
104         q = p->next;
105         p->next = p->next->next;
106         free(q);
107         return 1;
108     }
109 }
110 
111 int main()
112 {
113     N* n = Init();
114     n = Create(n);
115     output(n);
116     InsItem(n,5,5);
117     output(n);
118     DelItem(n,5);
119     output(n);
120 
121     return 0;
122 }

2.双链表

https://blog.csdn.net/qq_16933601/article/details/105351119

1 #include <stdio.h>
  2 #include <stdlib.h>
  3 
  4 typedef struct Node{
  5     struct Node *pre;
  6     int data;
  7     struct Node *next;
  8 }N;
  9 
 10 N *Init()
 11 {
 12     N *n;
 13     n=(N*)malloc(sizeof(N));//鍒涘缓閾捐〃绗竴涓粨鐐癸紙棣栧厓缁撶偣锛?
 14     n->next = n->pre=NULL;
 15     return n;
 16 }
 17 
 18 N* Create(N* n)
 19 {
 20    /*通过输入n个数据，创建一个单链表*/
 21     int x;
 22      N *p,*r,*l;
 23      l = r = n;
 24      printf("输入-1结束\n");
 25      scanf("%d",&x);
 26      while(-1 != x )
 27      {
 28          p = (N *)malloc(sizeof(N));
 29          p -> data = x;
 30          p->pre = p -> next = NULL;
 31          r->next = p;
 32          p->pre = r;
 33          r = r->next;    //指针r始终指向链表中末数据元素所在位置
 34          scanf("%d",&x);
 35     }
 36     return l;
 37 }
 38 
 39 void output(N* n) //输出
 40 {
 41      N *p;
 42      p = n->next;
 43      while(p)
 44      {
 45          printf("%d ",p->data);
 46          p = p->next;
 47      }
 48      printf("\n");
 49 }
 50 
 51 int InsItem(N *L,int item,int x) /*给定的序号来插入*/
 52 {
 53     int i = 1;
 54     N *p,*t;
 55     p = L;
 56     t = (N *)malloc(sizeof(N));
 57     t ->data = item;
 58     if(L->next==NULL)
 59     {   /*若L为空表且要求将新结点插入到第0个位置*/
 60         if(x==1)
 61         {
 62             L->next=t;
 63             t->pre = L;
 64             t->next=NULL;
 65             return 1;
 66         }
 67     }
 68     while(p->next!=NULL&&i<x)/*查找第i个节点*/
 69     {
 70         p = p->next;
 71         i++;
 72     }
 73     if(p->next==NULL&& i == x)/*在表中不存在插入位置i ，找不到，则插入操作失败*/
 74     {
 75         t->next = NULL;
 76         p->next = t;
 77         t->pre = p;
 78         return 1;
 79     }
 80     else
 81     {
 82         p->next->pre=t;
 83         t->next=p->next;
 84         p->next=t;
 85         t->pre=p;
 86         return 1;
 87     }
 88 }
 89 
 90 int DelItem(N *L,int x)//在单链表中删除数据元素
 91 {
 92     int i = 0;
 93     N *p,*q;
 94     p = L;
 95     if(L->next==NULL) /*L为空表，无结点可删除*/
 96     {
 97         return 0;
 98     }
 99     while(p->next!=NULL&&i<x)
100     {
101         p = p->next;
102         i++;
103     }
104     if(p->next==NULL && i == x)/*若没有第i个结点，则删除操作失败*/
105     {
106         p->pre->next = NULL;
107         free(p);
108         return 1;
109     }
110     else
111     {
112         p->pre->next=p->next;
113         p->next->pre=p->pre;
114         free(p);
115         return 1;
116     }
117 }
118 
119 int main()
120 {
121     N* n;
122     n = Init();
123     n = Create(n);
124     output(n);
125     InsItem(n,5,5);
126     output(n);
127     DelItem(n,5);
128     output(n);
129 
130     return 0;
131 }

3.单链表的反转

https://liang.blog.csdn.net/article/details/90116419 

1 #include<stdio.h>
 2 #include<stdlib.h>
 3  
 4 typedef int ElemType;
 5 
 6 typedef struct Node
 7 {
 8     ElemType data;   //数值域
 9     struct Node *next;  //指针域
10 }Linklist;
11  
12 Linklist *InitList(Linklist *L)    //初始化单链表
13 {
14     L = (Linklist *) malloc(sizeof(Linklist));
15     L->next = NULL;
16     return L;
17 }
18  
19 Linklist *CreateList(int n)
20 {
21     /*通过输入n个数据，创建一个单链表*/
22     int x,i;
23     Linklist *L,*r,*p;
24     L = InitList(L); //构造头结点
25     r = L;
26     printf("input %d value: ",n);
27     for(i=0;i<n;i++)
28     {
29         scanf("%d",&x);
30         p = (Linklist *)malloc(sizeof(Linklist));
31         p -> data = x;
32         p -> next = NULL;
33         r->next = p;
34         r = r->next;    //指针r始终指向链表中末数据元素所在位置
35  
36     }
37     return L;
38 }
39 
40 //头插法
41 int add_node_head(Linklist* head, Linklist* new_node)
42 {
43     if(NULL == head || NULL == new_node)
44         return -1;
45      new_node->next = head->next;
46     head->next = new_node;
47     return 0; 
48 } 
49 
50 //头插方式1-反转链表 
51 Linklist* revert_list(Linklist* head)
52 {
53     if(NULL == head)
54         return NULL;
55  
56     Linklist* p = head->next;
57     head->next= NULL;
58     Linklist* tmp = NULL;
59     while(p)
60     {
61         tmp = p->next;
62         add_node_head(head, p); 
63         p = tmp;    
64     }
65     return head;
66 }
67 
68 void output(Linklist *L) //输出
69 {
70     Linklist *p;
71     p = L->next;
72     printf("output element: \n");
73     for(;p!=NULL;p=p->next)
74     {
75         printf(" %d ",p->data);
76     }
77     printf("\n");
78 }
79 
80 int main()
81 {
82     Linklist *l = CreateList(6);
83     output(l);
84     l = revert_list(l);
85     output(l);
86     
87     return 0;
88 }

4.删除链表中的重复元素

https://blog.csdn.net/m0_59938453/article/details/123021127

1 #include<stdio.h>
 2 #include<stdlib.h>
 3  
 4 typedef int ElemType;
 5 
 6 typedef struct Node
 7 {
 8     ElemType data;   //数值域
 9     struct Node *next;  //指针域
10 }Linklist;
11  
12 Linklist *InitList(Linklist *L)    //初始化单链表
13 {
14     L = (Linklist *) malloc(sizeof(Linklist));
15     L->next = NULL;
16     return L;
17 }
18  
19 Linklist *CreateList(int n)
20 {
21     /*通过输入n个数据，创建一个单链表*/
22     int x,i;
23     Linklist *L,*r,*p;
24     L = InitList(L); //构造头结点
25     r = L;
26     printf("input %d value: ",n);
27     for(i=0;i<n;i++)
28     {
29         scanf("%d",&x);
30         p = (Linklist *)malloc(sizeof(Linklist));
31         p -> data = x;
32         p -> next = NULL;
33         r->next = p;
34         r = r->next;    //指针r始终指向链表中末数据元素所在位置
35  
36     }
37     return L;
38 }
39 
40 void output(Linklist *L) //输出
41 {
42     Linklist *p;
43     p = L->next;
44     printf("output element: \n");
45     for(;p!=NULL;p=p->next)
46     {
47         printf(" %d ",p->data);
48     }
49     printf("\n");
50 }
51 
52 Linklist* deleteDuplicates(Linklist* head)
53 {
54     //空链表就直接返回空指针
55     if(NULL == head)  // 注：在条件判断中，head == NULL 和 !head 所起的作用是一样的。
56         return NULL;
57 
58     Linklist* cur = head;
59     while(cur->next)  // 注意循环条件
60     {
61         Linklist* next = cur->next;
62         //若相等，则删掉下一个节点
63         if(cur->data == next->data)
64         {
65             cur->next = next->next;
66             free(next);
67         }
68         //若不等，则将下一个节点变为当前节点
69         else
70             cur = cur->next;
71     }
72     return head;  
73 }
74 
75 int main()
76 {
77     Linklist *l = CreateList(6);
78     output(l);
79     l = deleteDuplicates(l);
80     output(l);
81     
82     return 0;
83 }

c++实现删除链表的重复元素，把重复的元素全部删除（力扣82题）：

1 #include <iostream>
 2 #include <vector>
 3 using namespace std;
 4 
 5 typedef struct Node
 6 {
 7    int data;   
 8     struct Node *next;  
 9 }Linklist;
10 
11 class node1{
12 public:
13     Linklist *InitList(Linklist *L){    //初始化单链表
14         L = new Linklist;
15         L->next = NULL;
16         return L;
17     }
18     
19     Linklist *CreateList(int n){
20      /*通过输入n个数据，创建一个单链表*/
21         int x,i;
22         Linklist *L,*r,*p;
23         L = InitList(L); //构造头结点
24         r = L;
25         for(i=0;i<n;i++){
26             cin >> x;
27             p = new Linklist;
28             p -> data = x;
29             p -> next = NULL;
30             r->next = p;
31             r = r->next;    //指针r始终指向链表中末数据元素所在位置
32         }
33          return L;
34      }
35     
36      void output(Linklist *L){ //输出
37         Linklist *p;
38         p = L->next;
39         for(;p!=NULL;p=p->next)
40             cout << p->data;
41         cout << endl;
42      }
43      
44     Linklist *deletedup(Linklist *L){
45         Linklist *dumy = new Linklist,*p = dumy;
46         dumy->next = L;
47         while(p->next){
48            Linklist* q = p->next;
49            while(q->next && q->next->data == q->data)  q = q->next;
50            if(q == p->next) p = p->next;
51            else p->next = q->next;
52         }
53         return dumy->next;
54     }
55 };
56 
57 int main()
58 {
59    node1 n;
60    Linklist *l,*p;
61    l = n.CreateList(5);
62    n.output(l);
63    p = n.deletedup(l);
64    n.output(p);
65     
66    return 0;
67 }

c++实现 删除链表重复元素，使得重复元素只出现一次（力扣83题）

1 #include <iostream>
 2 #include <vector>
 3 using namespace std;
 4 
 5 typedef struct Node
 6 {
 7    int data;   
 8     struct Node *next;  
 9 }Linklist;
10 
11 class node1{
12 public:
13     Linklist *InitList(Linklist *L){    //初始化单链表
14         L = new Linklist;
15         L->next = NULL;
16         return L;
17     }
18     
19     Linklist *CreateList(int n){
20      /*通过输入n个数据，创建一个单链表*/
21         int x,i;
22         Linklist *L,*r,*p;
23         L = InitList(L); //构造头结点
24         r = L;
25         for(i=0;i<n;i++){
26             cin >> x;
27             p = new Linklist;
28             p -> data = x;
29             p -> next = NULL;
30             r->next = p;
31             r = r->next;    //指针r始终指向链表中末数据元素所在位置
32         }
33          return L;
34      }
35     
36      void output(Linklist *L){ //输出
37         Linklist *p;
38         p = L->next;
39         for(;p!=NULL;p=p->next)
40             cout << p->data;
41         cout << endl;
42      }
43      
44     Linklist *deletedup(Linklist *L){
45         Linklist *p = L;
46         while(p && p->next){
47            Linklist *q = p->next;
48            while(q && q->data == p->data) q = q->next;
49            p->next = q;
50            p = p->next;
51         }
52         return L;
53     }
54 };
55 
56 int main()
57 {
58    node1 n;
59    Linklist *l,*p;
60    l = n.CreateList(5);
61    n.output(l);
62    p = n.deletedup(l);
63    n.output(p);
64     
65    return 0;
66 }

5.链表排序

https://blog.csdn.net/Vectory0213/article/details/79168475

 1 #include<stdio.h>
 2 #include<stdlib.h>
 3  
 4 typedef int ElemType;
 5 
 6 typedef struct Node
 7 {
 8     ElemType data;   //数值域
 9     struct Node *next;  //指针域
10 }Linklist;
11  
12 Linklist *InitList(Linklist *L)    //初始化单链表
13 {
14     L = (Linklist *) malloc(sizeof(Linklist));
15     L->next = NULL;
16     return L;
17 }
18  
19 Linklist *CreateList(int n)
20 {
21     /*通过输入n个数据，创建一个单链表*/
22     int x,i;
23     Linklist *L,*r,*p;
24     L = InitList(L); //构造头结点
25     r = L;
26     printf("input %d value: ",n);
27     for(i=0;i<n;i++)
28     {
29         scanf("%d",&x);
30         p = (Linklist *)malloc(sizeof(Linklist));
31         p -> data = x;
32         p -> next = NULL;
33         r->next = p;
34         r = r->next;    //指针r始终指向链表中末数据元素所在位置
35  
36     }
37     return L;
38 }
39 
40 void output(Linklist *L) //输出
41 {
42     Linklist *p;
43     p = L->next;
44     printf("output element: \n");
45     for(;p!=NULL;p=p->next)
46     {
47         printf(" %d ",p->data);
48     }
49     printf("\n");
50 }
51 
52 void BubbleSort(Linklist *head)
53 {
54     Linklist *cur,*tail;
55     cur=head;
56     tail=NULL; 
57     if(cur==NULL||cur->next==NULL){
58         return;
59     }
60     while(cur!=tail)
61     {
62         while(cur->next!=tail)
63         {
64             if(cur->data > cur->next->data)
65             {
66                 int temp=cur->data;
67                 cur->data=cur->next->data;
68                 cur->next->data=temp;
69             }
70             cur=cur->next;
71         }
72         tail=cur;
73         cur=head;
74     }
75 }
76 
77 int main()
78 {
79     Linklist *l = CreateList(6);
80     output(l);
81     BubbleSort(l);
82     output(l);
83     
84     return 0;
85 }

6.旋转链表（链表的移位） 力扣61题

1 #include<stdio.h>
 2 #include<stdlib.h>
 3 
 4 #include<stdio.h>
 5 #include<stdlib.h>
 6  
 7 typedef int ElemType;
 8 /*结构体部分*/
 9 typedef struct Node
10 {
11     ElemType data;   //数值域
12     struct Node *next;  //指针域
13 }Linklist;
14  
15 Linklist *InitList(Linklist *L)    //初始化单链表
16 {
17     int x;
18     scanf("%d",&x);
19     L = (Linklist *) malloc(sizeof(Linklist));
20     L->data = x;
21     L->next = NULL;
22     return L;
23 }
24  
25 Linklist *CreateList(int n)
26 {
27     /*通过输入n个数据，创建一个单链表*/
28     int x,i;
29     Linklist *L,*r,*p;
30     L = InitList(L); //构造头结点
31     r = L;
32     printf("input %d value: ",n);
33     for(i=0;i<n;i++)
34     {
35         scanf("%d",&x);
36         p = (Linklist *)malloc(sizeof(Linklist));
37         p -> data = x;
38         p -> next = NULL;
39         r->next = p;
40         r = r->next;    //指针r始终指向链表中末数据元素所在位置
41  
42     }
43     return L;
44 }
45 
46 Linklist *rotatRight(Linklist *head,int k)
47 {
48     if(NULL == head) return NULL;
49     Linklist *cur = head;
50     int n = 1;
51     while(cur->next) cur = cur->next;n++;
52     cur->next = head;
53     for(int i = 0;i<n-k%n;i++)
54     {
55         cur = cur->next;
56     }
57     head = cur->next;
58     cur->next = NULL;
59     return head;
60 }
61 
62 void output(Linklist *L) //输出
63 {
64     Linklist *p;
65     p = L;
66     printf("output element: \n");
67     for(;p!=NULL;p=p->next)
68     {
69         printf(" %d ",p->data);
70     }
71     printf("\n");
72 }
73 
74 int main()
75 {
76     Linklist *l = CreateList(4);
77     output(l);
78     l = rotatRight(l,5);
79     output(l);
80     
81     return 0;
82 }

7.两数之和（力扣第二题）

创建2个链表，对两个链表对应位进行相加。

1 #include<iostream>
 2 using namespace std;
 3 
 4 typedef struct Node
 5 {
 6     int data;   
 7     struct Node *next;  
 8 }Linklist;
 9 
10 class node{
11 public:
12     Linklist *InitList(Linklist *L)    //初始化单链表
13     {
14        L = new Linklist;
15        L->next = NULL;
16        return L;
17     }
18  
19     Linklist *CreateList(int n)
20     {
21     /*通过输入n个数据，创建一个单链表*/
22        int x,i;
23        Linklist *L,*r,*p;
24        L = InitList(L); //构造头结点
25        r = L;
26        for(i=0;i<n;i++)
27        {
28            cin >> x;
29            p = new Linklist;
30            p -> data = x;
31            p -> next = NULL;
32            r->next = p;
33            r = r->next;    //指针r始终指向链表中末数据元素所在位置
34        }
35         return L;
36     }
37     
38     void output(Linklist *L) //输出
39     {
40        Linklist *p;
41        p = L->next;
42        for(;p!=NULL;p=p->next)
43        {
44            cout << p->data;
45        }
46        cout << endl;
47     }
48     
49     Linklist *addtwonumbers(Linklist *l1,Linklist *l2)
50     {
51         Linklist *dumy = new Linklist,*cur = dumy;
52         int sum = 0;
53         while(l1 || l2 || sum){
54             if(l1) sum += l1->data,l1=l1->next;
55             if(l2) sum += l2->data,l2=l2->next;
56             cur->next = new Linklist;
57             cur->data = sum%10;
58             cur = cur->next;
59             sum /= 10;
60         }
61         return dumy->next;
62     }
63 };
64 
65 int main()
66 {
67     node n;
68     Linklist *l,*r,*p;
69     l = n.CreateList(3);
70     n.output(l);
71     r = n.CreateList(3);
72     n.output(r);
73     p = n.addtwonumbers(l,r);
74     n.output(p);
75     
76     return 0;
77 }

 8.合并两个有序链表（力扣21题）

1 #include<iostream>
 2 using namespace std;
 3  
 4  typedef struct Node
 5  {
 6      int data;   
 7       struct Node *next;  
 8  }Linklist;
 9  
10 class node{
11 public:
12     Linklist *InitList(Linklist *L)    //初始化单链表
13      {
14         L = new Linklist;
15         L->next = NULL;
16         return L;
17      }
18   
19      Linklist *CreateList(int n)
20      {
21      /*通过输入n个数据，创建一个单链表*/
22         int x,i;
23         Linklist *L,*r,*p;
24         L = InitList(L); //构造头结点
25         r = L;
26         for(i=0;i<n;i++)
27         {
28             cin >> x;
29             p = new Linklist;
30             p -> data = x;
31             p -> next = NULL;
32             r->next = p;
33             r = r->next;    //指针r始终指向链表中末数据元素所在位置
34         }
35          return L;
36      }
37      
38      void output(Linklist *L) //输出
39      {
40         Linklist *p;
41         p = L->next;
42         for(;p!=NULL;p=p->next)
43         {
44             cout << p->data;
45         }
46         cout << endl;
47      }
48      
49      Linklist *addtwonumbers(Linklist *l1,Linklist *l2)
50      {
51            Linklist* dumy = new Linklist,*cur = dumy;
52            while(l1 && l2){
53                if(l1->data <=l2->data){
54                   cur->next = new Linklist;
55                   cur->next->data = l1->data;
56                   l1 = l1->next;
57                }else{
58                   cur->next = new Linklist;
59                   cur->next->data = l2->data;
60                   l2 = l2->next;
61                }   
62                cur = cur->next;
63            }
64          cur->next = l1 ? l1 : l2;
65          return dumy->next->next;
66      }
67  };
68  
69  int main()
70  {
71      node n;
72      Linklist *l,*r,*p;
73      l = n.CreateList(3);
74      n.output(l);
75      r = n.CreateList(3);
76      n.output(r);
77      p = n.addtwonumbers(l,r);
78      n.output(p);
79      
80      return 0;
81  }

9.删除链表的倒数第N个元素（力扣第十九题）

#include <iostream>
using namespace std;

typedef struct Node
{
     int data;   //数值域
     struct Node *next;  //指针域
}Linklist;

class node{
public:
    Linklist *InitList(Linklist *L)    //初始化单链表
    {
       L = new Linklist;
       L->next = NULL;
       return L;
    }
    
    Linklist *CreateList(int n)
    {
       /*通过输入n个数据，创建一个单链表*/
       int x,i;
       Linklist *L,*r,*p;
       L = InitList(L); //构造头结点
       r = L;
       for(i=0;i<n;i++)
       {
           cin >> x;
           p = new Linklist;
           p -> data = x;
           p -> next = NULL;
           r->next = p;
           r = r->next;    //指针r始终指向链表中末数据元素所在位置
       }
       return L;
    }
    
    void output(Linklist *L) //输出
    {
       Linklist *p;
       p = L->next;
       for(;p!=NULL;p=p->next)
       {
           cout << p->data << " ";
       }
       cout << endl;
    }
    
    Linklist* removee(Linklist* head,int n)
    {
        Linklist *dumy = new Linklist;
        Linklist *slow = dumy,*fast = dumy;
        dumy->next = head;
        for(int i = 0;i<n;i++){
            fast = fast->next;
        }
        while(fast->next){
            slow = slow->next;
            fast = fast->next;
        }
        slow->next = slow->next->next;
        return dumy->next;
    }
};

int main() 
{
    node n;
    Linklist *l = n.CreateList(5);
    n.output(l);
    l = n.removee(l,4);
    n.output(l);
    
    return 0;
}

嵌入式_笔记
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链表面试题总结（一）
宇哲
06-11 1万+
基于上一次写的链表，现在，我们来讨论下面这些问题。1.链表的冒泡排序 2.删除无头非尾节点 3.反转链表 4.在当前节点前插入一个数据x 5.查找链表的中间节点。 6.删除单链表的倒数第K个节点（K>1&&K<总长度）对于上面这6个问题，我们进行分析与解答。链表的代码我都已经写过博客：数据结构—单链表的实现另外，我也在我的github上有链表的代码，github链接如还有什么问题，可以发邮
嵌入式软件工程师笔试面试题分类汇总——C语言链表之增删改查等等（超详细）
黑面秃头的博客
10-09 871
C语言链表1. 基础知识1.1 什么是链表 ？1.2 链表的优点&缺点1.3 复杂度2. 基本操作2.1 链表的结构类型2.2 创建一个节点并初始化2.3 链表的头插法&尾插法2.3.1 尾插法2.3.2 头插法2.4 查找2.4.1 按序号查找节点值2.4.2 按值查找链表节点2.5 按给定序号插入2.6 删除2.6.1 按序号删除节点2.6.2 按值删除节点   由于本人表较懒，加之你如果理解了单链表，那么双链表、循环链表我觉得都不是太大问题，所以本篇博文仅针对单链表进行详细讲解。整理匆
C++面试——链表
Face_to_sun
04-21 167
链表逆序 #include<iostream> using namespace std; struct ListNode { int data; ListNode* next; }; ListNode * reverseList(ListNode* head) { ListNode *p, *q, *t=nullptr; p = head; if (p->next ...
链表面试题C++
开贰锤
11-09 717
注意头结点的处理，如果倒叙记得将新的尾节点指向空。 示例一 给定一个整数num，如何在节点值有序的链表中插入一个节点值为num的节点，并且保证这个单链表依然有序。 #include&amp;amp;amp;lt;iostream&amp;amp;amp;gt; #include&amp;amp;amp;lt;thread&amp;amp;amp;gt; using std::endl; using std::cout; template&amp;amp
C++关于链表操作的八个常见面试题
weixin_30509393的博客
06-23 190
1、从链表的末尾添加节点 2、删除链表节点 3、链表中倒数第K个节点 4、反转链表 5、从尾到头打印链表 6、合并两个排序的链表 7、两个链表的第一个公共节点 8、判断两个链表是否有环相关问题 struct ListNode{int m_data;ListNode *m_pNext;}; 一、从链表的末尾添加节点： ListNode *AddToTail(ListNo...
C++面试题系列:链表
haimianjie2012的专栏
08-13 268
更多文章见C++面试题系列 牛客网 C++校招面试题合集 146:手写代码,如何合并两个有序链表 147:手写代码:反转链表 148:判断一个链表是否为回文链表,说出你的思路并手写代码
嵌入式C面试题总结整理
05-07
在这份嵌入式C面试题总结整理中，涵盖了嵌入式C语言相关的基础知识，包括对变量、函数以及常量的修饰，实时系统的特点，以及全局变量与局部变量的区别等多个方面。下面详细阐述其中的知识点： 1. static关键字的...
C/C++程序员面试指南.杨国祥(带详细书签).pdf
04-08
本书以流行的面试题讲解为主要内容，介绍了C、C++语言基本概念，包括保留字、字符串、指针和引用、结构体、库函数等各个方面的基础知识，介绍了面向对象编程基本概念，包括如何实现继承、多态和封装等。还介绍了排序...
用C/C++实现的各种经典算法以及常见面试题
03-22
本资源“用C/C++实现的各种经典算法以及常见面试题”正是针对这两方面的学习和提升。 首先，经典算法是计算机科学的基础，包括排序、查找、图论、动态规划等。例如： 1. **排序算法**：快速排序、归并排序、堆排序...
经典c/c++笔试面试题汇总
11-07
2. **华为笔试面试题**：华为作为全球知名的科技公司，其笔试和面试题通常涵盖C/C++语言的基本语法、数据结构、算法、操作系统原理等内容，旨在考察候选人的编程基础和解决问题的能力。 3. **嵌入式开发**：嵌入式...
c/c++面试题
10-20
以下是对标题和描述中提到的几个公司面试题可能涉及的重要知识点的详细说明： 1. **百度** - **语言特性**：考察C++11/14/17新特性，如智能指针、lambda表达式、右值引用等。 - **STL使用**：包括容器（如vector,...
【C++】单链表面试题
Cheng_913的博客
11-10 750
链表是非常重要的内容，在面试时也是非常喜欢问的，下面是几个常见的面试题。 说明：这些题目中的链表都是指无头单链表。            代码的实现涉及到部分C++的语法。 typedef struct Node { Node(const int& data) : _data(data) , _pNext(NULL) {} int _data; Node* _pNext; }*p
C/C++面试可能会问一：静态链表与动态链表
最新发布
xiaoyaolangwj的博客
03-12 193
C/C++面试可能会问一：静态链表与动态链表
C++面试准备之单链表操作
lvjianqing007的博客
08-09 265
C++面试准备之单链表操作 链表节点定义 struct ListNode{ int data; ListNode* next; }; 创建链表 ListNode* createList(int n) {//参数为链表的节点数目 ListNode *pHead,*s; pHead = NULL; for(int i=0;i&lt;n;i++) ...
C++面试总结之算法（三）：链表
lxin_liu的博客
04-15 250
1. 怎样判断一个链表有环 （1）最常用方法 定义两个指针，同时从链表的头节点出发，一个指针一次走一步，另一个指针一次走两步。如果走得快的指针追上了走得慢的指针，那么链表就是环形链表；如果走得快的指针走到了链表的末尾（next指向NULL）都没有追上第一个指针，那么链表就不是环形链表。 boolIsLoop(NODE*head){//假设为带头节点的单链表 if(he...
链表常见面试题C/C++
zhangsy_csdn的博客
06-08 2433
链表 文章目录链表1. 链表反转题目思路代码2. 链表反转（部分反转）题目思路代码3. 链表交点题目思路方法1方法2代码3.环形链表交点题目思路代码4. 复杂链表复制题目思路方法1方法2代码5.两个排序链表的合并题目 （Leetcode21）思路代码6.K个排序链表合并题目 （Leetcode23）思路代码 leetcode部分链表题目笔记 1. 链表反转 题目 反转一个单链表。 示例:输入: ...
链表面试常见考题（C++实现）
Melo琦
05-31 739
链表 2: 单链表实现约瑟夫环约瑟夫环问题： 围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。思路：利用单链表数据结构，每次找到目标节点，之后将该节点从链表移除。更新当前的头节点，再次遍历寻找目标节点，之后剩下一个节点为止。 3: 逆置/反转单链表反转链表： 1 2 3 4 5 反转
C/C++笔试经典——链表倒序
rayylee
07-03 6864
设链表节点为： typedef struct tagListNode{ int data; struct tagListNode* next; }ListNode, *List; 要求将一带链表头List head的单向链表逆序。 分析：   1). 若链表为空或只有一个元素，则直接返回；   2). 设置两个前后相邻的指针p,q. 将p所指向的节点作
面试考题之9.2:链表(C/C++版)
JohnnyHu90的专栏
06-07 3451
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
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

嵌入式_笔记

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

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

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

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值