常见Linux嵌入式面试题--常见算法

1.各种排序算法的时间空间复杂度、稳定性

2.各种排序算法什么时候有最好情况、最坏情况（尤其是快排）

3.冒泡排序

4.选择排序

5.插入排序

6.希尔排序

7.归并排序

8.快速排序

9.二分法查找的原理

1. 各种排序算法的时间复杂度、空间复杂度和稳定性：

| 排序算法    | 时间复杂度（平均） | 空间复杂度 | 稳定性 |

| ----------- | ----------------- | ---------- | ------ |

| 冒泡排序    | O(n^2)            | O(1)       | 稳定   |

| 选择排序    | O(n^2)            | O(1)       | 不稳定 |

| 插入排序    | O(n^2)            | O(1)       | 稳定   |

| 希尔排序    | O(n log n)        | O(1)       | 不稳定 |

| 归并排序    | O(n log n)        | O(n)       | 稳定   |

| 快速排序    | O(n log n)        | O(log n)   | 不稳定 |

| 堆排序      | O(n log n)        | O(1)       | 不稳定 |

| 计数排序    | O(n + k)          | O(k)       | 稳定   |

| 桶排序      | O(n + k)          | O(n + k)   | 稳定   |

| 基数排序    | O(d(n + k))       | O(n + k)   | 稳定   |

其中，n 表示待排序元素的个数，k 表示元素的取值范围，d 表示元素的位数。

2. 各种排序算法的最好情况和最坏情况：

- 冒泡排序：

  - 最好情况：输入数组已经有序，时间复杂度为 O(n)。

  - 最坏情况：输入数组逆序，时间复杂度为 O(n^2)。

- 快速排序：

  - 最好情况：每次划分都能把数组均匀地分成两部分，时间复杂度为 O(n log n)。

  - 最坏情况：每次划分都只能将数组分成一个小部分和一个大部分，时间复杂度为 O(n^2)。

其他排序算法的最好情况和最坏情况可以参考相关文献或资料进行进一步了解。

3. 冒泡排序（Bubble Sort）是一种简单但效率较低的排序算法。它依次比较相邻的两个元素，如果顺序不正确则交换它们，直到整个序列有序为止。

void bubbleSort(int arr[], int n) {

    for (int i = 0; i < n - 1; ++i) {

        for (int j = 0; j < n - i - 1; ++j) {

            if (arr[j] > arr[j + 1]) {

                // 交换元素

                int temp = arr[j];

                arr[j] = arr[j + 1];

                arr[j + 1] = temp;

            }

        }

    }

}

4. 选择排序（Selection Sort）是一种简单直观的排序算法。它通过不断选择最小的元素放到已排序部分的末尾来完成排序。

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;

            }

        }

        // 交换元素

        int temp = arr[i];

        arr[i] = arr[minIndex];

        arr[minIndex] = temp;

    }

}

5. 插入排序（Insertion Sort）是一种简单且稳定的排序算法。它通过构建有序序列，对于未排序部分的每个元素，依次插入到已排序序列的合适位置。

void insertionSort(int arr[], int n) {

    int i, key, j;

    for (i = 1; i < n; i++) {

        key = arr[i];

        j = i - 1;

        while (j >= 0 && arr[j] > key) {

            arr[j + 1] = arr[j];

            j = j - 1;

        }

        arr[j + 1] = key;

    }

}

6. 希尔排序（Shell Sort）：

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;

        }

    }

}

7. 归并排序（Merge Sort）：

void merge(int arr[], int left, int mid, int right) {

    int i, j, k;

    int n1 = mid - left + 1;

    int n2 = right - mid;

    int L[n1], R[n2];

    for (i = 0; i < n1; i++)

        L[i] = arr[left + i];

    for (j = 0; j < n2; j++)

        R[j] = arr[mid + 1 + j];

    i = 0;

    j = 0;

    k = left;

    while (i < n1 && j < n2) {

        if (L[i] <= R[j]) {

            arr[k] = L[i];

            i++;

        } else {

            arr[k] = R[j];

            j++;

        }

        k++;

    }

    while (i < n1) {

        arr[k] = L[i];

        i++;

        k++;

    }

    while (j < n2) {

        arr[k] = R[j];

        j++;

        k++;

    }

}

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);

    }

}

8. 快速排序（Quick Sort）：

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++;

            int temp = arr[i];

            arr[i] = arr[j];

            arr[j] = temp;

        }

    }

    int temp = arr[i + 1];

    arr[i + 1] = arr[high];

    arr[high] = temp;

    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);

    }

}

9. 二分查找原理：

int binarySearch(int arr[], int low, int high, int target) {

    while (low <= high) {

        int mid = low + (high - low) / 2;

        if (arr[mid] == target)

            return mid;

        else if (arr[mid] < target)

            low = mid + 1;

        else

            high = mid - 1;

    }

    return -1;

}

以上是在 C 语言中定义的希尔排序、归并排序、快速排序和二分查找原理的函数示例。这些函数可以用于相应的排序和查找操作。一般使用冒泡法和快速排序法，对堆栈局域比较小的单片机来说冒泡法比较好，对时间要求苛刻的实时响应来说快速排序法好。