简单排序算法(插入、选择、冒泡、希尔 )

最新推荐文章于 2024-06-01 18:20:50 发布

转载最新推荐文章于 2024-06-01 18:20:50 发布 · 149 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/dreamness/blog/3036659

文章标签：

#数据结构与算法 #python

本文详细介绍了多种排序算法，包括插入排序、改进的插入排序、选择排序、冒泡排序、希尔排序等，通过具体的代码实例展示了每种算法的工作原理及其实现方式。

2019独角兽企业重金招聘Python工程师标准>>>

插入排序

对于一个长度为N的数组，维持前m个元素是有序的，不断扩大m的大小，知道m等于N。
对原本近乎有序的数组进行排序，更适合使用插入排序。

    public static void InsertionSort(Comparable[] data){
        for (int i = 1; i < data.length; i ++){
            for (int j = i; j > 0; j --){
                if (data[j].compareTo(data[j - 1]) < 0){
                    Comparable tmp = data[j];
                    data[j] = data[j - 1];
                    data[j - 1] = tmp;
                }
            }
        }
    }

改进的插入排序

上面的程序使用了两两交换的方式，将带排序的元素插入到已经排好的序列中，会有性能损失。
下面的程序中，将要插入的元素保存起来，使用后面元素等于前面元素这种赋值的方法实现元素的移动，最后将待排元素插入到合适的位置。

    public static void InsertionSort2(Comparable[] data){
        for (int i = 1; i < data.length; i ++){
            Comparable tmp = data[i];
            for (int j = i - 1; j >= 0; j --){
                if (data[j].compareTo(tmp) > 0){
                    data[j + 1] = data [j];
                }else{
                    data[j + 1] = tmp;
                    break;
                }
            }
        }
    }

选择排序

依次在数组中寻找最小的，第2小的，第3小的，...，依次把他们放到该在的位置。

        for (int i = 0; i < data.length; i ++){
            int min_j_index = i;
            for (int j = i + 1; j < data.length; j ++){
                if (data[min_j_index].compareTo(data[j]) > 0){
                    min_j_index = j;
                }
            }
            Comparable tmp = data[min_j_index];
            data[min_j_index] = data[i];
            data[i] = tmp;
        }

冒泡排序

不断得从头到尾，使得后面小于前面的数，每次遍历都可以让最后一个数是最大的。
一直遍历N次，就可以保证所有元素有序。

        for (int i = 0; i < data.length; i ++){
            for(int j = 0; j < data.length - i - 1; j ++){
                if (data[j].compareTo(data[j + 1]) > 0){
                    Comparable tmp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = tmp;
                }
            }
        }

希尔排序

先选取步长为总长度的1/3(向下取整)，然后对按照步长计算的子序列排序；
然后步长为原步长的1/3，再进行排序；
一直进行到步长为1。

        for (int increase = (int)Math.floor(data.length / 3.); increase > 0; increase = (int)Math.floor(increase / 3.)){
            for (int i = increase; i < data.length; i += increase) {
                Comparable tmp = data[i];
                for (int j = i - increase; j >= 0; j -= increase) {
                    if (data[j].compareTo(tmp) > 0) {
                        data[j + increase] = data[j];
                    } else {
                        data[j + increase] = tmp;
                        break;
                    }
                }
            }
        }

转载于:https://my.oschina.net/dreamness/blog/3036659