排序方法

最新推荐文章于 2024-09-03 07:11:16 发布
最新推荐文章于 2024-09-03 07:11:16 发布
阅读量273 收藏 1
点赞数
文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ashenyongye/article/details/52486715
版权

冒牌排序

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

插入排序

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

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

选择排序

**特性：**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;

        }
    }
}

希尔排序

思想：基于插入排序，交换不相邻的元素已对数组的局部进行排序，并最终用插入排序将局部有序的数组排序。思想是使数组中任意间隔为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;
        }
    }
}

归并排序

**特点：**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++];
        }
    }
}
自底向上：

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

快速排序

**特性：**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 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;
        }
    }
}

堆排序

**特性：**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;
    }
}
王傅永
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
排序方法稳定性总结
醉卧考场君莫笑
11-16 4773
文章目录前言一、排序算法稳定性是什么？二、各个算法解析1.选择排序2.冒泡排序3.插入排序4. 归并排序5.快速排序6.堆排序7.桶排序思想的算法总结 前言 这次将介绍各种排序算法的稳定性和一些小结论 一、排序算法稳定性是什么？ 它说的是，当一个排序算法对一个数组排序的时候，两个相同的数，在排序后相对位置有没有发生变化。没有则稳定 二、各个算法解析 1.选择排序 选择排序算法是不稳定的，它是先遍历一次数组，找到一个最小值，和已排好序的边界后一个元素交换。这个交换的步骤就让选择排序变得不稳定。如果交换过.
MySort.ts TS通用排序方法
04-27
* 通用排序方法 * @param arr 需要排序的数组 * @param field 排序字段 值类型传null 单字段传string 多字段传数组[["field1", SortType], ["field2", SortType]] 可传属性名 方法名 * @param sortType 排序类型...
python字典排序方法
LHJCSDNYL的博客
01-16 8万+
字典是“键-值对”的无序可变序列 在实际运用中，对字典进行排序是一个比较常见的操作，主要用到了python内置函数sorted()，该函数可以对所有可迭代的对象进行排序操作。 语法（python3）： sorted(iterable, key=None,reverse=False) 参数说明： iterable：可迭代对象，即可以用for循环进行迭代的对象； key：主要是用来进行比较的元素，只有一个参数，具体的函数参数取自于可迭代对象中，用来指定可迭代对象中的一个元素来进行排序； reverse：排序规
C语言常用排序方法
m0_73685411的博客
12-08 6453
C语言常用的几种排序方法
JAVA内置排序方法
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
12-21 2308
排序是按特定顺序组织数据项集合的过程，通常是升序或降序。有许多不同的算法可用于对数据进行排序，包括冒泡排序、选择排序、插入排序、归并排序和快速排序等。 Java 是一种编程语言，它提供了许多用于对数据进行排序的内置方法，包括Arrays.sort() 和 Collections.sort() 这些方法使用高效的排序算法来快速高效地对数据进行排序。
c语言常见的排序方法
Jacksjie的博客
06-27 3846
c语言学习的几种排序方法。
java数组排序方法
心若向阳 无谓悲伤
12-14 6333
java数组中内容的2种排序方法
Set排序方法
岸河世界
04-22 1万+
在讲解Set集合排序的几种方法之前，我们应该先清楚Set集合的几种类型以及特点，才能有效使用起来。 Set集合的特点 ​ Set不允许包含相同的元素，如果试图把两个相同元素加入同一个集合中，add方法返回false。 ​ Set判断两个对象相同不是使用==运算符，而是根据equals方法。也就是说，只要两个对象用equals方法比较返回true，Set就不会同时接受这两个对象。 Set集合的分...
八大排序算法（C语言实现）
热门推荐
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
数组对象的排序方法
庚中
03-19 6792
//数组对象方法排序:从小到大 function sortByKey(array,key){ return array.sort(function(a,b){ var x=a[key];//如果要从大到小,把x,y互换就好 var y=b[key]; return ((x<y)?-1:((x>y)?1:0)); }); } //...
数组元素的排序方法
dyc200709的博客
08-17 4440
数组元素的排序
总结各类排序方法
05-05
总结各类排序方法。排序问题一直是计算机技术研究的重要问题，排序算法的好坏直接影响程序的执行速度和辅助存储空间的占有量。此代码将详细分析常见的各种排序算法，并从时间复杂度、空间复杂度、适用情况等多个方面...
mysql排序方法
12-29
几种mysql利用sql语句进行距离排序的方法，亲测可用，大家可放心研究
MyBatisPlus条件构造器带条件排序方法orderBy、orderByDesc、orderByAsc使用示例代码
04-24
在实际开发中，我们经常需要对查询结果进行排序，MyBatisPlus为此提供了`orderBy`、`orderByDesc`和`orderByAsc`三个方法，方便我们实现条件排序。下面将详细介绍这三个方法的使用及原理。 `orderBy`方法是...
【数据结构】排序算法篇二
最新发布
2303_80737493的博客
09-03 1547
1. 快速排序（hoare版本） （1）基本思想： （2）动态图解： （3）代码实现： （4）特性总结： 2. 快速排序（推荐：前后指针版本） （1）基本思想： （2）动态图解： （3）静态图解（一趟）： （4）代码实现： 3. 快速排序（挖坑法） （1）具体步骤： （2）静态图解： （3）动态图解： （4）代码实现： 4. 计数排序 （1）基本思想： （2）具体步骤： （3）代码实现： （4）特性总结： 5. 归并排序（递归法） （1）基本思想： （2）动态图解： （3）代码实现： （4）辅助理解：
Java进阶13讲__第六讲
I am the light coursing in the soul of the moon.
09-02 426
Java业务逻辑-1(冒泡排序)-CSDN博客//选择排序i++) {j++) {//二分查找return -1;return mid;
C++实现归并排序
m0_50127633的博客
09-02 334
归并排序将待排序数组分成两个子数组，分别对这两个子数组进行排序，然后将排序好的子数组合并，得到排序后的数组。：通过递归的方式，不断地将数组一分为二，直到每个子数组只有一个元素（此时视为有序）。：将两个有序子数组合并成一个有序数组。
数据结构——排序上
hedhjd的博客
09-02 655
预排序。
数据结构---五大排序---哈希表---二分查找法
m0_65301172的博客
09-02 526
int data;}Data_t;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值