探索C语言中的常见排序算法

电玩女神 2023-10-14 22:00 3阅读 0赞

## 探索C语言中的常见排序算法 ##

排序算法是计算机科学中至关重要的基础知识之一，它们能够帮助我们对数据进行有序排列，从而更高效地进行搜索、插入和删除操作。在本篇博客中，我们将深入探讨C语言中的一些常见排序算法，包括它们的工作原理、实现代码以及性能比较。

### 1. 冒泡排序 (Bubble Sort) ###

冒泡排序是一种简单但低效的排序算法，它通过多次遍历数组，每次比较相邻的元素并交换位置，将最大的元素逐渐“冒泡”到数组的末尾。虽然不太适用于大型数据集，但冒泡排序在教学和理解排序概念时仍具有一定的价值。

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

### 2. 选择排序 (Selection Sort) ###

选择排序是一种每次选取未排序部分中最小（或最大）的元素，然后将其放置到已排序部分的末尾。虽然比冒泡排序稍微快一些，但仍然不适用于大型数据集。

void selectionSort(int arr[], int n) {
        
        for (int i = 0; i < n - 1; i++) {
        
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
        
                if (arr[j] < arr[minIndex]) {
        
                    minIndex = j;
                }
            }
            // 交换位置
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }

### 3. 插入排序 (Insertion Sort) ###

插入排序的思想是将未排序的元素逐个插入到已排序部分的合适位置。它对于小型数据集和部分有序的数据集表现良好。

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

### 4. 快速排序 (Quick Sort) ###

快速排序是一种高效的分治排序算法，它通过选择一个基准元素，将数组分成左右两个子数组，然后递归地对子数组进行排序。虽然在大多数情况下表现出色，但在最坏情况下可能会导致性能下降。

void quickSort(int arr[], int low, int high) {
        
        if (low < high) {
        
            int pivot = partition(arr, low, high);
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
    }
    
    int partition(int arr[], int low, int high) {
        
        int pivot = arr[high];
        int i = (low - 1);
        for (int j = low; j <= high - 1; j++) {
        
            if (arr[j] < pivot) {
        
                i++;
                // 交换位置
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // 交换位置
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return (i + 1);
    }

### 5. 归并排序 (Merge Sort) ###

归并排序是一种稳定的分治排序算法，它将数组分成两个子数组，递归地对子数组进行排序，然后将排序好的子数组合并为一个有序数组。

void mergeSort(int arr[], int left, int right) {
        
        if (left < right) {
        
            int middle = left + (right - left) / 2;
            mergeSort(arr, left, middle);
            mergeSort(arr, middle + 1, right);
            merge(arr, left, middle, right);
        }
    }
    
    void merge(int arr[], int left, int middle, int right) {
        
        int n1 = middle - left + 1;
        int n2 = right - middle;
        int L[n1], R[n2];
    
        for (int i = 0; i < n1; i++) {
        
            L[i] = arr[left + i];
        }
        for (int j = 0; j < n2; j++) {
        
            R[j] = arr[middle + 1 + j];
        }
    
        int 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++;
        }
    }

### 总结 ###

在本篇博客中，我们对C语言中的一些常见排序算法进行了简要介绍。每个算法都有其独特的特点和适用范围，因此在实际应用中需要根据问题的性质选择合适的算法。要深入理解这些算法的工作原理，最好的方法是通过实际