嵌入式开发高频面试题——第四章 常见算法(上)

目录

      • [4.1 排序算法](#4.1 排序算法)
        • [4.1.1 **各种排序算法的时间空间复杂度、稳定性** ⭐⭐⭐⭐⭐](#4.1.1 各种排序算法的时间空间复杂度、稳定性 ⭐⭐⭐⭐⭐)
        • [4.1.2 **各种排序算法什么时候有最好情况、最坏情况(尤其是快排)** ⭐⭐⭐⭐](#4.1.2 各种排序算法什么时候有最好情况、最坏情况(尤其是快排) ⭐⭐⭐⭐)
      • [4.1.3 **冒泡排序** ⭐⭐⭐⭐](#4.1.3 冒泡排序 ⭐⭐⭐⭐)
      • [4.1.4 **选择排序** ⭐⭐⭐⭐](#4.1.4 选择排序 ⭐⭐⭐⭐)
      • [4.1.5 **插入排序** ⭐⭐⭐⭐](#4.1.5 插入排序 ⭐⭐⭐⭐)
      • [4.1.6 **希尔排序** ⭐⭐⭐⭐](#4.1.6 希尔排序 ⭐⭐⭐⭐)
      • [4.1.7 **归并排序** ⭐⭐⭐⭐](#4.1.7 归并排序 ⭐⭐⭐⭐)
      • [4.1.8 **快速排序** ⭐⭐⭐⭐⭐](#4.1.8 快速排序 ⭐⭐⭐⭐⭐)
      • [4.1.9 **快排的 partition 函数与归并的 Merge 函数** ⭐⭐⭐](#4.1.9 快排的 partition 函数与归并的 Merge 函数 ⭐⭐⭐)

4.1 排序算法

4.1.1 各种排序算法的时间空间复杂度、稳定性 ⭐⭐⭐⭐⭐
排序算法 平均时间复杂度 最好情况时间复杂度 最坏情况时间复杂度 空间复杂度 稳定性
冒泡排序 O(n^2) O(n) O(n^2) O(1) 稳定
选择排序 O(n^2) O(n^2) O(n^2) O(1) 不稳定
插入排序 O(n^2) O(n) O(n^2) O(1) 稳定
希尔排序 O(n log n) O(n log^2 n) O(n^2) O(1) 不稳定
归并排序 O(n log n) O(n log n) O(n log n) O(n) 稳定
快速排序 O(n log n) O(n log n) O(n^2) O(log n) 不稳定
  • 稳定性:指的是如果两个元素相等,它们在排序前后的相对位置是否保持不变。
  • 时间复杂度:算法执行所需的时间,通常表示为最坏、平均和最好情况。
  • 空间复杂度:算法执行时所需的额外存储空间。
4.1.2 各种排序算法什么时候有最好情况、最坏情况(尤其是快排) ⭐⭐⭐⭐
  • 冒泡排序

    • 最好情况:数组已经有序,时间复杂度为 O(n)。
    • 最坏情况:数组逆序,时间复杂度为 O(n^2)。
  • 选择排序

    • 无论数组是否有序,最好和最坏情况的时间复杂度都是 O(n^2)。
  • 插入排序

    • 最好情况:数组已经有序,时间复杂度为 O(n)。
    • 最坏情况:数组逆序,时间复杂度为 O(n^2)。
  • 希尔排序

    • 最好情况:数组基本有序,时间复杂度接近 O(n log n)。
    • 最坏情况:数组完全无序,时间复杂度为 O(n^2)。
  • 归并排序

    • 最好和最坏情况的时间复杂度都是 O(n log n),因为归并排序是分治算法,分割和合并的过程都不会依赖于数据的顺序。
  • 快速排序

    • 最好情况:每次分割点恰好是数组的中位数,时间复杂度为 O(n log n)。
    • 最坏情况:每次分割点总是选择最大或最小值,时间复杂度为 O(n^2)(通常在数组几乎有序或完全无序时发生)。改进方式是使用随机化或三数取中。

4.1.3 冒泡排序 ⭐⭐⭐⭐

cpp 复制代码
void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        bool swapped = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
                swapped = true;
            }
        }
        if (!swapped)
            break;
    }
}

4.1.4 选择排序 ⭐⭐⭐⭐

cpp 复制代码
void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex])
                minIndex = j;
        }
        std::swap(arr[i], arr[minIndex]);
    }
}

4.1.5 插入排序 ⭐⭐⭐⭐

cpp 复制代码
void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

4.1.6 希尔排序 ⭐⭐⭐⭐

cpp 复制代码
void shellSort(int arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}

4.1.7 归并排序 ⭐⭐⭐⭐

cpp 复制代码
void merge(int arr[], int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;
    int L[n1], R[n2];

    for (int i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (int i = 0; i < n2; i++)
        R[i] = arr[mid + 1 + i];

    int i = 0, j = 0, k = left;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j])
            arr[k++] = L[i++];
        else
            arr[k++] = R[j++];
    }

    while (i < n1)
        arr[k++] = L[i++];
    while (j < n2)
        arr[k++] = R[j++];
}

void mergeSort(int arr[], int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}

4.1.8 快速排序 ⭐⭐⭐⭐⭐

cpp 复制代码
int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[i + 1], arr[high]);
    return (i + 1);
}

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

4.1.9 快排的 partition 函数与归并的 Merge 函数 ⭐⭐⭐

  • Partition 函数(用于快速排序):

    • 用来确定一个枢轴(pivot),将数组划分为两部分,使得枢轴左边的元素小于枢轴,右边的元素大于枢轴。
    • 快排基于分治思想,利用递归将划分后的部分继续排序。
  • Merge 函数(用于归并排序):

    • 用来合并两个已经排序的数组,形成一个有序数组。
    • 归并排序的分治过程首先对数组分割,然后通过Merge函数逐步将有序的子数组合并成最终的有序数组。
相关推荐
小码农<^_^>29 分钟前
优选算法精品课--滑动窗口算法(一)
算法
羊小猪~~31 分钟前
神经网络基础--什么是正向传播??什么是方向传播??
人工智能·pytorch·python·深度学习·神经网络·算法·机器学习
软工菜鸡1 小时前
预训练语言模型BERT——PaddleNLP中的预训练模型
大数据·人工智能·深度学习·算法·语言模型·自然语言处理·bert
南宫生1 小时前
贪心算法习题其三【力扣】【算法学习day.20】
java·数据结构·学习·算法·leetcode·贪心算法
AI视觉网奇1 小时前
sklearn 安装使用笔记
人工智能·算法·sklearn
JingHongB2 小时前
代码随想录算法训练营Day55 | 图论理论基础、深度优先搜索理论基础、卡玛网 98.所有可达路径、797. 所有可能的路径、广度优先搜索理论基础
算法·深度优先·图论
weixin_432702262 小时前
代码随想录算法训练营第五十五天|图论理论基础
数据结构·python·算法·深度优先·图论
小冉在学习2 小时前
day52 图论章节刷题Part04(110.字符串接龙、105.有向图的完全可达性、106.岛屿的周长 )
算法·深度优先·图论
Repeat7152 小时前
图论基础--孤岛系列
算法·深度优先·广度优先·图论基础
小冉在学习2 小时前
day53 图论章节刷题Part05(并查集理论基础、寻找存在的路径)
java·算法·图论