常见排序算法详解（Java）

其他 2021-03-03 16:02:49 阅读次数: 0

目录

（1）Comparable接口介绍

Java提供了一个接口Comparable就是用来定义排序 规则的，在这里我们以案例的形式对Comparable接口做一个简单的回顾。

需求：

1.定义一个学生类Student，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则；

2.定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)完成测试

学生类：

package cn.itcast.algorithm.sort;

/**
 * 1.定义一个学生类Student，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则；
 * @author caizhengjie
 */
public class Student implements Comparable<Student>{
    
    
    private String username;
    private int age;

    public String getUsername() {
    
    
        return username;
    }

    public void setUsername(String username) {
    
    
        this.username = username;
    }

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        this.age = age;
    }

    @Override
    public String toString() {
    
    
        return "Student{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
    
    
        return this.getAge() - o.getAge();
    }
}

测试类：

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.sort.Student;

/**
 * 2.定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)完成测试
 */
public class TestComparable {
    
    

    public static void main(String[] args) {
    
    
        Student s1 = new Student();
        s1.setUsername("alex");
        s1.setAge(10);

        Student s2 = new Student();
        s2.setUsername("jack");
        s2.setAge(20);

        Comparable<Student> max = getMax(s1,s2);
        System.out.println(max);
    }
    public static Comparable<Student> getMax(Comparable<Student> c1,Comparable<Student> c2){
    
    
        int result = c1.compareTo((Student) c2);

        // 如果result<0，c1<c2
        // 如果result>0，c1>c2
        // 如果result=0，c1=c2

        if (result >= 0){
    
    
            return c1;
        } else {
    
    
            return c2;
        }

    }
}

运行结果：

Student{
    
    username='jack', age=20}

（2）冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

需求：

  • 排序前：{4,5,6,3,2,1}
  • 排序后：{1,2,3,4,5,6}

排序原理：

  1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。

  2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大 值。

在这里插入图片描述
冒泡排序API设计：
在这里插入图片描述
冒泡排序的代码实现：

package cn.itcast.algorithm.sort;

/**
 * @author ：caizhengjie
 * @description：冒泡排序
 * @date ：2021/1/25 10:32 下午
 */
public class Bubble {
    
    

    /**
     * 对数组arr中的元素进行排序
     * @param arr
     */
    public static void sort(Comparable<Integer>[] arr){
    
    

        for (int i = arr.length - 1;i > 0;i--){
    
    
            for (int j = 0;j < i;j++){
    
    
                if (greater(arr[j],arr[j+1])){
    
    
                    exch(arr,j,j+1);
                }
            }
        }
    }

    /**
     * 比较v元素是否大于w元素
     * @param v
     * @param w
     * @return
     */
    public static boolean greater(Comparable<Integer> v,Comparable<Integer> w){
    
    
        return v.compareTo((Integer) w)>0;
    }

    /**
     * 数组元素i和j交换位置
     * @param arr
     * @param i
     * @param j
     */
    public static void exch(Comparable<Integer>[] arr,int i,int j){
    
    

        Comparable<Integer> comparable = arr[i];
        arr[i] = arr[j];
        arr[j] = comparable;
    }
}

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.sort.Bubble;

import java.util.Arrays;

/**
 * @author ：caizhengjie
 * @description：TODO
 * @date ：2021/1/25 10:57 下午
 */
public class BubbleTest {
    
    
    public static void main(String[] args) {
    
    
        Integer[] arr = {
    
    4,5,6,3,2,1};
        Bubble.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

冒泡排序的时间复杂度分析 ：
冒泡排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以， 我们分析冒泡排序的时间复杂度，主要分析一下内层循环体的执行次数即可。

在最坏情况下，也就是假如要排序的元素为{6,5,4,3,2,1}逆序，那么：
元素比较的次数为：
(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

元素交换的次数为：
(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

总执行次数为：
(N ^ 2/2-N/2)+(N ^ 2/2-N/2)=N^2-N;

按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2).

（3）选择排序

选择排序是一种更加简单直观的排序方法。

需求：

  • 排序前：{4,6,8,7,9,2,10,1}
  • 排序后：{1,2,4,5,7,8,9,10}

排序原理：

  1. 每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处 的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引

  2. 交换第一个索引处和最小值所在的索引处的值

在这里插入图片描述
选择排序API设计：
在这里插入图片描述
选择排序的代码实现：

package cn.itcast.algorithm.sort;

/**
 * @author ：caizhengjie
 * @description：选择排序
 * @date ：2021/1/26 10:14 下午
 */
public class Selection {
    
    

    /**
     * 对数组arr中的元素进行排序
     * @param arr
     */
    public static void sort(Comparable<Integer>[] arr){
    
    
        for (int i=0;i <= arr.length-2;i++){
    
    
            // 假定本次遍历，最小值所在的索引是i
            int minIndex = i;
            for (int j=i+1;j<arr.length;j++){
    
    
                if (greater(arr[minIndex],arr[j])){
    
    
                    // 跟最小值换索引
                    minIndex = j;
                }
            }
            // 交换i索引处和minTndex索引处的值
            exch(arr,i,minIndex);
        }
    }

    /**
     * 比较v元素是否大于w元素
     * @param v
     * @param w
     * @return
     */
    public static boolean greater(Comparable<Integer> v,Comparable<Integer> w){
    
    
        return v.compareTo((Integer) w)>0;
    }

    /**
     * 数组元素i和j交换位置
     * @param arr
     * @param i
     * @param j
     */
    public static void exch(Comparable<Integer>[] arr,int i,int j){
    
    

        Comparable<Integer> comparable = arr[i];
        arr[i] = arr[j];
        arr[j] = comparable;
    }
}

package cn.itcast.algorithm.test;
import cn.itcast.algorithm.sort.Selection;

import java.util.Arrays;

/**
 * @author ：caizhengjie
 * @description：TODO
 * @date ：2021/1/26 10:35 下午
 */
public class SelectionTest {
    
    
    public static void main(String[] args) {
    
    
        Integer[] arr = {
    
    4,6,8,7,9,2,10,1};
        Selection.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

选择排序的时间复杂度分析：

选择排序使用了双层for循环，其中外层循环完成了数据交换，内层循环完成了数据比较，所以我们分别统计数据 交换次数和数据比较次数：

数据比较次数：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

数据交换次数： N-1

时间复杂度：N ^ 2/2-N/2+（N-1）=N ^ 2/2+N/2-1; 根据大O推导法则，保留最高阶项，去除常数因子，时间复杂度为O(N^2);

（4）插入排序

插入排序（Insertion sort）是一种简单直观且稳定的排序算法。

需求：

  • 排序前：{4,3,2,10,12,1,5,6}
  • 排序后：{1,2,3,4,5,6,10,12}

排序原理：

  1. 把所有的元素分为两组，已经排序的和未排序的；

  2. 找到未排序的组中的第一个元素，向已经排序的组中进行插入；

  3. 倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待 插入元素放到这个位置，其他的元素向后移动一位；

在这里插入图片描述

插入排序API设计：
在这里插入图片描述
插入排序代码实现：

package cn.itcast.algorithm.sort;

/**
 * @author ：caizhengjie
 * @description：插入排序
 * @date ：2021/1/26 10:45 下午
 */
public class Insertion {
    
    

    /**
     * 对数组arr中的元素进行排序
     * @param arr
     */
    public static void sort(Comparable<Integer>[] arr){
    
    

        for (int i=1;i< arr.length;i++){
    
    
            // 当前元素为a[i]，依次和i前面的元素比较，找到一个小于等于a[i]的元素
            for (int j=i;j>0;j--){
    
    
                if (greater(arr[j-1],arr[j])){
    
    
                    // 交换元素
                    exch(arr,j-1,j);
                } else {
    
    
                    // 找到了该元素，结束
                    break;
                }
            }
        }
    }
    /**
     * 比较v元素是否大于w元素
     * @param v
     * @param w
     * @return
     */
    public static boolean greater(Comparable<Integer> v,Comparable<Integer> w){
    
    
        return v.compareTo((Integer) w)>0;
    }

    /**
     * 数组元素i和j交换位置
     * @param arr
     * @param i
     * @param j
     */
    public static void exch(Comparable<Integer>[] arr,int i,int j){
    
    

        Comparable<Integer> comparable = arr[i];
        arr[i] = arr[j];
        arr[j] = comparable;
    }
}

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.sort.Insertion;

import java.util.Arrays;

/**
 * @author ：caizhengjie
 * @description：TODO
 * @date ：2021/1/26 10:52 下午
 */
public class InsertionTest {
    
    
    public static void main(String[] args) {
    
    
        Integer[] arr = {
    
    4,3,2,10,12,1,5,6};
        Insertion.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

插入排序的时间复杂度分析：
插入排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析插入排序的时间复 杂度，主要分析一下内层循环体的执行次数即可。

最坏情况，也就是待排序的数组元素为{12,10,6,5,4,3,2,1}，那么：

比较的次数为：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

交换的次数为：

(N-1)+(N-2)+(N-3)+…+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

总执行次数为：

(N ^ 2/2-N/2)+(N ^ 2/2-N/2)=N^2-N;

按照大O推导法则，保留函数中的最高阶项那么最终插入排序的时间复杂度为O(N^2).

（5）希尔排序

希尔排序是插入排序的一种，又称“缩小增量排序”，是插入排序算法的一种更高效的改进版本。

需求：

  • 排序前：{9,1,2,5,7,4,8,6,3,5}
  • 排序后：{1,2,3,4,5,5,6,7,8,9}

排序原理：

  1. 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；

  2. 对分好组的每一组数据完成插入排序；

  3. 减小增长量，最小减为1，重复第二步操作。

在这里插入图片描述
增长量h的确定：增长量h的值每一固定的规则，我们这里采用以下规则：

int h=1 
while(h<5){
    
    
	h=2h+1；//3,7 
} 
// 循环结束后我们就可以确定h的最大值； 
// h的减小规则为：
h=h/2

希尔排序的API设计：
在这里插入图片描述
希尔排序的代码实现：

package cn.itcast.algorithm.sort;

/**
 * @author ：caizhengjie
 * @description：希尔排序
 * @date ：2021/1/30 4:28 下午
 */
public class Shell {
    
    

    /**
     * 对数组arr中的元素进行排序
     * @param arr
     */
    public static void sort(Comparable<Integer>[] arr){
    
    
        // 1.根据数组arr的长度，确定增长量h的初始值
        int h = 1;
        while (h < arr.length/2){
    
    
            h = 2*h + 1;
        }

        // 2.希尔排序
        while (h >= 1){
    
    
            // 找到待插入的元素
            for (int i = h;i < arr.length;i++){
    
    
                // arr[i]就是待插入的元素,把arr[i]插入到arr[i-h],arr[i-2h],arr[i-3h]...序列中
                for (int j = i;j >= h;j-=h){
    
    
                    //arr[j]就是待插入元素，依次和arr[j-h],arr[j-2h],arr[j-3h]进行比较，
                    // 如果arr[j]小，那么 交换位置，如果不小于，arr[j]大，则插入完成。
                    if (greater(arr[j - h],arr[j])){
    
    
                        // 交换元素
                        exch(arr,j-h,j);
                    } else {
    
    
                        // 带插入元素已经找到合适的位置，结束循环
                        break;
                    }

                }
            }
            // 减少h的值
            h = h/2;
        }
    }

    /**
     * 比较v元素是否大于w元素
     * @param v
     * @param w
     * @return
     */
    public static boolean greater(Comparable<Integer> v,Comparable<Integer> w){
    
    
        return v.compareTo((Integer) w)>0;
    }

    /**
     * 数组元素i和j交换位置
     * @param arr
     * @param i
     * @param j
     */
    public static void exch(Comparable<Integer>[] arr,int i,int j){
    
    

        Comparable<Integer> comparable = arr[i];
        arr[i] = arr[j];
        arr[j] = comparable;
    }
}

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.sort.Shell;

import java.util.Arrays;

/**
 * @author ：caizhengjie
 * @description：TODO
 * @date ：2021/1/30 4:46 下午
 */
public class ShellTest {
    
    
    public static void main(String[] args) {
    
    
        Integer[] arr = {
    
    9,1,2,5,7,4,8,6,3,5};
        Shell.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

希尔排序的时间复杂度分析：
我们可以使用事后分析法对希尔排序和插入排序做性能比较。

在资料的测试数据文件夹下有一个reverse_shell_insertion.txt文件，里面存放的是从100000到1的逆向数据，我们 可以根据这个批量数据完成测试。测试的思想：在执行排序前前记录一个时间，在排序完成后记录一个时间，两个 时间的时间差就是排序的耗时。

希尔排序和插入排序性能比较测试代码：

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.sort.Insertion;
import cn.itcast.algorithm.sort.Shell;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;

/**
 * @author ：caizhengjie
 * @description：TODO
 * @date ：2021/1/30 5:07 下午
 */
public class SortCompare {
    
    
    public static void main(String[] args) throws Exception {
    
    
        // 创建一个ArrayList集合，保存读取出来的整数
        ArrayList<Integer> list = new ArrayList<>();

        // 读取reverse_arr.txt文件并保存到ArrayList中
        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(new FileInputStream("resources/reverse_arr.txt")));

        while (bufferedReader.readLine() != null){
    
    
            // line是字符串，把line换成Integer，存储到集合中
            int i = Integer.parseInt(bufferedReader.readLine());
            list.add(i);
        }
        bufferedReader.close();

        // 把集合转换成数组
        Integer[] arr = new Integer[list.size()];
        list.toArray(arr);

        // 调用测试代码完成测试
        // 希尔排序：18毫秒
        // testShell(arr);
        // 插入排序：5057毫秒
        testInsertion(arr);
    }

    /**
     * 测试希尔排序
     * @param arr
     */
    public static void testShell(Integer[] arr){
    
    
        // 获取执行前的时间
        long start = System.currentTimeMillis();
        // 执行算法代码
        Shell.sort(arr);
        // 获取执行之后的时间
        long end = System.currentTimeMillis();
        // 算出程序执行的时间并输出
        System.out.println("希尔排序的执行时间为："+(end - start)+"毫秒");
    }

    /**
     * 测试插入排序
     * @param arr
     */
    public static void testInsertion(Integer[] arr){
    
    
        // 获取执行前的时间
        long start = System.currentTimeMillis();
        // 执行算法代码
        Insertion.sort(arr);
        // 获取执行之后的时间
        long end = System.currentTimeMillis();
        // 算出程序执行的时间并输出
        System.out.println("插入排序的执行时间为："+(end - start)+"毫秒");
    }
}

通过测试发现，在处理大批量数据时，希尔排序的性能确实高于插入排序。

（6）归并排序

（1）递归

正式学习归并排序之前，我们得先学习一下递归算法。

定义：

定义方法时，在方法内部调用方法本身，称之为递归.

public void show(){
    
     
	System.out.println("aaaa"); 
	show(); 
}

作用：

它通常把一个大型复杂的问题，层层转换为一个与原问题相似的，规模较小的问题来求解。递归策略只需要少量的 程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

注意事项：
在递归中，不能无限制的调用自己，必须要有边界条件，能够让递归结束，因为每一次递归调用都会在栈内存开辟 新的空间，重新执行方法，如果递归的层级太深，很容易造成栈内存溢出。

在这里插入图片描述
需求：

请定义一个方法，使用递归完成求N的阶乘；

分析：

1!: 2!: 3!: 4!: ... n!:

1 2*1=2*1! 3*2*1=3*2! 4*3*2*1=4*3!

n*(n-1)*(n-2)...*2*1=n*(n-1)!

所以，假设有一个方法factorial(n)用来求n的阶乘，那么n的阶乘还可以表示为n*factorial(n-1)

代码实现：

package cn.itcast.algorithm.test;

/**
 * @author ：caizhengjie
 * @description：TODO
 * @date ：2021/1/31 1:54 下午
 */
public class FactorialTest {
    
    
    public static void main(String[] args) {
    
    
        int result = factorial(5);
        System.out.println(result);
    }

    public static int factorial(int n){
    
    
        if (n == 1){
    
    
            return 1;
        }
        return n*factorial(n-1);
    }
}

（2）归并排序

归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子 序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序 表，称为二路归并。

需求：

  • 排序前：{8,4,5,7,1,3,6,2}
  • 排序后：{1,2,3,4,5,6,7,8}

排序原理：

  1. 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是 1为止。

  2. 将相邻的两个子组进行合并成一个有序的大组；

  3. 不断的重复步骤2，直到最终只有一个组为止。

在这里插入图片描述
归并排序 API设计：
在这里插入图片描述
归并原理：
在这里插入图片描述
归并排序代码实现：

package cn.itcast.algorithm.sort;

/**
 * @author ：caizhengjie
 * @description：归并排序
 * @date ：2021/1/31 2:00 下午
 */
public class Merge {
    
    

    /**
     * 归并所需要的数组
     */
    private static Comparable<Integer>[] assist;

    /**
     * 对数组arr中的元素进行排序
     * @param arr
     */
    public static void sort(Comparable<Integer>[] arr){
    
    
        // 初始化辅助数组
        assist = new Comparable[arr.length];
        // 定义一个lo变量，和hi变量，分别记录数组中最小索引和最大索引
        int lo = 0;
        int hi = arr.length - 1;
        // 调用sort重载方法完成数组arr中从索引lo到索引hi的元素排序
        sort(arr,lo,hi);

    }

    /**
     * 对数组arr中从lo到hi的元素进行排序
     * @param arr
     * @param lo
     * @param hi
     */
    public static void sort(Comparable<Integer>[] arr,int lo,int hi){
    
    
        // 安全性比较
        if (lo == hi){
    
    
            return;
        }

        // 对lo到hi之间的数据进行分为两个组
        int mid = lo + (hi - lo) / 2;

        // 分别对每一组数据进行排序
        sort(arr, lo, mid);
        sort(arr, mid+1, hi);

        // 在把两个数组中的数据进行归并
        merge(arr,lo,mid,hi);
    }

    /**
     * 对数组中从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并
     * @param arr
     * @param lo
     * @param mid
     * @param hi
     */
    public static void merge(Comparable<Integer>[] arr,int lo,int mid,int hi){
    
    

        // 定义一个指针，指向assist数组中开始填充数据的索引
        int i = lo;
        // 定义一个指针，指向第一组数据的第一个元素
        int p1 = lo;
        // 定义一个指针，指向第二组数据的第一个元素
        int p2 = mid + 1;

        // 遍历，移动p1指针和p2指针，比较对应索引的值，找出小的那个，放到辅助数组对应的索引
        while (p1 <= mid && p2 <= hi){
    
    
            // 比较对应索引处的值
            if (less(arr[p1],arr[p2])){
    
    
                assist[i++] = arr[p1++];
            } else {
    
    
                assist[i++] = arr[p2++];
            }
        }

        // 遍历，如果p1的指针没有走完，那么顺序移动p1指针，把对应的元素放到辅助数组的对应索引
        while (p1 <= mid){
    
    
            assist[i++] = arr[p1++];
        }

        // 遍历，如果p2的指针没有走完，那么顺序移动p2指针，把对应的元素放到辅助数组的对应索引
        while (p2 <= hi){
    
    
            assist[i++] = arr[p2++];
        }

        // 把辅助数组中的元素拷贝到原数组中
        for(int index = lo;index<=hi;index++){
    
    
            arr[index] = assist[index];
        }
    }

    /**
     * 比较v元素是否小于w元素
     * @param v
     * @param w
     * @return
     */
    public static boolean less(Comparable<Integer> v,Comparable<Integer> w){
    
    
        return v.compareTo((Integer) w)<0;
    }

    /**
     * 数组元素i和j交换位置
     * @param arr
     * @param i
     * @param j
     */
    public static void exch(Comparable<Integer>[] arr,int i,int j){
    
    

        Comparable<Integer> comparable = arr[i];
        arr[i] = arr[j];
        arr[j] = comparable;
    }

}

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.sort.Merge;

import java.util.Arrays;

/**
 * @author ：caizhengjie
 * @description：TODO
 * @date ：2021/1/31 3:10 下午
 */
public class MergeTest {
    
    
    public static void main(String[] args) {
    
    
        Integer[] arr = {
    
    8,4,5,6,2,3,7,9,1};
        Merge.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

归并排序时间复杂度分析：
归并排序是分治思想的最典型的例子，上面的算法中，对a[lo…hi]进行排序，先将它分为a[lo…mid]和a[mid+1…hi] 两部分，分别通过递归调用将他们单独排序，最后将有序的子数组归并为最终的排序结果。该递归的出口在于如果 一个数组不能再被分为两个子数组，那么就会执行merge进行归并，在归并的时候判断元素的大小进行排序。

在这里插入图片描述
用树状图来描述归并，如果一个数组有8个元素，那么它将每次除以2找最小的子数组，共拆log8次，值为3，所以 树共有3层,那么自顶向下第k层有2 ^ k个子数组，每个数组的长度为2 ^ (3-k)，归并最多需要2^(3-k)次比较。因此每层的比较次数为 2 ^ k * 2 ^ (3-k)=2 ^ 3,那么3层总共为 3*2 ^3。

假设元素的个数为n，那么使用归并排序拆分的次数为log2(n),所以共log2(n)层，那么使用log2(n)替换上面32^3中 的3这个层数，最终得出的归并排序的时间复杂度为：log2(n) 2^(log2(n))=log2(n)*n,根据大O推导法则，忽略底 数，最终归并排序的时间复杂度为O(nlogn);

归并排序的缺点：

需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换时间的操作。

归并排序与希尔排序性能测试：

之前我们通过测试可以知道希尔排序的性能是由于插入排序的，那现在学习了归并排序后，归并排序的效率与希尔 排序的效率哪个高呢？我们使用同样的测试方式来完成一样这两个排序算法之间的性能比较。

在资料的测试数据文件夹下有一个reverse_arr.txt文件，里面存放的是从1000000到1的逆向数据，我们可以根据 这个批量数据完成测试。测试的思想：在执行排序前前记录一个时间，在排序完成后记录一个时间，两个时间的时 间差就是排序的耗时。

通过测试，发现希尔排序和归并排序在处理大批量数据时差别不是很大。

（7）快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一 部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序 过程可以递归进行，以此达到整个数据变成有序序列。

需求：

  • 排序前:{6, 1, 2, 7, 9, 3, 4, 5, 8}
  • 排序后:{1, 2, 3, 4, 5, 6, 7, 8, 9}

排序原理：

  1. 首先设定一个分界值，通过该分界值将数组分成左右两部分；

  2. 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于 或等于分界值，而右边部分中各元素都大于或等于分界值；

  3. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两 部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

  4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当 左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

在这里插入图片描述
快速排序 API设计:
在这里插入图片描述
切分原理：
把一个数组切分成两个子数组的基本思想：

  1. 找一个基准值，用两个指针分别指向数组的头部和尾部；

  2. 先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置；

  3. 再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；

  4. 交换当前左边指针位置和右边指针位置的元素；

  5. 重复2,3,4步骤，直到左边指针的值大于右边指针的值停止。

在这里插入图片描述

快速排序代码实现：

package cn.itcast.algorithm.sort;

/**
 * @author ：caizhengjie
 * @description：快速排序
 * @date ：2021/2/1 3:23 下午
 */
public class Quick {
    
    

    /**
     * 对数组arr中的元素进行排序
     * @param arr
     */
    public static void sort(Comparable<Integer>[] arr){
    
    
        // 定义一个lo变量，和hi变量，分别记录数组中最小索引和最大索引
        int lo = 0;
        int hi = arr.length - 1;
        // 调用sort重载方法完成数组arr中从索引lo到索引hi的元素排序
        sort(arr,lo,hi);
    }

    /**
     * 对数组arr中从lo到hi的元素进行排序
     * @param arr
     * @param lo
     * @param hi
     */
    public static void sort(Comparable<Integer>[] arr,int lo,int hi){
    
    
        // 安全性比较
        if (hi <= lo){
    
    
            return;
        }

        // 需要对数组中lo索引到hi索引之间的元素进行分组（左子组和右子组）
        int partition = partition(arr, lo, hi);

        // 对左边分组中的元素进行排序
        sort(arr, lo, partition-1);

        // 对右边分组中的元素进行排序
        sort(arr, partition+1, hi);

    }

    /**
     * 对数组arr中从lo到hi的元素进行分组，并返回分组界限对应的索引
     * @param arr
     * @param lo
     * @param hi
     * @return
     */
    public static int partition(Comparable<Integer>[] arr,int lo,int hi){
    
    
        //把最左边的元素当做基准值
        Comparable<Integer> key = arr[lo];
        // 定义一个左侧指针，初始指向最左边的元素
        int left = lo;
        // 定义一个右侧指针，初始指向左右侧的元素下一个位置
        int right = hi + 1;

        // 进行切分
        while (true){
    
    
            // 先从右往左扫描，找到一个比基准值小的元素,循环停止，证明找到了一个比基准值小的元素
            while (less(key,arr[--right])){
    
    
                if (right == lo){
    
    
                    // 已经扫描到最左边了，无需继续扫描
                    break;
                }
            }

            // 再从左往右扫描，找一个比基准值大的元素,循环停止，证明找到了一个比基准值大的元素
            while (less(arr[++left],key)){
    
    
                if (left == hi){
    
    
                    // 已经扫描到了最右边了，无需继续扫描
                    break;
                }
            }

            //判断 left>=right,如果是，则证明元素扫描完毕，结束循环，如果不是，则交换元素即可
            if (left>=right){
    
    
                break;
            }else{
    
    
                exch(arr,left,right);
            }
        }
        // 交换最后rigth索引处和基准值所在的索引处的值
        exch(arr,lo,right);
        // right就是切分的界限
        return right;
    }

    /**
     * 比较v元素是否小于w元素
     * @param v
     * @param w
     * @return
     */
    public static boolean less(Comparable<Integer> v,Comparable<Integer> w){
    
    
        return v.compareTo((Integer) w)<0;
    }

    /**
     * 数组元素i和j交换位置
     * @param arr
     * @param i
     * @param j
     */
    public static void exch(Comparable<Integer>[] arr,int i,int j){
    
    

        Comparable<Integer> comparable = arr[i];
        arr[i] = arr[j];
        arr[j] = comparable;
    }
}

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.sort.Quick;

import java.util.Arrays;

/**
 * @author ：caizhengjie
 * @description：TODO
 * @date ：2021/2/1 4:26 下午
 */
public class QuickTest {
    
    
    public static void main(String[] args) {
    
    
        Integer[] arr = {
    
    6, 1, 2, 7, 9, 3, 4, 5, 8};
        Quick.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

快速排序和归并排序的区别：
快速排序是另外一种分治的排序算法，它将一个数组分成两个子数组，将两部分独立的排序。快速排序和归并排序 是互补的：归并排序将数组分成两个子数组分别排序，并将有序的子数组归并从而将整个数组排序，而快速排序的 方式则是当两个数组都有序时，整个数组自然就有序了。在归并排序中，一个数组被等分为两半，归并调用发生在 处理整个数组之前，在快速排序中，切分数组的位置取决于数组的内容，递归调用发生在处理整个数组之后。

快速排序时间复杂度分析：
快速排序的一次切分从两头开始交替搜索，直到left和right重合，因此，一次切分算法的时间复杂度为O(n),但整个 快速排序的时间复杂度和切分的次数相关。

最优情况：每一次切分选择的基准数字刚好将当前序列等分。
在这里插入图片描述
如果我们把数组的切分看做是一个树，那么上图就是它的最优情况的图示，共切分了logn次，所以，最优情况下快速排序的时间复杂度为O(nlogn);

最坏情况：每一次切分选择的基准数字是当前序列中最大数或者最小数，这使得每次切分都会有一个子组，那么总 共就得切分n次，所以，最坏情况下，快速排序的时间复杂度为O(n^2);
在这里插入图片描述
平均情况：每一次切分选择的基准数字不是最大值和最小值，也不是中值，这种情况我们也可以用数学归纳法证 明，快速排序的时间复杂度为O(nlogn),由于数学归纳法有很多数学相关的知识，容易使我们混乱，所以这里就不对 平均情况的时间复杂度做证明了。

（8）排序的稳定性

稳定性的定义：
数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保 证A元素依然在B元素的前面，可以说这个该算法是稳定的。
在这里插入图片描述
常见排序算法的稳定性：

冒泡排序：

只有当arr[i]>arr[i+1]的时候，才会交换元素的位置，而相等的时候并不交换位置，所以冒泡排序是一种稳定排序 算法。

选择排序:

选择排序是给每个位置选择当前元素最小的,例如有数据{5(1)，8 ，5(2)， 2， 9 },第一遍选择到的最小元素为2， 所以5(1)会和2进行交换位置，此时5(1)到了5(2)后面，破坏了稳定性，所以选择排序是一种不稳定的排序算法。

插入排序：

比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其 后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么把要插入的元素放在相等 元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序 是稳定的。

希尔排序：

希尔排序是按照不同步长对元素进行插入排序 ,虽然一次插入排序是稳定的，不会改变相同元素的相对顺序，但在 不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以希尔排序是不 稳定的。

归并排序：

归并排序在归并的过程中，只有arr[i]<arr[i+1]的时候才会交换位置，如果两个元素相等则不会交换位置，所以它 并不会破坏稳定性，归并排序是稳定的。

快速排序：

快速排序需要一个基准值，在基准值的右侧找一个比基准值小的元素，在基准值的左侧找一个比基准值大的元素， 然后交换这两个元素，此时会破坏稳定性，所以快速排序是一种不稳定的算法。

以上内容仅供参考学习，如有侵权请联系我删除！
如果这篇文章对您有帮助，左下角的大拇指就是对博主最大的鼓励。
您的鼓励就是博主最大的动力！

猜你喜欢

转载自blog.csdn.net/weixin_45366499/article/details/113434300
今日推荐
周排行
Elasticsearch Log GC 日志分析详解
C++调用C出现的undefined reference 之坑------缺extern "C"
WordPress无法建立到WordPress.org的安全连接
《Spark大数据处理技术》PDF版
生成二维码功能（js前端）
day2csv
LeetCode 104. 二叉树的最大深度(C#实现)——二叉树,BFS,DFS,递归,迭代
Together
【矿工配餐_IOI2007Miners 】
HDU - 4135 Co-prime(分解质因数&容斥原理)
每日归档
更多
2025-03-21(0)
2025-03-20(0)
2025-03-19(0)
2025-03-18(0)
2025-03-17(0)
2025-03-16(0)
2025-03-15(0)
2025-03-14(0)
2025-03-13(0)
2025-03-12(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022