登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›嵌入式面试中常见的一些编程题目

嵌入式面试中常见的一些编程题目

普料飕 昨天 23:55
嵌入式面试中常见的一些编程题目

注：本文只是代码实现，并没有深入讲解实现原理，大家可以看一下主要会考什么，然后再具体针对性了解原理，也更有利于理解。
眼看26届秋招接近尾声，自己虽然很菜，但也在激烈的竞争中拿到了几个 offer，已经非常满意了，希望未来持续学习进步。
本文主要总结了嵌入式秋招中问的比较多的编程题目，总的来说，大部分不会涉及到复杂的算法题（我本身非科班，也没怎么刷题，秋招期间遇到手撕复杂算法的公司也是成功挂掉了），比较重要的是一些已有函数的实现，主要考察对数据在内存中分布的掌握，对C语言在嵌入式场景中理解的深度，比如 memcpy() 函数，遇到 dest 和 src 空间重合的问题是怎么处理的。其次就是各大排序，链表，字符串，数组的操作，二叉树的概念，遍历等等。
一、链表

链表的一些基础操作

  • 链表定义
  1. struct Node {
  2.     int data;
  3.     struct Node* next;
  4. }
复制代码

  • 创建节点
  1. struct Node* createNode(int value) {
  2.     struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
  3.     if(newNode == NULL)
  4.         printf("malloc failed!");
  5.     newNode->data = value;
  6.     newNode->next = NULL;
  7.     return newNode;
  8. }
复制代码

  • 头插法插入节点
  1. struct Node* insertAtHead(struct Node* head, int value) {
  2.     struct Node* newNode = createNode(value);
  3.     newNode->next = head;
  4.     return newNode;  // 新的头结点
  5. }
复制代码

  • 尾插法插入节点
  1. struct Node* insertAtTail(struct Node* head, int value) {
  2.     struct Node* newNode = createNode(value);
  3.     if(head == NULL)
  4.         return newNode;
  5.     struct Node* temp = head;
  6.     while(temp->next != NULL) {
  7.         temp = temp->text;
  8.     }
  9.     temp->next = newNode;
  10.     return head;
  11. }
复制代码

  • 遍历链表
  1. void printList(struct Node* head) {
  2.     struct Node* temp = head;
  3.     while (temp != NULL) {
  4.         printf("%d -> ", temp->data);
  5.         temp = temp->next;
  6.     }
  7.     printf("NULL\n");
  8. }
复制代码
1.  实现链表的逆置
  1. struct ListNode* reverseList(struct ListNode* head) {
  2.     if (head == NULL || head->next == NULL) return NULL;
  3.     struct LiseNode* former;
  4.     struct ListNode* latter;
  5.     struct ListNode* mid = head;
  6.     while (mid != NULL) {
  7.         latter = mid->next;
  8.         mid->next = former;
  9.         former = mid;
  10.         mid = latter;                        
  11.     }
  12. }
复制代码
2. 判断单链表中是否存在环
  1. struct ListNode* detectCycle(struct ListNode* head) {
  2.     struct ListNode* fast = head;
  3.     struct ListNode* slow = head;
  4.    
  5.     while(fast != NULL && fast->next != NULL) {
  6.         slow = slow->next;
  7.         fast = fast->next->next;
  8.         if(slow == fast) {
  9.             fast = head;
  10.             while(fast != slow) {
  11.                 fast = fast->next;
  12.                 slow = slow->next;
  13.                 }
  14.             return slow;
  15.         }
  16.     }
  17.     return NULL;
  18. }
复制代码
3. 单链表相交，如何求交点
  1. struct ListNode* getIntersectionNode(struct ListNode* headA, struct ListNode* headB) {
  2.     struct ListNode* p = headA;
  3.     struct ListNode* q = headB;
  4.    
  5.     while(q != p) {
  6.         if (p == NULL)
  7.             p = headB;
  8.         else
  9.             p = p->next;
  10.         if (q == NULL)
  11.             q = headA;
  12.         else
  13.             q = q->next
  14.     }
  15.     return q;
  16. }
复制代码
4. 求有环链表第一个入环点
  1. struct ListNode* detectCycle(struct ListNode* head) {
  2.     struct ListNode* fast = head;
  3.     struct ListNode* slow = head;
  4.    
  5.     while(fast != NULL && fast->next != NULL) {
  6.         slow = slow->next;
  7.         fast = fast->next->next;
  8.         if(slow == fast) {
  9.             fast = head;
  10.             while(fast != slow) {
  11.                 fast = fast->next;
  12.                 slow = slow->next;
  13.                 }
  14.             return slow;
  15.         }
  16.     }
  17.     return NULL;
  18. }
复制代码
5. 写出链表的删除一个节点的程序
  1. void deleteNode(Node** headRef, int key) {
  2.     Node* temp = *headRef;
  3.     Node* prev = NULL;
  4.         if (temp == NULL) return;
  5.     if (temp->data == key) {
  6.         *headRef = temp->next; // 头指针后移
  7.         free(temp);            // 释放原头节点
  8.         return;
  9.     }
  11.     while (temp != NULL && temp->data != key) {
  12.         prev = temp;
  13.         temp = temp->next;
  14.     }
  15.     if (temp == NULL) return;
  16.     prev->next = temp->next;
  17.     free(temp);
  18. }
复制代码
6. 用递归算法实现两个有序链表的合并
  1. struct ListNode* Merge(struct ListNode* pHead1, struct ListNode* pHead2 ) {
  2.     // write code here
  3.     if (pHead1 == NULL) return pHead2;
  4.     if (pHead2 == NULL) return pHead1;
  5.    
  6.     if (pHead1->val > pHead2->val) {
  7.         pHead2->next = Merge(pHead1, pHead2->next);
  8.         return pHead2;
  9.     } else {
  10.         pHead1->next = Merge(pHead1->next, pHead2);
  11.         return pHead1;
  12.     }
  13. }
复制代码
二、二叉树

满二叉树：除了最后一层，所有的节点都是满的，并且所有节点都有两个子节点
完全二叉树：最后一层可以是单节点，所有节点连续几种在左边。
二叉搜索数：BST，左子树中的所有节点值都小于该节点值。右子树中的所有节点值都大于该节点值。
平衡二叉树：AVL，左右子节点的高度不超过1的BST。
  1. // 定义二叉树节点结构
  2. typedef struct Node {
  3.     int data;               // 存储节点的数据
  4.     struct Node* left;      // 指向左子节点
  5.     struct Node* right;     // 指向右子节点
  6. } Node;
  8. // 创建新节点
  9. Node* createNode(int data) {
  10.     Node* newNode = (Node*)malloc(sizeof(Node));
  11.     if (newNode == NULL) {
  12.         printf("内存分配失败！\n");
  13.         exit(1);
  14.     }
  15.     newNode->data = data;
  16.     newNode->left = NULL;
  17.     newNode->right = NULL;
  18.     return newNode;
  19. }
  21. // 销毁二叉树
  22. void destroyTree(Node* root) {
  23.     if (root == NULL) return;
  24.     destroyTree(root->left);   // 递归释放左子树
  25.     destroyTree(root->right);  // 递归释放右子树
  26.     free(root);                // 释放当前节点
  27. }
  29. // 二叉树深度
  30. int maxDepth(struct TreeNode* root){
  31.    if (root == NULL) return 0;
  32.    int lenLeft = maxDepth(root->left);
  33.    int lenRight = maxDepth(root->right);
  34.    return lenLeft > lenRight ? lenLeft + 1 : lenRight + 1;
  35. }
复制代码
1. 遍历
  1. // 中序遍历：创建一个数组，数组作为传入参数保存遍历的结果
  2. /**
  3. * returnNum: 保存遍历出的元素
  4. * returnSize: 保存二叉树的大小
  5. */
  6. void inTra(struct TreeNode* root, int *returnNum, int* returnSize)
  7. {
  8.     if(root==NULL) return;
  9.     inTra(root->left, returnNum, returnSize);
  10.     returnNum[(*returnSize)++] = root->val;
  11.     inTra(root->right, returnNum, returnSize);
  12. }
  14. int* inorderTraversal(struct TreeNode* root, int* returnSize) {
  15.     int *returnNum = (int *)malloc(sizeof(int)*101);
  16.     *returnSize = 0;
  17.     if(root==NULL) return NULL;
  18.     inTra(root,returnNum,returnSize);
  19.     return returnNum;
  20. }
复制代码
不需要保存的遍历：
  1. // 前序遍历：根 -> 左 -> 右
  2. void preorderTraversal(Node* root) {
  3.     if (root == NULL) return;
  4.     printf("%d ", root->data);  // 访问根节点
  5.     preorderTraversal(root->left);  // 遍历左子树
  6.     preorderTraversal(root->right); // 遍历右子树
  7. }
  9. // 中序遍历：左 -> 根 -> 右
  10. void inorderTraversal(Node* root) {
  11.     if (root == NULL) return;
  12.     inorderTraversal(root->left);   // 遍历左子树
  13.     printf("%d ", root->data);     // 访问根节点
  14.     inorderTraversal(root->right);  // 遍历右子树
  15. }
  18. // 后序遍历：左 -> 右 -> 根
  19. void postorderTraversal(Node* root) {
  20.     if (root == NULL) return;
  21.     postorderTraversal(root->left);  // 遍历左子树
  22.     postorderTraversal(root->right); // 遍历右子树
  23.     printf("%d ", root->data);      // 访问根节点
  24. }
复制代码
2. 深度
  1. int maxDepth(struct TreeNode* root) {
  2.     // 递归结束条件
  3.     if (root == NULL) return 0;
  5.     int l_depth = maxDepth(root->left);
  6.     int r_depth = maxDepth(root->right);
  8.     return (l_depth > r_depth ? l_depth : r_depth) + 1;
  9. }
复制代码
3. 是否平衡二叉树
  1. bool isAVL(struct TreeNode* root)
  2. {
  3.         struct TreeNode* left  = root->left;
  4.     struct TreeNode* right = root->right;
  5.    
  6.     int l_dep = maxDepth(left);
  7.     int r_dep = maxDepth(right);
  8.    
  9.     if (l_dep == r_dep) return true;
  10.     else if (l_dep > r_dep) return ((l_dep-r_dep) < 1 ? true : false);
  11.     else return ((r_dep-l_dep) < 1 ? true : false);
  12. }
复制代码
三、排序查找算法及其改进

我想对于每一个经历过秋招的小伙伴们来说，十大排序基本都被问过（快速排序、归并排序、堆排序、冒泡排序、插入排序、选择排序、希尔排序、桶排序、基数排序）。
排序名称最好时间复杂度平均时间复杂度最坏时间复杂度空间复杂度快排$O(nlogn)$$O(nlogn)$$O(n^2)$$O(logn)$归并$O(nlogn)$$O(nlogn)$$O(nlogn)$$O(n)$插入$O(n)$$O(n^2)$$O(n^2)$$O(1)$冒泡$O(n)$$O(n^2)$$O(n^2)$$O(1)$堆排$O(nlogn)$$O(nlogn)$$O(nlogn)$$O(1)$选择$O(n^2)$$O(n^2)$$O(n^2)$$O(1)$1. 快速排序
  1. void quickSort(vector<int>& arr, int left, int right) {
  2.     if (left >= right) return;
  4.     int pivot = arr[right];
  5.     int l = left - 1;
  6.     int r = left;
  8.     for (; r < right; ++r) {
  9.         if (arr[r] < pivot) {
  10.             l++;
  11.             swap(arr[l], arr[r]);
  12.         }
  13.     }
  14.        
  15.     int povitIndex = l + 1;
  16.     swap(arr[povitIndex], arr[right]);   
  17.     quickSort(arr, left, povitIndex - 1);
  18.     quickSort(arr, povitIndex + 1, right);
  19. }
复制代码
2. 冒泡排序
  1. // 双重循环，每次循环次数减1.长度为5的数组，第一次循环对比4次
  2. void bubble_sort(int *arr, int n) {
  3.     int flag;
  4.     for (int i = 0; i < n-1; i++) {
  5.         flag = 0;
  6.         for (int j = 0; j < n-1-i; j++) {
  7.             if (arr[j] > arr[j+1]) {
  8.                 swap(&arr[j], &arr[j+1]);
  9.                 flag = 1;
  10.             }
  11.         }
  12.         if (flag == 0) return;
  13.     }
  14. }
复制代码
3. 归并排序
  1. /*
  2. * 归并排序的思想：
  3. * 1. merge函数，传入一个以m为界限的左右分别排序好的数组，然后把这个数组合并
  4. * 1.1 首先malloc两个数组L，R然后填充，然后使用? :填充arr[k++]
  5. * 2. mergeSort函数递归执行，停止条件l>=r;
  6. */
  7. void merge(vector<int>& arr, int left, int mid, int right) {
  8.     int n1 = mid - left + 1;
  9.     int n2 = right - mid;
  11.     vector<int> L(arr.begin() + left, arr.begin() + left + n1); // 或 mid + 1
  12.     vector<int> R(arr.begin() + mid + 1, arr.begin() + mid + 1 + n2); // 或 right + 1
  14.     int i = 0, j = 0;
  15.     int k = left;
  17.     while (i < n1 && j < n2) arr[k++] = L[i] < R[j] ? L[i++] : R[j++];
  18.     while (i < n1) arr[k++] = L[i++];
  19.     while (j < n2) arr[k++] = R[j++];
  20. }
  22. void mergeSort(vector<int>& arr, int left, int right) {
  23.     if (left >= right) return;
  24.     int mid = left + (right - left)/2;
  25.     mergeSort(arr, left, mid);
  26.     mergeSort(arr, mid+1, right);
  27.     merge(arr, left, mid, right);
  28. }
复制代码
4. 堆排序

堆的数组表示：
对于数组中一个位置为i的节点（下标从0开始），

  • 父节点：(i-1)/2
  • 左子节点2i+1
  • 右子节点2i+2
最后一个非叶子节点的下标是n/2 - 1。n是数组长度。
最大堆：每个父节点大于子节点。
最小堆：每个子节点大于父节点。
构建最大堆，排序
  1. /**
  2. * @brief 堆化函数
  3. *
  4. * 这是堆排序的核心。它将以 i 为根的子树调整为大顶堆。
  5. * 假设 i 的左右子树已经是大顶堆。
  6. *
  7. * @param arr  待排序的数组
  8. * @param n    数组的大小，也是堆中元素的总数
  9. * @param i    当前需要堆化的子树的根节点索引
  10. */
  11. void heapify(std::vector<int>& arr, int n, int i) {
  12.     int largest = i;   
  13.     int left = 2 * i + 1;
  14.     int right = 2 * i + 2;
  16.     if (left < n && arr[left] > arr[largest]) largest = left;
  17.     if (right < n && arr[right] > arr[largest]) largest = right;
  18.     if (largest != i) {
  19.         std::swap(arr[i], arr[largest]);
  20.         heapify(arr, n, largest);
  21.     }
  22. }
  24. void maxHeap(std::vector<int>& arr) {
  25.     int n = arr.size();
  26.     for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i);
  27. }
  29. void heapSort(std::vector<int>& arr) {
  30.     int n = arr.size();
  31.     maxHeap(arr);
  32.     for (int i = n - 1; i > 0; i--) {
  33.         std::swap(arr[0], arr[i]);
  34.         heapify(arr, i, 0);
  35.     }
  36. }
复制代码
使用priority_heap容器适配器实现的堆排列
  1. void heapSortUsingPriorityQueue(std::vector<int>& arr) {
  2.     if (arr.empty()) {
  3.         return;
  4.     }
  6.     // 1. 创建一个最大堆（默认行为）
  7.     // 将数组中的所有元素放入优先队列
  8.     std::priority_queue<int> max_heap;
  9.     for (int val : arr) {
  10.         max_heap.push(val);
  11.     }
  13.     // 2. 依次取出最大元素，并存回原数组
  14.     // 此时元素是按从大到小的顺序被取出的
  15.     int index = 0;
  16.     while (!max_heap.empty()) {
  17.         arr[index] = max_heap.top(); // 获取最大值
  18.         max_heap.pop();              // 从堆中移除
  19.         index++;
  20.     }
  22.     // 3. 因为得到的是降序序列，需要反转数组才能得到升序结果
  23.     std::reverse(arr.begin(), arr.end());
  24. }
复制代码
5. 插入排序
  1. // 从第二个数开始往前插入数，前面部分是排序好的，假如有n=5个数据，第一次插入a[1]，第4次插入a[4]。
  2. // 所以外循环n-1次，从index=1开始。从j = i - 1依次向左比较，直到比较到最低位或者小于key的数。
  3. // 两个关键点，i是需要插入的索引key=arr[i]，i左边也就是j=i-1是排序好的节点，然后向左比对，当arr[j]<key时，arr[j+1]=key。
  4. void insertSort(vector<int>& arr) {
  5.     for (int i = 0; i < arr.size(); ++i){
  6.         // i=2插入到前面排序好的数组，跟前面的一一比较
  7.         int key = arr[i];
  8.         int j = i-1;
  9.         while (j >= 0 && arr[j] > key) {
  10.             arr[j + 1] = arr[j];
  11.             j--;
  12.         }
  13.         arr[j + 1] = key;
  14.     }
  15. }
复制代码
6. 选择排序
  1. // 选择排序函数（升序）
  2. // 遍历数组，第一遍找出最小的放到第一个位置，第二遍从[1]开始，找出最小的，以此类推
  3. void selectionSort(std::vector<int>& arr) {
  4.     int n = arr.size();
  6.     for (int i = 0; i < n - 1; ++i) {
  7.         int minIndex = i;
  8.         for (int j = i + 1; j < n; ++j) {
  9.             if (arr[j] < arr[minIndex]) minIndex = j;
  10.         }
  12.         if (minIndex != i) swap(arr[i], arr[minIndex]);
  13.     }
  14. }
复制代码
四、数组

二分查找法
  1. int searchInsert(vector<int>& nums, int target) {
  2.     int left = 0;
  3.     int right = nums.size() - 1;
  5.     while (left <= right) {
  6.         int mid = left + (right - left)/2;
  7.         if (nums[mid] == target) return mid;
  8.         else if (nums[mid] < target) left = mid + 1;
  9.         else right = mid - 1;
  10.     }
  11.     return left;
  12. }
复制代码
  1. void mucpy(char *s1, char *s2) {
  2.     while(*s1++ = *s2++);
  3. }
复制代码
[code]#include #include #include #include using namespace std;// 图的邻接表表示vector graph = {    {1, 2},     // 0    {0, 3, 4},  // 1    {0, 4},     // 2    {1},        // 3    {1, 2}      // 4};vector visited(5, false); // 记录节点是否被访问过// 深度优先搜索（DFS）- 递归实现void dfs(int node) {    visited[node] = true;    cout
嵌入式面试常见一些编程

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
普料飕
昨天 23:55

0

粉丝关注

21

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫