c语言数据结构各种排序方式以及代码实例

C语言中常用的排序算法有以下几种：

1. 冒泡排序
2. 选择排序
3. 插入排序
4. 希尔排序
5. 归并排序
6. 快速排序
7. 堆排序

接下来，我将为您提供这些排序算法的代码示例。

1. 冒泡排序

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

1. 选择排序

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

1. 插入排序

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

1. 希尔排序

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; j>=gap && arr[j-gap]>temp; j-=gap){
                arr[j] = arr[j-gap];
            }
            arr[j] = temp;
        }
    }
}

1. 归并排序

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

1. 快速排序

int partition(int arr[], int left, int right){
    int p = arr[right];
    int i = left - 1;
    int j,temp;
    for(j=left; j<=right-1; j++){
        if(arr[j] < p){
            i++;
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    temp = arr[i+1];
    arr[i+1] = arr[right];
    arr[right] = temp;
    return i+1;
}
 
void quickSort(int arr[], int left, int right){
    if(left < right){
        int pi = partition(arr, left, right);
        quickSort(arr, left, pi-1);
        quickSort(arr, pi+1, right);
    }
}

1. 堆排序

void heapify(int arr[], int size, int i){
    int largest = i;
    int l = 2*i + 1;
    int r = 2*i + 2;
    if(l<size && arr[l]>arr[largest]){
        largest = l;
    }
    if(r<size && arr[r]>arr[largest]){
        largest = r;
    }
    if(largest != i){
        int temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;
        heapify(arr, size, largest);
    }
}
 
void heapSort(int arr[], int size){
    int i,temp;
    for(i=size/2-1; i>=0; i--){
        heapify(arr, size, i);
    }
    for(i=size-1; i>=0; i--){
        temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapify(arr, i, 0);
    }
}

C语言中常用的排序算法的时间复杂度如下：

1. 冒泡排序

最好情况时间复杂度：O(n) 平均情况时间复杂度：O(n^2) 最坏情况时间复杂度：O(n^2)

1. 选择排序

最好情况时间复杂度：O(n^2) 平均情况时间复杂度：O(n^2) 最坏情况时间复杂度：O(n^2)

1. 插入排序

最好情况时间复杂度：O(n) 平均情况时间复杂度：O(n^2) 最坏情况时间复杂度：O(n^2)

1. 希尔排序

最好情况时间复杂度：O(n(log n)^2) 平均情况时间复杂度：O(n(log n)^2) 最坏情况时间复杂度：O(n(log n)^2)

1. 归并排序

最好情况时间复杂度：O(nlog n) 平均情况时间复杂度：O(nlog n) 最坏情况时间复杂度：O(nlog n)

1. 快速排序

最好情况时间复杂度：O(nlog n) 平均情况时间复杂度：O(nlog n) 最坏情况时间复杂度：O(n^2)

1. 堆排序

最好情况时间复杂度：O(nlog n) 平均情况时间复杂度：O(nlog n) 最坏情况时间复杂度：O(nlog n)

从时间复杂度的角度来看，归并排序和堆排序在大数据量情况下性能相对更好，而冒泡排序和选择排序在任何情况下都比较低效。