数据结构之排序算法

常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。

以下是C++代码示例：

1、冒泡排序
冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，每次比较相邻的两个元素，如果它们的顺序错误就交换它们的位置。

//冒泡排序 
//arr：待排序数组
//n：数组长度
//i：外层循环变量，表示已经排好序的元素个数
//j：内层循环变量，用于比较相邻元素并交换位置
//temp：用于交换两个元素的中间变量
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]);
}

2、选择排序

选择排序是一种简单直观的排序算法，它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

//选择排序
//arr：待排序数组
//n：数组长度
//i：外层循环变量，表示已经排好序的元素个数
//j：内层循环变量，用于查找最小元素
//min_idx：记录最小元素的下标
//temp：用于交换两个元素的中间变量

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

3、插入排序

插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入

//插入排序
//arr：待排序数组
//n：数组长度
//i：外层循环变量，表示当前要插入的元素下标
//j：内层循环变量，用于比较已排序元素并移动位置
//key：当前要插入的元素值
void insertionSort(int arr[], int n)
{
    int i, j, key;
    for (i = 1; i < n; i++)
    {
        key = arr[i];
        j = i - 1;
        while (j >= 0 && arr[j] > key)
        {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}

4、快速排序
快速排序是一种常用的排序算法，它采用分治法策略，将原问题分解成若干个规模较小但类似原问题的子问题，递归地求解这些子问题，然后将这些子问题的解组合成原问题的解。

//arr：待排序数组
//low：当前子数组的起始下标
//high：当前子数组的结束下标
//pivot：枢轴元素，用于划分子数组
//i：指向已处理区间的末尾下标
//j：指向未处理区间的起始下标
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);
    }
}

5、归并排序
归并排序是一种分治算法，它将原始数组分成两个子数组，递归地对这两个子数组进行归并排序，并将结果合并成一个有序数组。

//5 归并排序
//arr：待排序数组
//l：当前子数组的起始下标
//r：当前子数组的结束下标
//m：当前子数组的中间下标
//n1、n2：左右子数组的长度
//L[]、R[]：左右子数组
//i、j、k：左右子数组和合并后数组的下标
void merge(int arr[], int l, int m, int r)
{
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;

    int L[n1], R[n2];

    for (i = 0; i < n1; i++)
        L[i] = arr[l + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[m + 1 + j];

    i = 0;
    j = 0;
    k = l;

    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 l, int r)
{
    if (l < r)
    {
        int m = l + (r-l)/2;

        mergeSort(arr, l, m);
        mergeSort(arr, m+1, r);

        merge(arr, l, m, r);
    }
}