C语言经典排序算法的完整代码

排序

1.插入排序

1.1直接插入排序

int insertSort(int array[],int n){
    int i , j;
    int tempNum;
    for(i = 1; i < n;i++){
        tempNum = array[i];
        for(j = i - 1; j >= 0 && tempNum < array[j];j--){
            array[j + 1] = array[j];
        }
        array[j + 1] = tempNum;
    }
    return 1;
}

最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(n)	O(n²)	O(n²)	O(1)	稳定

• 最好情况：元素有序
• 最坏情况：元素逆序

1.2折半插入排序

void InsertSort(int array[],int n){
	int i, j, tempNum;
	int high ,mid ,low;
	for(i = 1; i < n; i++){
		tempNum = array[i];
		low = 0;
		high = i - 1;
		while(low <= high){
			mid = (low + high) / 2;
			if(array[mid] > tempNum)
				high = mid - 1;
			else
				low = mid + 1;
		}
		for(j = i - 1; j >= high + 1; j--){
			array[j + 1] = array[j];
		}
		array[high + 1] = tempNum;
	}
}

• 时间复杂度O(n²)
• 稳定性：稳定

1.3希尔排序

祥哥的说讲解

int shellSort(int array[],int n){
    int gap,j;
    for(gap = n / 2; gap > 0;gap /= 2){
        for(j = gap;j < n;j++){
            insertShellSort(array,gap,j);
        }
    }
    return 1;
}
int insertShellSort(int array[],int gap,int i){
    int j;
    int insertNum = array[i];
    for(j = i - gap; j>= 0 && insertNum < array[j];j -= gap){
        array[j + gap] = array[j];
    }
    array[j+ gap] = insertNum;
    return 1;
}

最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(n)	O(n^1.3)	O(n²)	O(1)	不稳定

2.交换排序

2.1冒泡排序

int BubbleSrot(int array[],int n){
    int i, j;
    int temp;
    for(i = 0; i < n - 1; i++){
        for(j = n - 1; j > i; j--){
            if(array[j] < array[j - 1]){
                temp = array[j];
                array[j] = array[j - 1];
                array[j - 1] = temp;
            }
        }
    }
    return 1;
}

最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(n)	O(n²)	O(n²)	O(1)	稳定

2.2快速排序

int QuickSort(int array[],int low,int high){
    int mid;
    if(low < high){
        mid = Partition(array,low,high);
        QuickSort(array,low,mid - 1);
        QuickSort(array,mid + 1,high);
    }
    return 1;
}
int Partition(int array[],int low ,int high){
    int key = array[low];
    while(low < high){
        while(array[high] >= key && high > low){
            high--;
        }
        array[low] = array[high];
        while(array[low] <= key && high > low){
            low++;
        }
        array[high] = array[low];
    }
    array[low] = key;
    return low;
}

最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(nlogn)	O(nlogn)	O(n²)	O(logn)	不稳定

3.选择排序

3.1简单选择

int SelectSort(int array[],int n){
    int i, j, min;
    int temp;
    for(i = 0; i < n - 1; i++){
        min = i;
        for(j = i + 1; j < n; j++){
            if(array[j] < array[min]){
                k = j;
            }
        }
        if(min != i){
         temp = array[min];
         array[min] = array[i];
         array[i] = temp;
        }
    }
    return 1;
}

最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(n²)	O(n²)	O(n²)	O(1)	不稳定

3.2堆排序

大根堆排序算法

void HeapSort(int array[],int n){
	int i ,temp;
	BuildMaxHeap(array,n - 1);
	for(i = n ;i > 1; i--){
		temp = array[i];
		array[i] = array[1];
		arrry[1] = temp;
		HeadAdjust(array,1,i - 1);
	}
}

void BuildMaxHeap(int array[],int n){
	for(i = n / 2; i > 0;i--){
		HeadAdjust(array,i,len);
	}
}

void HeadAdjust(int array[],int i,int n){
	int j;
	array[0] = array[i];
	for(j = 2 * i; j <= n ; j *= 2){
		if(j < n && array[j] < array[j + 1]){
			j++;
		}
		if(array[0] >= array[j])
			break;
		else{
			array[i] = array[j];
			i = j;
		}
	}
	array[i] = array;
} 

最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定

4.归并排序和基数排序

4.1归并排序

doubleguy的讲解

int MergeSort(int array[],int start,int end){
    int mid = (end + start) / 2;
    if(start < end){
        MergeSort(array,start,mid);
        MergeSort(array,mid + 1,end);
        MergeArray(array,start,mid,end);
    }
    return 1;
}

int MergeArray(int array[],int start,int mid,int end){
    int i = start, j = mid + 1;
    int length = end - start + 1;
    int temp[length];
    int k = 0;
    while(i <= mid && j <= end){
        if(array[i] < array[j]){
            temp[k++] = array[i++];
        }else{
            temp[k++] = array[j++];
        }
    }
    while(i <= mid){
        temp[k++] = array[i++];
    }
    while(j <= end){
        temp[k++] = array[j++];
    }
    for(i = 0; i < k; i++){
        array[start++] = temp[i];
    }
    return 1;
}

最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定

4.2基数排序

基于关键字各位大小进行排序，通常采用链式基数排序
d为关键字位数，r为基数

最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(d(n+r))	O(d(n+r))	O(d(n+r))	O( r )	稳定

各种排序算法性质：

算法种类	最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
直接插入排序	O(n)	O(n²)	O(n²)	O(1)	稳定
希尔排序	O(n)	O(n^1.3)	O(n²)	O(1)	不稳定
冒泡排序	O(n)	O(n²)	O(n²)	O(1)	稳定
快速排序	O(nlogn)	O(nlogn)	O(n²)	O(logn)	不稳定
简单选择排序	O(n²)	O(n²)	O(n²)	O(1)	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定
基数排序（桶排序）	O(d(n+r))	O(d(n+r))	O(d(n+r))	O( r )	稳定