1. 冒泡排序（Bubble Sort）：冒泡排序是一种简单的排序算法，它通过比较相邻两个元素的大小来进行排序。每一轮循环都会把一个最大值移动到数组的末尾，因此每一轮循环会少处理一项。冒泡排序的时间复杂度为O(n^2)。

public void bubbleSort(int[] array) {    int n = array.length;    for (int i = 0; i < n - 1; i++) { // 外层循环表示循环次数，共循环n-1次        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;            }        }    }}

2. 插入排序（Insertion Sort）：插入排序也是一种简单的排序算法，它通过将未排序的元素依次插入已排序的元素中，来完成排序。插入排序的时间复杂度为O(n^2)，但当数据已经基本有序时，插入排序的表现会更好。

public void insertionSort(int[] array) {    int n = array.length;    for (int i = 1; i < n; i++) { // 外层循环表示待插入的元素下标，从1开始到n-1        int key = array[i]; // 待插入的元素        int j = i - 1; // 已排好序部分的最后一个元素下标        while (j >= 0 && array[j] > key) { // 在已排好序部分找到插入位置            array[j + 1] = array[j]; // 把大于待插入元素的元素向右移动一位            j--;        }        array[j + 1] = key; // 把待插入元素插入到正确的位置    }}

3. 选择排序（Selection Sort）：选择排序是一种简单的排序算法，它通过依次选择未排序部分中的最小值，并将其放到已排序部分的末尾，来完成排序。选择排序的时间复杂度为O(n^2)。

public void selectionSort(int[] array) {    int n = array.length;    for (int i = 0; i < n - 1; i++) { // 外层循环表示已排好序部分的长度，初始值为0，每次循环加1        int minIndex = i; // 已排好序部分的最小值下标，默认为i        for (int j = i + 1; j < n; j++) { // 内层循环表示在未排序部分找到最小值            if (array[j] < array[minIndex]) { // 如果当前值比最小值还小，则更新最小值下标                minIndex = j;            }        }        // 交换元素        int temp = array[i];        array[i] = array[minIndex];        array[minIndex] = temp;    }}

4. 快速排序（Quick Sort）：快速排序是一种分治排序算法，它通过选定一个主元（pivot），将数组分成两个子数组，并对子数组进行递归排序，从而完成排序。快速排序的平均时间复杂度为O(nlogn)，但是最坏的情况下的时间复杂度为O(n^2)。

public void quickSort(int[] array, int low, int high) {    if (low < high) { // 当low >= high时停止递归        int pivotIndex = partition(array, low, high); // 将数组分成两个子数组，并返回主元的最终位置        quickSort(array, low, pivotIndex - 1); // 对左子数组进行递归排序        quickSort(array, pivotIndex + 1, high); // 对右子数组进行递归排序    }}private int partition(int[] array, int low, int high) {    int pivot = array[high]; // 取数组最后一个元素为主元    int i = low - 1; // smallerIndex表示已经处理过的元素中比主元小的下标最大值    for (int j = low; j < high; j++) { // 遍历整个数组        if (array[j] < pivot) { // 如果当前元素比主元小            i++; // smallerIndex加1            // 交换元素            int temp = array[i];            array[i] = array[j];            array[j] = temp;        }    }    // 交换元素    int temp = array[i + 1];    array[i + 1] = array[high];    array[high] = temp;    return i + 1; // 返回主元的最终位置}

5. 归并排序（Merge Sort）：归并排序也是一种分治排序算法，它通过将数组划分成两个子数组，并对子数组进行递归排序，最后将两个排序后的子数组合并成一个有序的数组。归并排序的时间复杂度为O(nlogn)。

public void mergeSort(int[] array, int low, int high) {    if (low < high) { // 当low >= high时停止递归        int mid = (low + high) / 2; // 找到middleIndex        mergeSort(array, low, mid); // 对左子数组进行递归排序        mergeSort(array, mid + 1, high); // 对右子数组进行递归排序        merge(array, low, mid, high); // 合并两个有序子数组    }}private void merge(int[] array, int low, int mid, int high) {    int n1 = mid - low + 1; // 左子数组的长度    int n2 = high - mid; // 右子数组的长度    int[] leftArray = new int[n1]; // 左子数组    int[] rightArray = new int[n2]; // 右子数组    for (int i = 0; i < n1; ++i) {        leftArray[i] = array[low + i]; // 把原数组中左子数组的元素复制到新数组中    }    for (int j = 0; j < n2; ++j) {        rightArray[j] = array[mid + 1 + j]; // 把原数组中右子数组的元素复制到新数组中    }    int i = 0, j = 0;    int k = low;    while (i < n1 && j < n2) { // 将两个数组合并成一个有序数组        if (leftArray[i] <= rightArray[j]) {            array[k] = leftArray[i];            i++;        } else {            array[k] = rightArray[j];            j++;        }        k++;    }    while (i < n1) { // 把剩余的元素加到新数组中        array[k] = leftArray[i];        i++;        k++;    }    while (j < n2) { // 把剩余的元素加到新数组中        array[k] = rightArray[j];        j++;        k++;    }}

以上是本人手写举例，请大家给予鼓励支持！