前言

排序算法在线模拟：http://www.atool9.com/sort.php

直接插入排序

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

希尔排序

void shellSort(int arr[], int n) {
    int index = n / 2;
    while (index >= 1) {
        for (int i = index; i < n; i++) {
            for (int j = i - index; j >= 0; j -= index) {
                if (arr[j] > arr[j + index]) {
                    int temp = arr[j];
                    temp = arr[j];
                    arr[j] = arr[j + index];
                    arr[j + index] = temp;
                }
            }
        }
        index = index / 2;
    }
}

直接选择排序

void straightSelectSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int index = i;
        for (int j = i + 1; j <= n; j++) {
            if (arr[index] > arr[j]) {
                index = j;
            }
        }
        if (index != i) {
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
    }
}

简单选择排序

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

堆排序

swap()函数

void swap(int arr[], int a, int b) {
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

maxHeapify()函数

void maxHeapify(int arr[], int i, int n) {
    int child;
    int temp;
    for (temp = arr[i]; i * 2 + 1 < n; i = child) {
        child = i * 2 + 1;
        if (child != n - 1 && arr[child] < arr[child + 1]) {
            child++;
        }
        if (temp < arr[child]) {
            arr[i] = arr[child];
        } else {
            break;
        }
    }
    arr[i] = temp;
}

heapSort()函数

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--) {
        maxHeapify(arr, i, n);
    }
    for (int i = n - 1; i > 0; i--) {
        swap(arr, 0, i);
        maxHeapify(arr, 0, i);
    }
}

冒泡排序

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]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

优化

void bubbleSort(int arr[], int n) {
    int lastExchangeIndex = 0;
    int sortBorder = n - 1;
    for (int i = 0; i < n - 1; i++) {
        bool sorted = true;
        for (int j = 0; j < sortBorder; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                sorted = false;
                lastExchangeIndex = j;
            }
        }
        sortBorder = lastExchangeIndex;
        if (sorted) {
            break;
        }
    }
}

快速排序

partition()函数——挖坑法

int partition(int arr[], int startIndex, int endIndex) {
    int pivot = arr[startIndex];
    int left = startIndex;
    int right = endIndex;
    int index = startIndex;
    while (right >= left) {
        while (right >= left) {
            if (arr[right] < pivot) {
                arr[left] = arr[right];
                index = right;
                left++;
                break;
            }
            right--;
        }
        while (right >= left) {
            if (arr[left] > pivot) {
                arr[right] = arr[left];
                index = left;
                right--;
                break;
            }
            left++;
        }
    }
    arr[index] = pivot;
    return index;
}

partition()函数——指针交换法

int partition(int arr[], int startIndex, int endIndex) {
    int pivot = arr[startIndex];
    int left = startIndex;
    int right = endIndex;
    while (left != right) {
        while (left < right && arr[right] > pivot) {
            right--;
        }
        while (left < right && arr[left] <= pivot) {
            left++;
        }
        if (left < right) {
            int p = arr[left];
            arr[left] = arr[right];
            arr[right] = p;
        }
    }
    int p = arr[left];
    arr[left] = arr[startIndex];
    arr[startIndex] = p;
    return left;
}

quickSort()函数——递归算法

void quickSort(int arr[], int startIndex, int endIndex) {
    if (startIndex >= endIndex) {
        return;
    }
    int pivotIndex = partition(arr, startIndex, endIndex);
    quickSort(arr, startIndex, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, endIndex);
}

归并排序

merge()函数

void merge(int arr[], int left, int mid, int right, int temp[]) {
    int i = left;
    int j = mid + 1;
    int k = 0;
    while (i <= mid && j <= right) {
        if (arr[i] < arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = arr[i++];
    }
    while (j <= right) {
        temp[k++] = arr[j++];
    }
    k = 0;
    while (left <= right) {
        arr[left++] = temp[k++];
    }
}

mergeSort()函数

扫描二维码关注公众号，回复： 11188498 查看本文章

void mergeSort(int arr[], int left, int right, int temp[]) {
    if (left < right) {
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid, temp);
        mergeSort(arr, mid + 1, right, temp);
        merge(arr, left, mid, right, temp);
    }
}

基数排序

maxCount()函数

int maxCount(int arr[], int n) {
    int max = 0;
    for (int i = 0; i < n; i++) {
        int count = 1;
        int temp = arr[i];
        while (temp / 10 != 0) {
            temp = temp / 10;
            count++;
        }
        if (count > max) {
            max = count;
        }
    }
    return max;
}

radixSort()函数

void radixSort(int arr[], int n) {
    int max = maxCount(arr, n);
    int radix = 1;
    for (int i = 0; i < max; i++) {
        int count[10];
        int temp[10][n];
        for (int j = 0; j < 10; j++) {
            count[j] = 0;
        }
        for (int j = 0; j < 10; j++) {
            for (int k = 0; k < n; k++) {
                temp[j][k] = 0;
            }
        }
        for (int j = 0; j < n; j++) {
            int k = (arr[j] / radix) % 10;
            temp[k][count[k]] = arr[j];
            count[k]++;
        }
        int b = 0;
        for (int j = 0; j < 10; j++) {
            if (count[j] > 0) {
                for (int k = 0; k < count[j]; k++) {
                    arr[b] = temp[j][k];
                    b++;
                }
            }
        }
        radix = radix * 10;
    }
}

桶排序

getMax()函数

int getMax(int arr[], int n) {
    int max = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

bucketSort()函数

void bucketSort(int arr[], int n) {
    int max = getMax(arr, n) + 1;
    int buckets[max];
    for (int i = 0; i < max; i++) {
        buckets[i] = 0;
    }
    for (int i = 0; i < n; i++) {
        buckets[arr[i]]++;
    }
    for (int i = 0, j = 0; i < max; i++) {
        while (buckets[i] != 0) {
            arr[j] = i;
            j++;
            buckets[i]--;
        }
    }
}

计数排序

void countSort(int arr[], int n) {
    int max = arr[0];
    int min = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
        if (arr[i] < min) {
            min = arr[i];
        }
    }
    int size = max - min + 1;
    int count[size];
    memset(count, 0, sizeof(int) * size);
    for (int i = 0; i < n; i++) {
        count[arr[i] - min]++;
    }
    for (int i = 1; i < size; i++) {
        count[i] += count[i - 1];
    }
    int sortedArray[n];
    memset(sortedArray, 0, sizeof(int) * n);
    for (int i = n - 1; i >= 0; i--) {
        count[arr[i] - min]--;
        sortedArray[count[arr[i] - min]] = arr[i];
    }
    for (int i = 0; i < n; i++) {
        arr[i] = sortedArray[i];
    }
}