用C语言实现一维数组排列的6种方法

1.冒泡排序法：

冒泡排序是一种简单的排序方法，它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

法一：

#include<stdio.h>
int main()
{
    int a[10] = {3,1,5,7,2,4,9,6,10,8};
    int i,j,temp;
    printf("排序前：");
    for(i = 0;i < 10;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
    for(i = 0;i < 10;i++)
    {
        for(j = i + 1;j < 10;j++)
        {
            if(a[i] > a[j])
            {
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
    }
    printf("排序后：");
    for(i = 0;i < 10;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
    return 0;
}

法二：

#include <stdio.h>
int main()
{
    int a[10] = { 3,1,5,7,2,4,9,6,10,8 };
    int i, j, temp;
    int* p, * q;
    printf("排序前：");
    for (i = 0; i < 10; i++)
        printf("%d ", a[i]);
    printf("\n");
    for (i = 0; i < 10; i++)
    {
        p = &a[i];
        for (j = i + 1; j < 10; j++)
        {
            q = &a[j];
            if (*p > *q)
            {
                temp = *p;
                *p = *q;
                *q = temp;
            }
        }
    }
    printf("排序后：");
    for (i = 0; i < 10; i++)
        printf("%d ", a[i]);
    printf("\n");
    return 0;
}

2.选择排序法：

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

法一：

#include<stdio.h>

void selectSort(int a[], int n)
{
    int i, j, min, temp;
    for (i = 0; i < n - 1; i++)
    {
        min = i;
        for (j = i + 1; j < n; j++)
        {
            if (a[j] < a[min])
                min = j;
        }
        temp = a[i];
        a[i] = a[min];
        a[min] = temp;
    }
}

int main()
{
    int a[10] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
    int n = 10;
    selectSort(a, n);
    for (int i = 0; i < n; i++)
        printf("%d ", a[i]);
    printf("\n");
    return 0;
}

法二：

#include<stdio.h>

void selectSort(int* a, int n)
{
    int i, j, min, temp;
    for (i = 0; i < n - 1; i++)
    {
        min = i;
        for (j = i + 1; j < n; j++)
            if (a[j] < a[min])
                min = j;
        temp = a[i];
        a[i] = a[min];
        a[min] = temp;
    }
}

int main()
{
    int a[10] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
    int n = 10;
    selectSort(a, n);
    for (int i = 0; i < n; i++)
        printf("%d ", a[i]);
    printf("\n");
    return 0;
}

3.插入排序法：

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

#include <stdio.h>
#define N 10
 
int main()
{
    int a[N] = {3,1,5,7,2,4,9,6,10,8};
    int i,j,t;
    printf("排序前数组为：\n");
    for(i=0;i<N;i++)
        printf("%d ",a[i]);
    printf("\n");
    for(i=1;i<N;i++)
    {
        t = a[i];
        for(j=i;j>0 && a[j-1]>t;j--)
            a[j] = a[j-1];
        a[j] = t;
    }
    printf("排序后数组为：\n");
    for(i=0;i<N;i++)
        printf("%d ",a[i]);
    printf("\n");
    return 0;
}

4.快速排序法：

快速排序（Quick Sort）是一种快速的排序算法。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

#include <stdio.h>

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

int main()
{
    int arr[] = {9, 7, 4, 6, 5, 8, 1, 3, 2};
    int len = sizeof(arr) / sizeof(arr[0]);
    quick_sort(arr, 0, len - 1);
    for (int i = 0; i < len; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

5.希尔排序法：

希尔排序（Shell's Sort）是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。

#include <stdio.h>

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

int main()
{
    int arr[10] = { 10, 5, 2, 4, 7, 6, 8, 1, 9, 3 };
    int i;
    ShellSort(arr, 10);
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

6.归并排序法：

归并排序（Merge Sort）是一种分治算法。它将一个序列（list）每相邻两个数字进行归并操作，形成 floor(n/2)个序列，接着将两个序列进行归并操作，形成 floor(n/4)个序列，如此重复，直到最后只剩下一个序列。

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

void merge_sort(int* arr, int* reg, int start, int end)
{
	if (start >= end)
		return;
	int mid = (end - start) / 2 + start;
	merge_sort(arr, reg, start, mid);
	merge_sort(arr, reg, mid + 1, end);
	int k = start;
	int start1 = start, end1 = mid;
	int start2 = mid + 1, end2 = end;
	while (start1 <= end1 && start2 <= end2)
		reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
	while (start1 <= end1)
		reg[k++] = arr[start1++];
	while (start2 <= end2)
		reg[k++] = arr[start2++];
	for (k = start; k <= end; k++)
		arr[k] = reg[k];
}

int main()
{
	int n, i;
	scanf("%d", &n);
	int* arr = (int*)malloc(n * sizeof(int));
	int* reg = (int*)malloc(n * sizeof(int));
	for (i = 0; i < n; i++)
		scanf("%d", &arr[i]);
	merge_sort(arr, reg, 0, n - 1);
	for (i = 0; i < n; i++)
		printf("%d ", arr[i]);
	free(arr);
	free(reg);
	return 0;
}