常见排序和查找算法(C实现)

    int nums[10] = {4, 5, 2, 10, 7, 1, 8, 3, 6, 9};
    int length = sizeof(nums) / sizeof(nums[0]);
    bubbleSort(nums, length);
    
    for (int i = 0; i < length; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

1. 冒泡排序

void bubbleSort(int arr[], int length) {
    for (int i = 0; i < length - 1; i++) {//比较n趟, 每次确定一个元素
        for (int j = 0; j < length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

2. 选择排序

void selectSort(int arr[], int length) {
    int minIndex = 0;
    for (int i = 0; i < length - 1; i++) {
        minIndex = i;
        //1. 对比记录最小元素的下标
        for (int j = i + 1; j < length; j++) {
            if (arr[minIndex] > arr[j]) {
                minIndex = j;
            }
        }
        //2. 将每次比较的最小元素调整到第i次的位置
        if (i != minIndex) {
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

3. 插入排序

void insertSort(int arr[], int length) {
    for (int i = 1; i < length; i++) {//循环从第2个元素开始
        if (arr[i] < arr[i - 1]) {//当前元素需要插入排序
            int temp = arr[i];//记录需要插入的值
            int j;
            
            //跳出循环式,就是插入的位置arr[j + 1],需要将插入的值赋值给arr[j + 1]
            for (j = i - 1; j >= 0 && arr[j] > temp; j--) {//利用反向冒泡排序把小的移动到前面
                arr[j + 1] = arr[j];
            }
            //跳出循环时j-1对应的是值arr[j]
            arr[j + 1] = temp;//插入的位置
        }
    }

4. 希尔排序

void hillSort(int arr[], int length) {
    int gap = length;
    
    do {
        gap = gap / 3 + 1;
        for (int i = gap; i < length; i++) {
            if (arr[i] < arr[i - gap]) {
                int temp = arr[i];
                int j;
                for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap) {
                    arr[j + gap] = arr[j];
                }
                arr[j + gap] = temp;
            }
        }
    } while (gap > 1);
}

5. 堆排序

void heapAdjust(int arr[], int s, int n) {
    int i, temp;
    temp = arr[s];
    for (i = 2 * s; i <= n; i *= 2) {
        if (i < n && arr[i] < arr[i + 1]) {
            i++;
        }
        if (temp >= arr[i]) {
            break;
        }
        arr[s] = arr[i];
        s = i;
    }
    arr[s] = temp;
}

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

6. 归并排序

void mergeSort(int arr[], int n) {
    
    if (n <= 1) {//终止条件
        return;
    }
    int *listLeft = arr;
    int listLeftSize = n / 2;
    int *listRight = arr + n / 2;
    int listRightSize = n - listLeftSize;
    
    //递归
    mergeSort(listLeft, listLeftSize);
    mergeSort(listRight, listRightSize);
    
    //合并
    int i, j, k;
    i = j = k = 0;
    int temp[n];
    while (i < listLeftSize && j < listRightSize) {
        if (listLeft[i] < listRight[j]) {
            temp[k++] = listLeft[i++];
        } else {
            temp[k++] = listRight[j++];
        }
    }
    //最后的数据
    while (i < listLeftSize) {
        temp[k++] = listLeft[i++];
    }
    while (j < listRightSize) {
        temp[k++] = listRight[j++];
    }
    
    //排序好的数据赋值给原数组
    for (int i = 0; i < n; i++) {
        arr[i] = temp[i];
    }
}

7. 快速排序

//quicklySort(nums, 0, length - 1);

void swap(int arr[], int left, int right) {
    int temp;
    temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;
}

int partition(int arr[],int left,int right){
    int point = arr[left];
    while (left < right) {
        while (left < right && arr[right] >= point) {
            right--;
        }
        swap(arr, left, right);
        while (left < right && arr[left] <= point) {
            left++;
        }
        swap(arr, left, right);
    }
    return point;
}

void quicklySort(int *arr, int left, int right){
    int basePosition = 0;//找到基准划分位置
    if (left < right) {
        basePosition = partition(arr, left, right);
        quicklySort(arr, left, basePosition - 1);
        quicklySort(arr, basePosition + 1, right);
    }
}

8. 折半查找

int binarySearch(int arr[], int n, int key) {
    int left = 0;
    int right = n - 1;
    int mid = 0;
    
    while (left <= right) {
        mid = (left + right) / 2;
        if (arr[mid] == key) {
            return mid;
        } else {
            if (arr[mid] < key) {//在右半段
                left = mid + 1;
            } else {//在左半段
                right = mid - 1;
            }
        }
    }
    return -1;
}

int main(int argc, const char * argv[]) {
    int arr[11]={0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int length = sizeof(arr) / sizeof(arr[0]);
    int key = 1;
    int result = binarySearch(arr, length, key);
    if (result == -1) {
        printf("can not find this key! \n");
    } else {
        printf("arr[%d] == %d \n", result, key);
    }
    printf("\n");
    return 0;
}

9. 插值查找

int insertSearch(int arr[], int n, int key) {
    int left = 0;
    int right = n - 1;
    int mid = 0;
    
    //(key- arr[left]) / (arr[right] - arr[left] ) 按照比例每次最接近的位置
    while (left <= right) {
        mid = left + (key- arr[left]) / (arr[right] - arr[left] ) * (right - left);
        if (arr[mid] == key) {
            return mid;
        } else {
            if (arr[mid] < key) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
    }
    return -1;
}