编程语言十大排序算法

冒泡排序(Bubble Sort)

冒泡排序是一种简单的排序算法。它重复地遍历要排序的列表，比较相邻的两个元素，并根据需要交换它们的位置，直到整个列表排序完成。

public void bubbleSort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                // 交换元素位置
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

选择排序(Selection Sort)

选择排序是一种简单直观的排序算法。它首先在未排序的列表中找到最小（或最大）元素，将其放置在排序序列的起始位置，然后再从剩余未排序的元素中继续这个过程，直到整个列表排序完成。

public void selectionSort(int[] array) {
    int n = array.length;
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < n; j++) {
            if (array[j] < array[minIndex]) {
                minIndex = j;
            }
        }
        // 交换元素位置
        int temp = array[minIndex];
        array[minIndex] = array[i];
        array[i] = temp;
    }
}

插入排序(Insertion Sort)

插入排序是一种简单直观的排序算法。它将未排序的列表的第一个元素视为已排序的子列表，然后逐个将列表中的元素插入到适当的位置，直到整个列表排序完成。

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

归并排序(Merge Sort)

归并排序是一种分治算法。它将列表不断分成两半，对每个子列表进行递归排序，然后将排好序的子列表合并为最终的排序列表。

public void mergeSort(int[] array) {
    if (array.length <= 1) {
        return;
    }
    int mid = array.length / 2;
    int[] leftArray = Arrays.copyOfRange(array, 0, mid);
    int[] rightArray = Arrays.copyOfRange(array, mid, array.length);

    mergeSort(leftArray);
    mergeSort(rightArray);

    merge(leftArray, rightArray, array);
}

private void merge(int[] leftArray, int[] rightArray, int[] resultArray) {
    int i = 0, j = 0, k = 0;
    while (i < leftArray.length && j < rightArray.length) {
        if (leftArray[i] <= rightArray[j]) {
            resultArray[k++] = leftArray[i++];
        } else {
            resultArray[k++] = rightArray[j++];
        }
    }
    while (i < leftArray.length) {
        resultArray[k++] = leftArray[i++];
    }
    while (j < rightArray.length) {
        resultArray[k++] = rightArray[j++];
    }
}

综上所述，这些排序算法分别是冒泡排序、选择排序、插入排序和归并排序。每个排序算法都有其特定的实现方式和适用场景，对于不同的输入数据和性能要求，可以选择相应的算法来进行排序操作。