java排序算法

最新推荐文章于 2023-06-30 19:45:37 发布
最新推荐文章于 2023-06-30 19:45:37 发布
阅读量174 收藏
点赞数
分类专栏： java基础

冒泡排序

主要思想：外层循环从1到n-1，内循环从当前外层的元素的下一个位置开始，依次和外层的元素比较，出现逆序就交换。 
特点：stable sort（稳定性排序）、In-place sort（不占用额外的空间,只是交换元素） 
最优复杂度：当输入数组就是排好序的时候，复杂度为O(n)，而快速排序在这种情况下会产生O(n^2)的复杂度。 
最差复杂度：当输入数组为倒序时，复杂度为O(n^2) 
插入排序比较适合用于“少量元素的数组”。

其实插入排序的复杂度和逆序对的个数一样，当数组倒序时，逆序对的个数为n(n-1)/2，因此插入排序复杂度为O(n^2)。

public class BubbleSort {
    public static void main(String[] args) {
        int[] array = new int[]{2, 3, 5, 8, 9, 0, 4, 5, 1, 6, 8, 7};
        sort(array);
        System.out.println(Arrays.toString(array));

    }
    private static void sort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n-1; i++) {
            for (int j = i + 1; j < n; j++) {
                if (array[j] < array[i]) {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

在算法导论思考题2-2中又问了”冒泡排序和插入排序哪个更快“呢？

插入排序的速度直接是逆序对的个数，而冒泡排序中执行“交换“的次数是逆序对的个数，因此冒泡排序执行的时间至少是逆序对的个数，因此插入排序的执行时间至少比冒泡排序快。

插入排序

主要思想： 
特点：stable sort(稳定性排序)、In-place sort（不占用额外空间） 
最优复杂度：当输入数组就是排好序的时候，复杂度为O(n)，而快速排序在这种情况下会产生O(n^2)的复杂度。 
最差复杂度：当输入数组为倒序时，复杂度为O(n^2) 
插入排序比较适合用于“少量元素的数组”。

其实插入排序的复杂度和逆序对的个数一样，当数组倒序时，逆序对的个数为n(n-1)/2，因此插入排序复杂度为O(n^2)。

public class InsertSort {
    public static void main(String[] args) {
        int[] array = new int[]{2, 3, 5, 8, 9, 0, 4, 5, 1, 6, 8, 7};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
    private static void sort(int[] array) {
        int n = array.length;
        for (int i = 1; i < n; i++) {
            for (int j = i ; j >0 ; j--) {
                if (array[j] < array[j - 1]) {
                    int temp = array[j];
                    array[j] = array[j - 1];
                    array[j-1] = temp;
                }
            }
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

插入排序的改进：内循环发现逆序不交换，采用整体右移，直到没有逆序的时候把元素放在该位置

public class InsertSort2 {
    public static void main(String[] args) {
        int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7};
        sort(array);
        System.out.println(Arrays.toString(array));
    }

    private static void sort(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;
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

问题：快速排序（不使用随机化）是否一定比插入排序快？

答：不一定，当输入数组已经排好序时，插入排序需要O(n)时间，而快速排序需要O(n^2)时间。

选择排序

特性：In-place sort，unstable sort。 
思想：每次找一个最小值。 
最好情况时间：O(n^2)。 
最坏情况时间：O(n^2)。

public class SelectSort {
    public static void main(String[] args) {
        int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7};
        sort(array);
        System.out.println(Arrays.toString(array));
    }

    private static void sort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n-1; i++) {
            int min = i;
            for (int j = i+1; j < n; j++) {
                if (array[j] < array[min]) min = j;
            }
            int temp = array[i];
            array[i] = array[min];
            array[min] = temp;

        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

希尔排序

思想：基于插入排序，交换不相邻的元素已对数组的局部进行排序，并最终用插入排序将局部有序的数组排序。思想是使数组中任意间隔为h的元素都是有序的，这样的数组称为h有序数组. 
特性：In-place sort，unstable sort。 
思想：每次找一个最小值。 
最好情况时间：O(n)。 
最坏情况时间：O(n^2)。

public class ShellSort {
    public static void main(String[] args) {
        int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7, 15};
        sort(array);
        System.out.println(Arrays.toString(array));
    }

    private static void sort(int[] array) {
        int n = array.length;
        int h = 1;
        while (h<n/3) h = 3*h +1;
        while (h >= 1) {
            for (int i = h; i < n; i++) {
                for (int j = i; j >= h && (array[j] < array[j - h]); j -= h) {
                    int temp = array[j];
                    array[j] = array[j - h];
                    array[j-h]= temp;
                }
            }
            h /=3;
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

归并排序

特点：stable sort、Out-place sort 
思想：运用分治法思想解决排序问题。 
最坏情况运行时间：O(nlgn) 
最佳运行时间：O(nlgn)

程序中merge的精髓（也就是排序）：左半边用尽，则取右半边元素；右半边用尽，则取左半边元素；右半边的当前元素小于左半边的当前元素，则取右半边元素；右半边的当前元素大于左半边的当前元素，则取左半边的元素。实际上大部分发生的都是后面两句话，前面两句只是特殊情况而已。

自顶向下：

public class MergeSort {
    public static void main(String[] args) {
        int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7};
        mergeSort(array);
        System.out.println(Arrays.toString(array));
    }

    private static void mergeSort(int[] array) {
        int[] aux = new int[array.length];
        sort(array, aux, 0, array.length - 1);
    }

    private static void sort(int[] array, int[] aux, int lo, int hi) {
        if (hi<=lo) return;
        int mid = lo + (hi - lo)/2;
        sort(array, aux, lo, mid);
        sort(array, aux, mid + 1, hi);
        merge(array, aux, lo, mid, hi);
    }

    private static void merge(int[] array, int[] aux, int lo, int mid, int hi) {
        System.arraycopy(array,0,aux,0,array.length);
        int i = lo, j = mid + 1;
        for (int k = lo; k <= hi; k++) {
            if (i>mid) array[k] = aux[j++];
            else if (j > hi) array[k] = aux[i++];
            else if (aux[j]<aux[i]) array[k] = aux[j++];
            else array[k] = aux[i++];
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

自底向上：

public class MergeSort2 {

    public static void main(String[] args) {
        int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7};
        sort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void sort(int[] array) {
        int N = a.length;
        int[] aux = new int[N];
        for (int n = 1; n < N; n = n+n) {
            for (int i = 0; i < N-n; i += n+n) {
                int lo = i;
                int m  = i+n-1;
                int hi = Math.min(i+n+n-1, N-1);
                merge(array, aux, lo, m, hi);
            }
        }
    }

    private static void merge(int[] array, int[] aux, int lo, int mid, int hi) {
        for (int k = lo; k <= hi; k++) {
            aux[k] = array[k];
        }
        // merge back to a[]
        int i = lo, j = mid+1;
        for (int k = lo; k <= hi; k++) {
            if      (i > mid)              array[k] = aux[j++];  // this copying is unneccessary
            else if (j > hi)               array[k] = aux[i++];
            else if (aux[j]<aux[i]) array[k] = aux[j++];
            else                           array[k] = aux[i++];
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

注意：当数组长度为2的幂时，自顶向下和自底向上的归并排序所用的次数和数组访问的次数正好相同，只是顺序不同。其他时候，两种方法的比较和数组的访问次数会有所不同

问：归并排序的缺点是什么？

答：他是Out-place sort，因此相比快排，需要很多额外的空间。

问：为什么归并排序比快速排序慢？

答：虽然渐近复杂度一样，但是归并排序的系数比快排大。

问：对于归并排序有什么改进？

答：就是在数组长度为k时，用插入排序，因为插入排序适合对小数组排序。在算法导论思考题2-1中介绍了。复杂度为O(nk+nlg(n/k)) ，当k=O(lgn)时，复杂度为O(nlgn)

改进： 
对小规模子数组采用插入排序： 
因为递归会使小规模问题中方法的调用过于频繁，所以改进对它们的处理方法就能改进整个算法。使用插入排序处理小规模的子数组，一般可以将归并排序的运行时间虽短10%~15%。无代码

测试数组是否已经有序：可以添加一个判断条件，如果a[mid]小于a[mid+1]，我们就任务数组已经是有序的并跳过merge方法（指的是两个sort后面的merge）。这个改动不影响排序的递归调用，但是任意有序的子数组算法的运行时间就变成线性的了。

不将元素复制到辅助数组：我们可以节省将数组复制到用于归并的辅助数组所用的时间。要做到这一点我们要调用两种排序方法，一种将数据从输入数组排序到辅助数组，一种将数据从辅助数组排序到输入数组，这种方法需要一些技巧，我们要在递归调用的每个层次交换输入数组和输出数组的角色。无代码

快速排序

特性：unstable sort、In-place sort。 
最坏运行时间：当输入数组已排序时，时间为O(n^2)，当然可以通过随机化来改进（shuffle array 或者 randomized select pivot）,使得期望运行时间为O(nlgn)。 
最佳运行时间：O(nlgn) 
快速排序的思想也是分治法。 
当输入数组的所有元素都一样时，不管是快速排序还是随机化快速排序的复杂度都为O(n^2)，而在算法导论第三版的思考题7-2中通过改变Partition函数，从而改进复杂度为O(n)。

public class QuickSort {
    public static void main(String[] args) {
        int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7};
        sort(array);
        System.out.println(Arrays.toString(array));
    }

    private static void sort(int[] array) {
        shuffle(array);
        sort(array, 0, array.length - 1);
    }
    private static void sort(int[] array, int lo, int hi) {
        if (hi<=lo) return;
        int j = partition(array, lo, hi);
        sort(array, lo, j - 1);
        sort(array, j+1, hi);
    }

    private static int partition(int[] array, int lo, int hi) {
        int i = lo;
        int j = hi + 1;
        int v = array[lo];
        while (true) {
            while (array[++i] < v) if (i == hi) break;
            while (v < array[--j]) if (j == lo) break;
            if (i>=j) break;

            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
        int temp = array[lo];
        array[lo] = array[j];
        array[j] = temp;
        return j;
    }
    /**
     *打乱数组
     */
    private static void shuffle(int[] array) {
        Random random = new Random(System.currentTimeMillis());
        if (array == null) throw new NullPointerException("argument array is null");
        int n = array.length;
        for (int i = 0; i < n; i++) {
            int r = i + random.nextInt(n-i);     // between i and n-1
            int temp = array[i];
            array[i] = array[r];
            array[r] = temp;
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

算法改进： 
1. 切换到插入排序 
和大多数排序算法一样，改进快速排序的一个简单办法基于以下两点： 
对于小数组，快速排序比插入排序慢； 
因为递归，快速排序的sort()方法在小数组中也会调用自己

简单的改动：将sort中的：

if(hi<=lo) return;

 
 
  • 1
  • 2

改成

if(hi<=lo+M) {
Insert.sort(a,lo,hi);
return;}

 
 
  • 1
  • 2
  • 3
  • 4

2. 三取样切分 
3. 三向切分（将数组分成小于切分元素，等于切分元素和大于切分元素三组数组），代码如下：

public class Quick3way {
    public static void main(String[] args) {
        int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7};
        sort(array);
        System.out.println(Arrays.toString(array));
    }

    private static void sort(int[] array) {
        shuffle(array);
        sort(array, 0, array.length - 1);
    }
    private static void sort(int[] array, int lo, int hi) {
        if (hi <= lo) return;
        int lt = lo, gt = hi;
        int v = array[lo];
        int i = lo;
        while (i <= gt) {
            if      (array[i]<v) exch(array, lt++, i++);
            else if (array[i]>v) exch(array, i, gt--);
            else              i++;
        }
        // a[lo..lt-1] < v = a[lt..gt] < a[gt+1..hi].
        sort(array, lo, lt-1);
        sort(array, gt+1, hi);
    }

    private static void exch(int[] a, int i, int j) {
        int swap = a[i];
        a[i] = a[j];
        a[j] = swap;
    }

    /**
     *打乱数组
     */
    private static void shuffle(int[] array) {
        Random random = new Random(System.currentTimeMillis());
        if (array == null) throw new NullPointerException("argument array is null");
        int n = array.length;
        for (int i = 0; i < n; i++) {
            int r = i + random.nextInt(n-i);     // between i and n-1
            int temp = array[i];
            array[i] = array[r];
            array[r] = temp;
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

堆排序

特性：unstable sort、In-place sort。 
最优时间：O(nlgn) 
最差时间：O(nlgn)

public class HeapSort {
    public static void main(String[] args) {
        int[] array = new int[]{2, 3, 5, 8, 9, 0, 7, 5, 1, 6, 8, 7};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
    public static void sort(int[] a){
        int N = a.length;
        int[] keys = new int[N+1];
        //注意，堆的数据结构是从1开始的，0不用
        for (int i = 1; i < keys.length; i++) {
            keys[i] = a[i-1];
        }
//      //构造堆,使得堆是有序的
        for(int k = N/2;k>=1;k--) sink(keys,k,N);
        //排序，相当于毁掉堆
        while(N>1){
            exch(keys,1,N--);
            sink(keys,1,N);
        }
        //重新写回数组
        for (int i = 0; i < a.length; i++) {
            a[i] = keys[i+1];
        }
    }

    private static void sink(int[] a, int k, int N) {
        // TODO Auto-generated method stub
        while(2*k<=N){
            int j = 2*k;
            if (j < N && less(a[j], a[j+1])) j++;
            if (less(a[j], a[k])) break;
            exch(a, k, j);
            k = j;
        }
    }

    private static boolean less(int k, int j) {
        // TODO Auto-generated method stub
        return k < j;
    }

    private static void exch(int[] a, int i, int n) {
        // TODO Auto-generated method stub
        int temp = a[i];
        a[i] = a[n];
        a[n] = temp;
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

计数排序

特性：stable sort、out-place sort。 
最坏情况运行时间：O(n+k) 
最好情况运行时间：O(n+k)

public class CountingSort {
    public static void main(String[] args) throws Exception {
        int[] array = { 9, 9, 8, 8, 7, 5, 3, 2, 6, 0, 5 };
        int[] sort = sort(array, 9);
        System.out.println(Arrays.toString(sort));
    }
    /**
     * 输入数组的元素都是介于0..k之间的
     * @param data 待排序数组
     * @param k 最大元素
     * @return 排序结果
     */
    public static int[] sort(int[] data, int k) {
        // 存放临时数据的数组tmp，初始元素都是0；k为数组中最大元素
        int[] tmp = new int[k + 1];

        // 计算数组中每个元素i出现的次数，存入数组tmp中的第i项，即原数组中的元素值为tmp数组中的下标
        for (int i = 0; i <= data.length - 1; i++) {
            tmp[data[i]]++;
        }
        // 计算数组中小于等于每个元素的个数,即从tmp中的第一个元素开始，每一项和前一项相加
        for (int j = 1; j <= k; j++) {
            tmp[j] = tmp[j] + tmp[j - 1];
        }
        // result数组用来来存放排序结果
        int[] result = new int[data.length];
        for (int i = data.length - 1; i >= 0; i--) {
            result[tmp[data[i]] - 1] = data[i];
            tmp[data[i]]--;
        }
        return result;
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

基数排序：

本文假定每位的排序是计数排序。 
特性：stable sort、Out-place sort。 
最坏情况运行时间：O((n+k)d) 
最好情况运行时间：O((n+k)d)

public class RadixSort {
    public static void main(String[] args) {

        int[] array = {3,2,3,2,5,333,45566,2345678,78,990,12,432,56};
        radixSort(array,10,7);
        System.out.println(Arrays.toString(array));
    }
    private static void radixSort(int[] array,int radix, int distance) {
        int length = array.length;
        int[] temp = new int[length];
        int[] count = new int[radix];
        int divide = 1;

        for (int i = 0; i < distance; i++) {

            System.arraycopy(array, 0,temp, 0, length);
            Arrays.fill(count, 0);

            for (int j = 0; j < length; j++) {
                int tempKey = (temp[j]/divide)%radix;
                count[tempKey]++;
            }

            for (int j = 1; j < radix; j++) {
                count [j] = count[j] + count[j-1];
            }
            for (int j = length - 1; j >= 0; j--) {
                int tempKey = (temp[j]/divide)%radix;
                count[tempKey]--;
                array[count[tempKey]] = temp[j];
            }
            divide = divide * radix;
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

桶排序

假设输入数组的元素都在[0,1)之间。 
特性：out-place sort、stable sort。 
最坏情况运行时间：当分布不均匀时，全部元素都分到一个桶中，则O(n^2)，当然[算法导论8.4-2]也可以将插入排序换成堆排序、快速排序等，这样最坏情况就是O(nlgn)。 
最好情况运行时间：O(n)

public class BucketSort {

    public static void main(String[] args) {
        double array[] = { 0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.26, 0.12,
                0.23, 0.68 };
        bucketSort(array);
        System.out.println(Arrays.toString(array));
    }
    public static void bucketSort(double array[]) {
        int length = array.length;
        ArrayList arrList[] = new ArrayList[length];
        for (int i = 0; i < length; i++) {
            //0.7到0.79放在第8个桶里,编号7；第一个桶放0到0.09
            int temp = (int) Math.floor(10 * array[i]);
            if (null == arrList[temp])
                arrList[temp] = new ArrayList();
            arrList[temp].add(array[i]);
        }
        // 对每个桶中的数进行插入排序
        for (int i = 0; i < length; i++) {
            if (null != arrList[i]) {
                Collections.sort(arrList[i]);
            }
        }
        int count = 0;
        for (int i = 0; i < length; i++) {
            if (null != arrList[i]) {
                Iterator iter = arrList[i].iterator();
                while (iter.hasNext()) {
                    Double d = (Double) iter.next();
                    array[count] = d;
                    count++;
                }
            }
        }
    }
}
sike_java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
十大排序（含java代码）
qq_62928039的博客
03-29 5889
十大排序算法详解：包括冒泡排序、选择排序、快速排序、插入排序、计数排序、希尔排序、归并排序、桶排序、堆排序、基数排序
十大排序算法 JAVA代码
guanhang89的专栏
07-13 1万+
冒泡排序 插入排序 选择排序 希尔排序 归并排序 快速排序 堆排序 计数排序 基数排序 桶排序参考了这篇博客总体总结表：这个有个错误就是归并排序需要一个o(n)的辅助数组 冒泡排序主要思想：外层循环从1到n-1，内循环从当前外层的元素的下一个位置开始，依次和外层的元素比较，出现逆序就交换。 特点：stable sort（稳定性排序）、In-place sort（不占用额外的空间,只是交换元素）
Java&C++题解与拓展——leetcode937.重新排列日志文件【Collections.sort()、stable_sort()学习与使用】
菜鸡成长之路
05-03 683
leetcode937.重新排列日志文件解题思路，用Java和C++两种语言分别编写，并对所使用类和方法进行学习记录。
Java 七大排序代码合集
爱干饭的猿的博客
03-20 1526
1.七大排序详解请见：《Java 七大排序（详解 + 代码 + 变种）》 2. 代码合集： import java.util.ArrayDeque; import java.util.Deque; import java.util.concurrent.ThreadLocalRandom; /** * 七大排序 * * @author haomin * @date 2022/03/17 20:34 **/ public class SevenSort { // 取随机数
2020-09-19
Atplse的博客
09-19 525
假设我们现在对“6 1 2 7 9 3 4 5 10 8”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边，类似下面这种排列。 3 1 2 5 4 6 9 7 10 8 在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位置，假设这个位
java 排序算法
01-11
代码中列举了java常见的排序算法，并备有简单的注释信息，对于初级开发人员可供参考。
Java排序算法
09-03
尚硅谷Java排序算法PPT
Java排序算法总结之堆排序
09-03
主要介绍了Java排序算法总结之堆排序,详细分析了堆排序的原理与java实现技巧,需要的朋友可以参考下
Java排序算法实现：冒泡与选择排序示例代码
最新发布
01-04
Java排序算法实现资源 这个资源是关于Java中排序算法实现的简单示例。排序算法是计算机科学中的基础概念，用于按升序或降序排列数据集。这里提供了两种常见的排序算法实现：冒泡排序和选择排序。 冒泡排序（Bubble ...
Java实现七种【排序算法】+图解+完整代码+分析
Zhou_LC的博客
12-13 4284
参考书目：《大话数据结构》 一、冒泡排序（优化版）： 0.基本思想：一种交换排序，两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录位置。 1.思路图解： 2.代码实现： public class BubbleSort { public static void sort(int[] a) { int i, j; boolean flag = true; int n = a.length - 1; for (i = 1;
Java 必会10大的经典算法
xmt1139057136的专栏
09-30 1万+
本文来源：https://github.com/hustcc/JS-Sorting-Algorithm排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排...
【Java 数据结构】十大排序 (动图解析)
书生-w的博客
04-24 1万+
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
十大排序算法（Java实现）
ji_meng的博客
06-27 2167
1.冒泡排序 2.快速排序
详解Java常用排序算法（10种，含演示动画）
热门推荐
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-30 1万+
Java常用的排序算法有以下几种： 1. 冒泡排序；2. 选择排序；3. 插入排序；4. 希尔排序；5. 归并排序；6. 快速排序；7. 堆排序；8. 计数排序；9. 桶排序；10. 基数排序。 这些排序算法都有各自的优缺点，应根据具体情况选择适合的算法。
[js] 排序算法 (2)
aefg95955的博客
08-22 355
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 平方阶 (O(n2))。 线性对数阶 (O(nlog2n))。 O(n1+§))，§ 是介于 0 和 1 之间的常数。 线性阶 (O(n)) 。 n：数据规模. k：“桶”的个数. In-place：占用常数内存，不占用额外内存...
十大经典排序算法最强总结（含JAVA代码实现）
Java笔记虾
08-27 1241
点击上方“后端技术精选”，选择“置顶公众号”技术文章第一时间送达！作者：郭耀华cnblogs.com/guoyaohua/p/8600214.html最近几天在研究排序算...
十大排序算法实现与总结（Java语言）
q160336802的博客
04-09 1077
十大排序算法的总结 十种排序算法的总结 1.冒泡排序 2.选择排序 3.插入排序 4.希尔排序 5.归并排序 6.堆排序 7.快速排序 8. 计数排序 9.桶排序 10 基数排序
Java实现十大排序算法
qq_56517253的博客
12-27 973
马士兵教育十大排序算法讲解和记忆
java 排序算法
08-27
Java中常用的排序算法有很多种，以下是一些常见的排序算法： 1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果顺序错误就交换位置，重复这个过程直到所有元素都排好序。时间复杂度为O(n^2)。 2. 选择排序...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值