笔试常考代码段记录

已于 2023-07-26 10:30:42 修改
阅读量221 收藏 5
点赞数 4
文章标签： 笔记 排序算法 数据结构 算法 单片机
于 2023-07-11 15:14:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56646002/article/details/131615212
版权

前言

本文记录了一些常见、常考的代码段。

1：将字符串转成数字（atoi实现）

int myint(char *str){
    int ret = 0;
    if(str == NULL){
        return 0;
    }

    while(*str != '\0'){
        ret = ret * 10 + (*str - '0');
        str++;
    }
    return ret;
}

2：将数字转成字符串（sprintf实现）

void reverse(char *str){
    int low = 0;
    int fast = strlen(str) - 1;
    while(low < fast){
        char temp = str[low];
        str[low] = str[fast];
        str[fast] = temp;
        low++;
        fast--;
    }
}

void mystr(int num, char *buf){
    char *head = buf;
    int cnt = 0;
    while(num){
        buf[cnt++] = num % 10 + '0';
        num /= 10;
    }
    reverse(head);
}

3：顺序查找

int seqSearch(int num[], int length, int target){
    int i = 0;
    for(i = 0; i < length && num[i] != target; i++);
    return i == length ? -1 : i;
}

4：二分法实现有序数组数据查找，不在数组内的目标，返回应放入数组的位置

int binarySearch(int num[], int length, int target){
    int low = 0, high = length - 1, mid, ret;
    while(low <= high){
        mid = (low + high) / 2;
        if(num[mid] >= target){
            high = mid - 1;
            ret = mid;
        }
        else{
            low = mid + 1;
        }
    }
    return ret;
}

5：冒泡排序

它通过不断比较相邻的元素，并交换位置，使得较大（或较小）的元素逐渐移动到序列的一端

void swap(int *a, int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}

void bubbleSort(int num[], int length){
    int i, j, flag = 0;
    for(i = 0; i < length - 1; i++){
        for(j = length - 1; j > i; j--){
            if(num[j] < num[j - 1]){
                swap(&num[j], &num[j - 1]);
                flag = 1;
            }
        }
        if(flag == 0){
            return;
        }
    }
}

6：快速排序

首先，选择一个基准元素（一般选择序列中的第一个元素），将序列分为两部分，使得左边的元素都小于基准元素，右边的元素都大于基准元素；然后递归地对左右两部分进行排序，直到整个序列排序完成。

int partition(int num[], int low, int high){
    int pivot = num[low];
    while(low < high){
        while(low < high && num[high] >= pivot) high--;
        num[low] = num[high];
        while(low < high && num[low] <= pivot) low++;
        num[high] = num[low];
    }
    num[low] = pivot;
    return low;
}

void quickSort(int num[], int low, int high){
    int pivotPos = 0;
    if(low < high){
        pivotPos = partition(num, low, high);
        quickSort(num, low, pivotPos - 1);
        quickSort(num, pivotPos + 1, high);
    }
}

7：插入排序

直接插入排序（Straight Insertion Sort）： 直接插入排序的思想是将待排序序列分为已排序和未排序两部分，初始时已排序部分只包含第一个元素。然后，依次从未排序部分取出一个元素，插入到已排序部分的适当位置，直到未排序部分为空。

void insertSort(int num[], int length){
    int i, j, temp;
    for(i = 1; i < length; i++){
        temp = num[i];
        for(j = i - 1; j >= 0 && num[j] > temp; j--){
            num[j + 1] = num[j];
        }
        num[j + 1] = temp;
    }
}

8：希尔排序

希尔排序（Shell Sort）： 希尔排序是插入排序的一种改进算法，也被称为缩小增量排序。它通过将待排序序列按照一定增量分组，对每个组进行直接插入排序，然后逐渐减小增量，最终将整个序列排序完成。

void shellSort(int num[], int length){
    int i, j, temp, gap;
    for(gap = length / 2; gap > 0; gap /= 2){
        for(i = gap; i < length; i++){
            temp = num[i];
            for(j = i - gap; j >= 0 && num[j] > temp; j -= gap){
                num[j + gap] = num[j];
            }
            num[j + gap] = temp;
        }
    }
}

9：简单选择排序

它的基本思想是每次从待排序序列中选择最小（或最大）的元素，将其放置在已排序序列的末尾

void swap(int *a, int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}
void selectSort(int num[], int len){
    int i, j, min;
    for(i = 0; i < len; i++){
        min = i;
        for(j = i + 1; j < len; j++){
            if(num[j] < num[min]){
                min = j;
            }
        }
        if(min != i){
            swap(&num[i], &num[min]);
        }
    }
}

10：堆排序

  1. 构建最大堆：将待排序的数据构建成一个最大堆。最大堆是一种完全二叉树，满足父节点的值大于或等于其子节点的值。通过从最后一个非叶子节点开始，自底向上地对每个非叶子节点进行下沉操作，使得整个树满足最大堆的条件。

  2. 排序：将最大堆的根节点（即最大值）与最后一个叶子节点交换，并将最后一个叶子节点移出堆。然后再对剩余的节点进行下沉操作，重新满足最大堆的条件。重复这个过程，直到堆中只剩下一个节点。

  3. 重复执行步骤2，直到所有的元素都被排序。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int arr[6] = {-1, 8, 54, 13, 23, 2};

void swap(int *a, int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}

void heapAdjust(int num[], int k, int length){
    num[0] = num[k];
    for(int i = 2 * k; i<= length; i *= 2){
        if(i < length && num[i] < num[i + 1]){
            i++;
        }
        if(num[0] > num[i]){
            break;
        }
        else{
            num[k] = num[i];
            k = i;
        }
    }
    num[k] = num[0];
}

void heapSort(int num[], int length){
    for(int i = length / 2; i > 0; i--){
        heapAdjust(num, i, length);
    }
    for(int i = length; i > 1; i--){
        swap(&num[i], &num[1]);
        heapAdjust(num, 1, i - 1);
    }
}
void printfArr(int arr[], int length){
    for(int i = 0; i < length; i++){
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main()
{
    heapSort(arr, 5);
    printfArr(arr + 1, 5);
}

11：软件模拟IIC时序

通用iic文件

#include "iic.h"


void iic_start(void){
   IIC_SDA = 1;
   delay_10us(1);
   IIC_SCL = 1;
   delay_10us(1);
   IIC_SDA = 0;
   delay_10us(1);
   IIC_SCL = 0;
   delay_10us(1);
}

void iic_stop(void){
   IIC_SDA = 0;
   delay_10us(1);
   IIC_SCL = 1;
   delay_10us(1);
   IIC_SDA = 1;
   delay_10us(1);
}

void iic_ack(void){
   IIC_SCL = 0;
   IIC_SDA = 0;
   delay_10us(1);
   IIC_SCL = 1;
   delay_10us(1);
   IIC_SCL = 0;
   delay_10us(1);
}

void iic_nack(void){
   IIC_SCL = 0;
   IIC_SDA = 1;
   delay_10us(1);
   IIC_SCL = 1;
   delay_10us(1);
   IIC_SCL = 0;
   delay_10us(1);

}

u8 iic_wait_ack(void){
   u8 time_cnt = 0;
   IIC_SCL = 0;
   delay_10us(1);
   IIC_SCL = 1;
   delay_10us(1);
   while(IIC_SDA){
      time_cnt++;
      if(time_cnt > 100){
         return 1;
      }
   }
   IIC_SCL = 0;
   delay_10us(1);
   return 0;

}
void iic_write_byte(u8 dat){
   u8 i = 0;
   IIC_SCL = 0;
   for(i = 0; i < 8; i++){
      if((dat & 0x80)){
         IIC_SDA = 1;
      }
      else{
         IIC_SDA = 0;
      }
      dat <<= 1;
      delay_10us(1);
      IIC_SCL = 1;
      delay_10us(1);
      IIC_SCL = 0;
      delay_10us(1);
   }

}

u8 iic_read_byte(u8 ack){
   u8 i = 0, ret = 0;
   for(i = 0; i < 8; i++){
      IIC_SCL = 0;
      delay_10us(1);
      IIC_SCL = 1;
      ret <<= 1;
      if(IIC_SDA){
         ret++;
      }
      delay_10us(1);
   }
   
   if(ack){
      iic_ack();
   }
   else{
      iic_nack();
   }
   return ret;
}

读写at24c02

#include "24c02.h"
#include "iic.h"


void at24c02_write_one_byte(u8 addr, u8 dat){
   iic_start();
   iic_write_byte(0xA0);
   iic_wait_ack();
   iic_write_byte(addr);
   iic_wait_ack();
   iic_write_byte(dat);
   iic_wait_ack();
   iic_stop();
   delay_ms(10);
}

u8 at24c02_read_one_byte(u8 addr){
   u8 ret = 0;
   iic_start();
   iic_write_byte(0xA0);
   iic_wait_ack();
   iic_write_byte(addr);
   iic_wait_ack();
   iic_write_byte(0xA1);
   iic_wait_ack();
   ret = iic_read_byte(1);
   iic_stop();
   return ret;

}

12：va_list相关用法（可变参）

#include <stdio.h>
#include <stdarg.h>

void printNumbers(int count, ...) {
    va_list args;
    va_start(args, count);

    for (int i = 0; i < count; i++) {
        int num = va_arg(args, int);
        printf("%d ", num);
    }
    printf("\n");
    va_end(args);
}

void myprintf(char *fmt, ...){
    va_list args;
    va_start(args, fmt);
    char buf[512];
    vsprintf(buf, fmt, args);
    puts(buf);
    va_end(args);
}

int main() {
    printNumbers(4, 123, 13,42, 234);
    myprintf("%d\n", 24);
    return 0;
}

glibc中printf和scanf函数原型也用到了va_list相关内容

int
printf (const char *format, ...)
{
  va_list arg;
  int done;

  va_start (arg, format);
  done = vfprintf (stdout, format, arg);
  va_end (arg);

  return done;
}

int
scanf (const char *format, ...)
{
  va_list arg;
  int done;

  va_start (arg, format);
  done = INTUSE(_IO_vfscanf) (stdin, format, arg, NULL);
  va_end (arg);

  return done;
}

13：字符串匹配算法（BF、KMP） 

BF算法，默认字符串下标从0开始

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int BF(char* text, char* pattern){
    int i = 0;
    int j = 0;
    int tLen = strlen(text), pLen = strlen(pattern);
    while(i < tLen && j < pLen){
        if(text[i] == pattern[j]){
            i++;
            j++;
        }
        else{
            i = i - j + 1;
            j = 0;
        }
    }
    if(j == pLen){
        return i - j;
    }
    else{
        return -1;
    }
}


int main()
{
    char text[] = "ASDIKOAMD";
    char pattern[] = "AMD";
    int pos = BF(text, pattern);
    char* temp = strstr(text, pattern);
    printf("%c\n", *temp);
    printf("%d\n", pos);
    return 0;
}

KMP算法

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// 计算模式串的next数组
void getNext(char* pattern, int* next) {
    int i = 0;  // i为模式串中当前字符的位置
    int j = -1; // j为已匹配的前缀子串的最后一个字符位置
    int len = strlen(pattern);
    next[0] = -1;

    while (i < len) {
        if (j == -1 || pattern[i] == pattern[j]) {
            // 如果j为-1，或当前字符与已匹配的前缀子串的最后一个字符相等
            i++;
            j++;
            next[i] = j;
        } else {
            // 否则，将j指向已匹配的前缀子串的最后一个字符的next值，继续匹配
            j = next[j];
        }
    }
}

// 使用KMP算法进行匹配
int KMP(char* text, char* pattern) {
    int tLen = strlen(text);
    int pLen = strlen(pattern);

    int* next = (int*)malloc(sizeof(int) * (pLen + 1));
    getNext(pattern, next);

    int i = 0;  // i为文本串的当前字符的位置
    int j = 0;  // j为模式串的当前字符的位置

    while (i < tLen && j < pLen) {
        if (j == -1 || text[i] == pattern[j]) {
            // 如果j为-1，或当前字符与模式串的当前字符相等
            i++;
            j++;
        } else {
            // 否则，将j指向模式串中当前字符的next值，继续匹配
            j = next[j];
        }
    }

    free(next);

    if (j == pLen) {
        // 完全匹配，返回在文本串中匹配的起始位置
        return i - j;
    } else {
        // 未找到匹配，返回-1
        return -1;
    }
}

int main() {
    char text[] = "ABABABA";
    char pattern[] = "BAB";
    int pos = KMP(text, pattern);

    if (pos != -1) {
        printf("Pattern found at position: %d\n", pos);
    } else {
        printf("Pattern not found\n");
    }

    return 0;
}

14：将MAC地址转成数组元素

例如MAC = "11:22:33:44:55:66"，将字符串中的数据截取出来放到数组中mac中，即mac[6] = {0x11,0x22,0x33,0x44,0x55,0x66}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int mac[6];
int strToHex(char* str){
    int ret = 0;
    while(*str != '\0'){
        if(*str >= '0' && *str <= '9'){
            ret = ret * 16 + (*str - '0');
            str++;
        }
        else if(*str >= 'a' && *str <= 'f'){
            ret = ret * 16 + (*str - 87);
            str++;
        }
        else if(*str >= 'A' && *str <= 'F'){
            ret = ret * 16 + (*str - 55);
            str++;
        }
    }
    return ret;
}

void macToHex(char* str){
    char temp[3] = {0};
    int cnt = 0;
    while(*str != '\0'){
        if(*str == ':'){
            memcpy(temp, str - 2, 2);
            temp[2] = '\0';
            mac[cnt++] = strToHex(temp);
            str++;
            memset(temp, 0x0, 2);
        }
        str++;
    }
    memcpy(temp, str - 2, 2);
    temp[2] = '\0';
    mac[cnt++] = strToHex(temp);
}

int main()
{
    macToHex("1a:22:3B:44:ff:2d");
    for(int i = 0; i < 6; i++){
        printf("%#X ", mac[i]);
    }

    printf("\n");
    return 0;
}

总结

以上就是本文的全部内容了，希望可以帮助到你

门牙会稍息
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
【网络入门】详解常用的基础网络知识（面试笔试常考内容）
dvlinker的技术专栏
04-26 6万+
本文结合多年来的工作实践，来详细讲述一下作为IT从业人员要掌握的一些基础网络知识。
2022年计算机等级考试四级笔试试试卷数据库工程师.doc
11-19
类图则用于表示类、接口和它们之间的关系，而组件图用于表示系统的实现层面，如源代码、可执行程序等。 11. **分布式数据库分布策略**：数据分配是对数据在节点间分配的操作，而数据分片则是将数据切分成片段。全...
Java基础——Java笔试常考题型（难度高）
Joshua Lee的博客
12-26 6272
1、作用域public,private,protected,以及不写时的区别答：区别如下，不写时默认缺省 作用域 同一类 同一包 不同包的子类 所有类 public ✔ ✔ ✔ ✔ protected ✔ ✔ ✔ × 缺省 ✔ ✔ × × private ✔ × × ...
前端笔试常考设计模式，操作系统，数据结构，ACM模板，经典算法，正则表达式，常用方法
luemeon的博客
03-29 5571
考试时允许使用草稿纸，请提前准备纸笔。考试过程中允许上厕所等短暂离开，但请控制离开时间笔试得分60%一般通过，面试答对80%才能通过。
2023届求职 笔试面试记录
meFranky的博客
07-07 1136
记录笔试、面试
java高级工程师 考试_JAVA高级工程师笔试题及答案
weixin_30716641的博客
02-13 1135
JAVA高级工程师笔试题及答案Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。下面是小编收集的JAVA高级工程师笔试题及答案，欢迎大家参考!1.abstractclass和interface的区别?抽象类可以有私有方法和变量，接口中不能有私有方法和变量。抽象类可以有方法的实现，接口中不能有方法的实现并且所以的方法都需要实现。2.try{}里有一个return语句，那...
计算机二级access笔试常考.pdf
10-11
【计算机二级Access笔试常考知识点】 1. **删除查询**：在Access中，删除查询用于删除整个记录，而不是仅删除指定字段中的记录。这涉及到数据库的完整性，因为删除操作不可逆，所以需谨慎使用。 2. **关系运算**：...
3月计算机等级考试二级C++笔试试题及答案.pdf
07-14
8. **关系数据库中的数据单位**：在学生管理的关系数据库中，记录是存取一个学生信息的数据单位，包含多个字段，如学号、姓名、成绩等。 9. **数据库设计阶段**：用E-R图描述信息结构而不涉及计算机表示，这属于...
2008年4月全国计算机等级考试二级VB笔试试卷.doc
11-16
10. **关系数据库键**：表SC的关键字（键或码）是**学号，课号** (C)，用于唯一标识每一条选课记录。 11. **Visual Basic知识点**： - 标准模块文件的扩展名是**.bas** (A)； - 标准模块文件是纯代码文件 (B)； ...
谷粒商城实战笔记-38-前端基础-Vue-指令-单向绑定&双向绑定
epitomizelu的专栏
07-20 1016
安全性v-text更安全，因为它总是将数据作为纯文本插入，不解析 HTML。v-html则可能引发安全问题，因为它会解析并渲染 HTML 标签。用途v-text适用于插入文本数据，而v-html适用于插入需要被解析为实际 HTML 的数据。处理 HTML 标签v-text忽略 HTML 标签，将其视为普通文本；v-html则会解析并显示 HTML 标签。二者都是单向绑定，元素绑定model，model不绑定元素，元素值改变时model值不会更新。
deepseek-vl 论文阅读笔记
samoyan的博客,记录技术成长~
07-22 1083
我们的语言模型基于DeepSeek LLM（DeepSeek-AI，2024），其微设计大体遵循LLaMA（Touvron等，2023a,b）的设计，采用带有RMSNorm（Zhang和Sennrich，2019）函数的Pre-Norm结构，并使用SwiGLU（Shazeer，2020）作为前馈网络（FFN）的激活函数，中间层维度为8/3模型维度。此外，我们引入了一种新的“模态预热”策略。为了促进创新并支持广泛的应用需求，我们公开了两个版本的模型，分别为1.3B和7B，以满足不同计算能力的需求。
HTML学习笔记[Web开发]
Jenlibein的博客
07-19 1002
本文为学习笔记，参考w3c，菜鸟，Mozilla，尚硅谷等文章编写。
ZYNQ 入门笔记（零）：概述
记录代码与生活
07-21 769
作为 AMD Xilinx SoC 的重要组成部分之一，Zynq 系列在视频编码、网络加速、射频信号处理等领域占据重要地位，其将 ARM 硬核 (PS) 与可编程逻辑 (PL) 集成在一块芯片内部，在提升系统整体性能的同时简化了设计流程。然而，初次接触 Zynq 的开发者可能会面临诸多困难，如工具链、开发流程、Block Design、AXI 总线、PS & PL 交互、联合调试等。笔者在此将学习过程中的笔记加以整理，希望能帮助大家快速入门 Zynq，体会软硬件联合开发的乐趣
OpenGL笔记十四之GLM数学库的配置与使用
小勇博客
07-20 398
— 2024-07-20 中午。
JavaScript对象学习笔记[Web开发]
Jenlibein的博客
07-19 892
JavaScript对象本文为学习笔记，参考Javascript.info，菜鸟等文章编写。
谷粒商城实战笔记-39-前端基础-Vue-指令-v-on、v-for、v-if
epitomizelu的专栏
07-20 1004
v-on 是 Vue.js 中的一个指令，用于在 DOM 元素上监听用户事件，并在事件触发时执行相应的 JavaScript 函数。它提供了一种将 Vue 实例中的方法与 DOM 事件关联起来的方式，使得你可以轻松地对用户交互做出响应。v-on 指令的基本语法是在元素上添加 v-on:event-name=“method”，其中 event-name 是你要监听的 DOM 事件类型（如 click、mouseover、keydown 等），method 则是 Vue 实例中定义的方法名。
江科大/江协科技 STM32学习笔记P6
sususu_2001的博客
07-19 355
AHB(Advanced High-performance Bus), 高速总线，用来接高速外设的。APB (Advanced Peripheral Bus) 低速总线，用来接低速外设的。APB2一般是和AHB同频率，都是72MHz，APB1一般是36MHz。APB2连接的一般是外设中稍微重要的部分，比如GPIO端口，还有一些外设的一号，比如USART1、SPI1、TIM1、TIM8，还接ADC、EXTI、AFIO。其他的2、3、4…外设和DAC、PWR、BKP等次要点的外设都放到APB1。
【Blockly图形化积木编程二次开发学习笔记】5.自动保存与恢复
乙酸氧铍的博客
07-21 203
/ 用户离开页面时自动将块备份到本地存储中。关闭后再次打开，工作区仍存在。// 从本地存储中恢复块。
SAP PP学习笔记31 - 计划运行的步骤2 - Scheduling(日程计算)，BOM Explosion(BOM展开）
最新发布
shi_ly的专栏
07-24 485
本章主要讲Scheduling(日程计算),其中包括 外部调达中的调度，生产订单中的调度，修改需求日期(其实就是在物料中增加安全时间和BOM中的提前期偏置量)。另外还讲了BOM展开的内容，详细讲了BOM选择的各种方法，除了按数量选BOM之外，还有其他比如 按日期，按生产版本等，而其中按日期又分为按订单开始日期，订单终了日期等，越趋复杂。
2011年计算机二级C语言考试重点解析
"这份资源是2011年9月全国计算机等级考试二级C语言笔试的复习课件，包含了选择题、程序设计等相关知识点。" 本文将详细解析这些题目所涉及的计算机科学基础概念和C语言知识。 1. 算法与程序：题目指出算法不是简单...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

门牙会稍息

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

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

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

打赏作者

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

抵扣说明：

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

余额充值