排序算法小计

最新推荐文章于 2024-02-27 10:56:47 发布

momo_ibeike

最新推荐文章于 2024-02-27 10:56:47 发布

阅读量228

点赞数

CC 4.0 BY-SA版权

分类专栏： java

本文链接：https://blog.youkuaiyun.com/momo_ibeike/article/details/79653333

java 专栏收录该内容

11 篇文章

订阅专栏

本文详细介绍了五种常用的排序算法：冒泡排序、选择排序、插入排序、希尔排序和快速排序，并提供了每种算法的实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

冒泡排序

public void bubbleSort(int[] array) {
        for (int j = array.length - 1; j > 0; j--) {
            boolean isOk = true;
            for (int i = 0; i < j; i++) {
                if (array[i] > array[i + 1]) {
                    int tmp = array[i];
                    array[i] = array[i + 1];
                    array[i + 1] = tmp;
                    isOk = false;
                }
            }
            if (isOk) break;
        }
    }

选择排序

public void selectSort(int[] array) {
        for (int j = 0; j < array.length - 1; j++) {
            int index = j;
            for (int i = j + 1; i < array.length; i++) {
                if (array[i] < array[index]) {
                    index = i;
                }
            }
            if (index != j) {
                int tmp = array[j];
                array[j] = array[index];
                array[index] = tmp;
            }
        }
    }

插入排序

public void insertSort(int[] array) {
        for (int k = 1; k < array.length; k++) {
            int j = k;
            int tmp = array[j];
            while (j > 0 && tmp < array[j - 1]) {
                array[j] = array[j - 1];
                j--;
            }
            array[j] = tmp;
        }
    }

希尔排序

public void shellSort(int[] array) {
        for (int step = array.length / 2; step > 0; step /= 2) {
            for (int k = step; k < array.length; k += step) {
                int j = k;
                int tmp = array[j];
                while (j > step - 1 && tmp < array[j - step]) {
                    array[j] = array[j - step];
                    j -= step;
                }
                array[j] = tmp;
            }
        }
    }

快速排序

public void quickSort(int[] array, int left, int right) {
        if (right - left <= 1) return;//递归退出条件
        int tmp = array[left];
        int start = left;
        int end = right;
        while (left < right) {
            while (left < right && array[right] > tmp) {
                right--;
            }
            while (left < right && array[left] < tmp) {
                left++;
            }
            int t = array[left];
            array[left] = array[right];
            array[right] = t;
        }
        array[left] = tmp;
        quickSort(array, start, left - 1);
        quickSort(array, left + 1, end);
    }

归并排序

public void mergeSort(int[] array, int[] tmp, int left, int right) {
        if (right == left) return;

        int mid = (left + right) / 2;

        mergeSort(array, tmp, left, mid);
        mergeSort(array, tmp, mid + 1, right);

        for (int i = left; i <= right; i++) {
            tmp[i] = array[i];
        }
        int leftPos = left;
        int rightPos = mid + 1;
        int index = left;
        while (leftPos <= mid && rightPos <= right) {
            if (tmp[leftPos] < tmp[rightPos]) {
                array[index++] = tmp[leftPos++];
            } else {
                array[index++] = tmp[rightPos++];
            }
        }

        while (leftPos <= mid) {
            array[index++] = tmp[leftPos++];
        }

        while (rightPos < right) {
            array[index++] = tmp[rightPos++];
        }

    }