数据结构与算法实战（二）基础排序算法

数据结构与算法实战（二）基础排序算法

包含选择排序和插入排序

一、选择排序法

1、算法引入

先把最小的拿出来，在剩下的里面再把最小的拿出来…

这个过程一直持续，每次选择还没处理的元素里最小的元素

2、原地排序

排序过程占用了额外的空间，而是否可以原地完成是排序算法中一个关键点。

选择排序法可以原地排序

3、算法思想

循环不变量：arr[i…n) 未排序 arr[0…i) 已排序

arr[i…n) 中的最小值要放到arr[i]的位置

4、代码实现

//使用泛型
public class SelectionSort {

    private SelectionSort(){}

    //extends 使用在泛型表示实现了Comparable接口
    public static <E extends Comparable<E>> void sort(E[] arr){

        //arr[i...n) 未排序    arr[0...i) 已排序
        for (int i = 0; i < arr.length; i++) {

            //选择arr[i ... n)中的最小值的索引
            int minIndex = i;
            for (int j = i; j <arr.length ; j++) {
                if(arr[j].compareTo(arr[minIndex]) < 0)
                    minIndex = j;
            }

            swap(arr, i, minIndex);
        }
    }
    private static <E>void swap(E[] arr,int i, int j){

        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    public static void main(String[] args) {

        Integer[] arr={1,3,4,6,5,2};
        SelectionSort.sort(arr);
        for (int e:arr
             ) {
            System.out.print(e+"  ");
        }
        System.out.println();
    }
}

5、使用自定义类型排序

//为进行排序需要实现Comparable接口
public class Student implements Comparable<Student>{

    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public int compareTo(Student another) {

//        if(this.score < another.score)
//            return -1;
//        else if(this.score == another.score)
//            return 0;
//        return 1;
        //成绩从小到大排序
        return this.score - another.score;
    }

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

}

Student[] students ={new Student("Alice",90)
        ,new Student("ycj",100)
        ,new Student("Simone",60)};
SelectionSort.sort(students);
for (Student student: students
     ) {
    System.out.println(student + " ");
}

6、复杂度分析

for (int i = 0; i < arr.length; i++) {

    //选择arr[i ... n)中的最小值的索引
    int minIndex = i;
    for (int j = i; j <arr.length ; j++) {
        if(arr[j] < arr[minIndex])
            minIndex = j;
    }

    swap(arr, i, minIndex);
}

O(n²)的复杂度

7、算法性能

public class ArrayGenerator {

    private ArrayGenerator(){}

    //生成一个长度为n的随机数组，每个数字的范围是[0,bound)
    public static Integer[] generateRandomArray(int n ,int bound){

        Integer[] arr = new Integer[n];
        Random random = new Random();
        for (int i = 0; i < n; i++) {
            arr[i] = random.nextInt(bound);
        }
        return arr;
    }
}

int n = 10000;
Integer[] arr = ArrayGenerator.generateRandomArray(n,n);

long startTineme = System.nanoTime();
SelectionSort.sort(arr);
long endTime = System.nanoTime();

double time = (endTime - startTineme) / 1000000000.0;

System.out.println(time + "s");

8、验证算法是否正确

public class SortingHelper {

    private SortingHelper(){}

    public static <E extends Comparable<E>> boolean isSorted(E[] arr){

        for (int i = 1; i < arr.length; i++) {
            if(arr[i-1].compareTo(arr[i]) > 0)
                return false;
        }
        return true;
    }
}

9、测试算法性能是否为O(n²)

public class SortingHelper {

    private SortingHelper(){}

    public static <E extends Comparable<E>> boolean isSorted(E[] arr){

        for (int i = 1; i < arr.length; i++) {
            if(arr[i-1].compareTo(arr[i]) > 0)
                return false;
        }
        return true;
    }

    public static <E extends Comparable<E>> void sortTest(String sortName, E[] arr){

        long startTineme = System.nanoTime();

        if(sortName.equals("SelectionSort"))
            SelectionSort.sort(arr);
        long endTime = System.nanoTime();

        double time = (endTime - startTineme) / 1000000000.0;

        if(!SortingHelper.isSorted(arr))
            throw new RuntimeException(sortName+"failed");

        System.out.println(String.format("%s , n = %d : %f s",sortName,arr.length
        ,time));
    }
}

int[] dataSize = {10000,100000};
for(int n : dataSize){
    Integer[] arr = ArrayGenerator.generateRandomArray(n,n);

    SortingHelper.sortTest("SelectionSort",arr);
}

数据量差十倍，时间相差约为100倍

二、插入排序法

1、算法引入

以手中的扑克牌为例，每一次处理一张牌，把这张牌插入到前面已经排好序的牌中

2、算法思想

循环不变量：arr[0,i) 已排好序 ； arr[i…n) 未排序

把arr[i] 放到合适的位置

插入排序与选择排序的区别在于当第i次遍历，选择排序前i个元素是整个数组中最小的i个元素的有序集合，而插入排序仅仅是i遍历到的i个元素中的有序集合

3、代码实现与测试

public class InsertionSort {

    private InsertionSort(){}

    public static <E extends Comparable<E>> void sort(E[] arr){

        for (int i = 0; i < arr.length; i++) {

            //将arr[i]插入到合适的位置
            for (int j = i; j -1 >=0 ; j--) {

                if(arr[j].compareTo(arr[j-1]) < 0)
                    swap(arr,j,j-1);
                else break;
            }
        }
    }

    private static <E>void swap(E[] arr,int i, int j){

        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    public static void main(String[] args) {

        int[] dataSize = {10000,100000};
        for(int n : dataSize){
            Integer[] arr = ArrayGenerator.generateRandomArray(n,n);

            SortingHelper.sortTest("InsertionSort",arr);
        }

    }
}

4、插入排序的代码上的小优化

public static <E extends Comparable<E>> void sort2(E[] arr){

    for (int i = 0; i < arr.length; i++){

        //将arr[i]插入到合适的位置
        //先使用一个变量暂存
        E t = arr[i];
        int j;
        for(j = i; j - 1 >= 0 && t.compareTo(arr[j-1]) < 0; j--){
            //以赋值的方式
            arr[j] = arr[j-1];
        }
        arr[j] = t;
    }
}

5、重要特性

对于有序数组，插入排序的复杂度是O(n)

而对于选择排序，永远都是O(n²)

public static void main(String[] args) {

    int[] dataSize = {10000,100000};
    for(int n : dataSize){
        Integer[] arr = ArrayGenerator.generateRandomArray(n,n);
        Integer[] arr2 = Arrays.copyOf(arr,arr.length);

        //SortingHelper.sortTest("InsertionSort",arr);
        //SortingHelper.sortTest("InsertionSort2",arr2);
        System.out.println("Ordered Array");
        arr =ArrayGenerator.generateOrderedArray(n);
        SortingHelper.sortTest("InsertionSort2",arr);
    }

}