数据结构基本排序问题总结：

最新推荐文章于 2023-05-27 23:41:57 发布

DuLaLaLa2

最新推荐文章于 2023-05-27 23:41:57 发布

阅读量443

点赞数 1

分类专栏：笔记数据结构排序算法文章标签：数据结构算法排序算法

本文链接：https://blog.csdn.net/m0_53269573/article/details/124423508

版权

笔记同时被 3 个专栏收录

4 篇文章 0 订阅

订阅专栏

数据结构

1 篇文章 0 订阅

订阅专栏

排序算法

1 篇文章 0 订阅

订阅专栏

比较排序；总的分为以下四种：

选择排序
插入排序------直接插入排序和希尔排序
归并排序
交换排序------冒泡排序和快速排序

一种最简单的排序算法------选择排序：

过程：找到数组中最小的元素，将它和数组中第一个元素交换位置（如果是自身也就与自己交换），然后再剩下的元素中找到最小的元素，与第二个元素交换位置。以此直到最后一个元素。

总结即为：不断选择最小的元素放到数组的指定位置。

public class Selection {
    public static void main(String[] args) {
        Comparable [] a ={1, 3, 2, 6, 4, 5};
        sort(a);
    }


    public static void sort(Comparable[] a){
        //将a按升序排列
        int N = a.length;
        for (int i = 0; i < N; i++) {
            //将a[]与a[i...N]中最小的元素交换
            int min = i;
            for (int j = i+1; j < N; j++) {
                if (less(a[j], a[min]))
                    min = j;
            }
            exch(a,i,min);
        }
        show(a);
    }

    /**
     * 交换方法
     * @param a
     * @param i
     * @param j
     */
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    /**
     * 比较两值
     * @param v
     * @param m
     * @return v<m,返回true，否则false
     */
    private static boolean less(Comparable v, Comparable m) {
        return v.compareTo(m)<0;
    }

    /**
     * 打印数组
     * @param a
     */
    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+"");
        }
        System.out.println();
    }

}

插入排序：

直接插入排序：

public static void sort(Comparable[] a){
        //将a按升序排列
        int N = a.length;
        for (int i = 1; i < N; i++) {
            //将a[i]插入到a[i-1]、a[i-2]、a[i-3]...之中
            for (int j = i; j >0 && less(a[j],a[j-1]) ; j--) {
                exch(a,j,j-1);
            }
        }
        show(a);
    }

改进插入排序：

public static void insertSortAdvance(Comparable[] a) {
        for(int i=0; i<a.length; i++) {
            Comparable e = a[i];
            int j;
            for(j=i; j>0 && a[j-1].compareTo(e) > 0; j--) {//中断机制
                a[j] = a[j-1];
            }
            a[j] = e;
        }
        show(a);
    }

a[i] 每一次都循环与前一个元素进行比较，总的看来是与a[0]-a[i-1]都比较了一遍，但是只与比他大的进行交换操作（针对从小到大排列）。

（所以对一个很大的数组来说，一个接近有序的数组排序起来比随机的或是逆序的数组要快的多）

比较两种排序算法：

希尔排序-------基于插入排序的快速排序算法：

考虑了最小元素在数组的最右端，那样就需要移动N-1次，所以希尔排序交换不相邻元素的方法可以加快排序速度。

思想：对一个h有序数组（h个互相独立的有序数组，编制在一起），希尔排序也就是使用了不同增量（元素移动的距离由1变为h）的插入排序。

总结：首先确定一个h，然后分组，再在组内排序，使h变小，直到h=1,变为插入排序。

public static void sort(Comparable[] a){
        int N = a.length;
        int h = 1;
        while(h < N/3){
            h = h*3+1;//h的设置不固定
        }
        while(h>=1){
            for (int i = h; i < N; i++) {
                for (int j = i; j >=h && less(a[j],a[j-h]); j=j-h) {
                    exch(a,j,j-h);
                }
            }
            h=h/3;
        }
        show(a);
    }

归并排序：

优点：快速，与NlogN成正比（N为数组长度）；

缺点：耗费空间；

思想：将一个数组分为若干个短数组分别排序，得到多个有序数组，最后归并到一个数组中。

原地归并：

//原地归并的抽象方法
    public static void merge(Comparable[] a,int low,int mid,int high){
        Util util = Util.getInstance();
        int i = low;
        int j = mid+1;
        //辅助数组，装载复制的数组内容
        Comparable[] aux = new Comparable[a.length];
        //将原数组复制一份，再一个一个添加
        for (int k = low; k <= high; k++) {
            aux[k] = a[k];
        }

        for (int k = low; k <=high ; k++) {
            if (i>mid)
                a[k] = aux[j++];
            else if (k>high)
                a[k] = aux[i++];
            //less()方法放到工具类中了，采用单利模式，节省代码
            else if (util.less(aux[j],aux[i]))
                a[k] = aux[j++];
            else
                a[k] = aux[i++];

        }
        util.show(a);
    }

任意长度的两组有序数组，按顺序归并到一个数组内，实现排序。

递归归并：------采用分治思想，对两个数组的子数组分组，不断平分，知道子数组元素个数为1，再递归合并。见代码：

public class Merge {

    private static Comparable[] aux;
    //原地归并的抽象方法
    public static void merge(Comparable[] a,int low,int mid,int high){
        Util util = Util.getInstance();
        int i = low;
        int j = mid+1;
        //辅助数组，装载复制的数组内容
        aux = new Comparable[a.length];
        //将原数组复制一份，再一个一个添加
        for (int k = low; k <= high; k++) {
            aux[k] = a[k];
        }

        for (int k = low; k <=high ; k++) {
            if (i>mid)
                a[k] = aux[j++];
            else if (k>high)
                a[k] = aux[i++];
            //less()方法放到工具类中了，采用单利模式，节省代码
            else if (util.less(aux[j],aux[i]))
                a[k] = aux[j++];
            else
                a[k] = aux[i++];

        }
        util.show(a);
    }
    
    private static void sort(Comparable[] a){
        aux = new Comparable[a.length];
        sort(a,0,a.length-1);

    }

    private static void sort(Comparable[] a, int low, int high) {
        if(high<=low)
            return;
        int mid = low + (high-low)/2;
        sort(a,low,mid);
        sort(a,mid+1,high);
        merge(a,low,mid,high);
    }


    public static void main(String[] args) {
        Comparable[] a = {"E","E","G","M","R","A","C","E","R","T"};
        //merge(a,0,4,9);
        sort(a);
    }
}

如果把递归归并称为自顶向下的归并，那么下面一种就是自底向上的归并。

递归归并是将大问题，大数组分解为小数组，排序后归并；

那么自底向上的归并方法就是先归并小数组，两两归并，四四归并。。。最后直到将整个数组归并在一起。

采用这种方法的优点：代码量更小。

    //辅助数组
    private static Comparable[] aux;
    //工具单例
    private static Exam u = Exam.getInstance();

    public static void sort(Comparable[] a){
        int N = a.length;
        aux = new Comparable[N];
        for (int sz = 1; sz < N; sz=sz+sz) {//sz为子数组大小
            for (int low = 0; low < N-sz; low+=sz+sz) {
                //调用merge（a,low,mid,high）;归并函数
                merge(a,low,low+sz-1,Math.min(low+sz+sz-1,N-1));
            }
        }
        u.show(a);
    }

应用最广泛的排序算法------快速排序

优点：实现简单，适用于各种不同的输入数据且在一般应用中比其他排序算法快得多。

缺点：非常脆弱，要十分小心才能避免低劣的性能。

快速排序在方式上与归并排序是互补的：如下

快速排序的排列方式是当两个子数组都有序时整个数组也就有序了。

快排的递归调用发生在数组处理之后（归并是先递归后处理数组）；

快排中数组分解成子数组取决于数组的内容，而不是对半分了；

public class Quick {

    private static Exam e = Exam.getInstance();

    public static void sort(Comparable[] a){
        StdRandom.shuffle(a);//消除对输入的依赖、
        sort(a,0,a.length-1);
        e.show(a);
    }
    private static void sort(Comparable[] a,int low,int high){
        if(high<=low)
            return;
        int j = partition(a,low,high);//切分方法
        sort(a,low,j-1);//左半部分排序
        sort(a,j+1,high);//右半部分排序
    }
    private static int partition(Comparable[] a,int low,int high){
        //左右扫描指针
        int i = low;
        int j = high+1;
        //v为切分元素
        Comparable v = a[low];
        while (true) {
            //扫免左右，检查扫描是否结束并交换
            while(e.less(a[++i],v))
                if (i==high)
                    break;
            while (e.less(v,a[--j]))
                if (j==low)
                    break;
            if (i>=j)
                break;
            e.exch(a,i,j);
        }
        e.exch(a,low,j);//将v=a[j]放到正确位置
        return j;// 此时满足a[low..j-1] <= a[j] <= a[j+1..high]
    }

    public static void main(String[] args) {
        Comparable[] a = {"K","R","A","T","E","L","E","P","U","I","M","Q","C","X","O","S"};
        sort(a);
    }
}

三向切分的快速排序：

过程：

a[i] 小于 v ，将 a[lt] 和 a[i] 交换，将 lt 和 i 都加一；

a[i] 大于 v ， a[gt] 和 a[i] 交，将 gt 和 i 减一；

a[i] 等于 v ，将 i 加一；

结果：

将数组划分为三部分了：<v ; =v ; >v ;

public static void sort(Comparable[] a,int low,int high) {
        if(high<=low)
            return;
        int lt = low;
        int i = low+1;
        int gt = high;
        Comparable v = a[low];
        while(i<=gt){
            int cmp = a[i].compareTo(v);
            if (cmp<0)
                e.exch(a,lt++,i++);
            else if(cmp>0)
                e.exch(a,i,gt--);
            else
                i++;
        }
        sort(a,low,lt-1);
        sort(a,gt+1,high);
    }

冒泡排序：

按升序排列来看，一趟下来最大的数就沉到数组最底部也就是最右端。

第二趟，倒数第二大数落于a[a.length-2]...

清楚两个循环：

外层循环：确定趟数，便于理解：不断选出最大的数放在数组末端（或是不断选出最小数放于数组前端，需要多少次）；

内层循环：比较次数，因为第一次确定最大数后，第二次在确定最大数，所比较的次数会变少，所以 j 会 i 的变化而变化：j < a.length-1-i 。

private static void sort(Comparable[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            /*内循环为每趟比较的次数，第i趟比较array.length-i次 */
            for (int j = 0; j < a.length - 1 - i; j++) {
                /*相邻元素比较，若满足条件则交换（升序为左大于右，降序反之） */
                if (!e.less(a[j], a[j + 1])) {
                    e.exch(a, j, j + 1);
                }
                /*查看每趟比较后的数组元素*/
                System.out.println("第 " + (i + 1) + " 趟，第 " + (j + 1) + " 次比较后的结果：");
                for (int k = 0; k < a.length; k++) {
                    System.out.print(a[k] + " ");
                }
                System.out.println();
            }
        }
    }

DuLaLaLa2

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构基本排序问题总结：

比较排序；总的分为以下四种：选择排序插入排序------直接插入排序和希尔排序归并排序交换排序------冒泡排序和快速排序一种最简单的排序算法------选择排序：过程：找到数组中最小的元素，将它和数组中第一个元素交换位置（如果是自身也就与自己交换），然后再剩下的元素中找到最小的元素，与第二个元素交换位置。以此直到最后一个元素。总结即为：不断选择最小的元素放到数组的指定位置。public class Selection { public static void.
复制链接

扫一扫