c++ 数据结构，直接插入排序、冒泡排序、快速排序、简单选择排序

好的，我来为您介绍一下这些经典的排序算法：

1. 直接插入排序

直接插入排序是将未排序的元素逐一插入到已排好的序列中，使之成为一个有序序列。具体操作是，将当前元素插入到前面已排好序的序列中的适当位置。时间复杂度为O(n^2)。

2. 冒泡排序

冒泡排序是通过相邻元素的比较和交换来进行排序的。具体操作是，从最左边开始，比较相邻的两个元素，如果左边的元素大于右边的元素，则交换这两个元素。一轮比较完后，最大的元素被交换到了最右边。时间复杂度为O(n^2)。

3. 快速排序

快速排序是一种分治算法，通过将一个序列分成两个子序列来进行排序。具体操作是，选取一个基准元素，将序列中小于基准元素的元素放在基准元素的左边，大于基准元素的元素放在基准元素的右边，然后对左右子序列分别递归进行快速排序。时间复杂度为O(nlogn)。

4. 简单选择排序

简单选择排序是通过比较和交换来进行排序的。具体操作是，从未排序的序列中选择最小的元素，将其放在已排好序的序列的最右边，然后继续从未排序的序列中选择最小的元素，直到所有元素都排好序。时间复杂度为O(n^2)。

以上是这几种经典的排序算法，每种算法都有其优缺点和适用场景，需要根据具体情况进行选择。

相关问题

数据结构 c++ 代码实现直接插入排序、冒泡排序、快速排序、简单选择排序

好的，下面是这些排序算法的 C++ 代码实现：

1. 直接插入排序

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

2. 冒泡排序

void bubbleSort(int arr[], int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++) {
        for (j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

3. 快速排序

void quickSort(int arr[], int left, int right) {
    if (left >= right) {
        return;
    }
    int i, j, pivot, temp;
    i = left;
    j = right;
    pivot = arr[left];
    while (i < j) {
        while (i < j && arr[j] >= pivot) {
            j--;
        }
        while (i < j && arr[i] <= pivot) {
            i++;
        }
        if (i < j) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    arr[left] = arr[i];
    arr[i] = pivot;
    quickSort(arr, left, i - 1);
    quickSort(arr, i + 1, right);
}

4. 简单选择排序

void selectSort(int arr[], int len) {
    int i, j, minIndex, temp;
    for (i = 0; i < len - 1; i++) {
        minIndex = i;
        for (j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

以上是这些排序算法的 C++ 实现，您可以根据需要进行调用。

数据结构 c++ 代码实现一组数据通过直接插入排序、冒泡排序、快速排序、简单选择排序进行排序

好的，下面是这四种排序算法的 C++ 代码实现：

1. 直接插入排序

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

2. 冒泡排序

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]) {
                swap(arr[j], arr[j + 1]);
            }
        }
    }
}

3. 快速排序

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++;
            swap(arr[i], arr[j]);
        }
    }
    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. 简单选择排序

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        swap(arr[i], arr[min_idx]);
    }
}

以上就是这四种排序算法的 C++ 代码实现。