java排序算法(一)

排序算法就是将一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。

选择排序、冒泡排序、插入排序、希尔排序、归并排序、堆排序、快速排序

非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

计数排序、桶排序、基数排序

 排序的因素

稳定：如果a原本在b前面，而a==b，排序之后a仍然在b的前面。

不稳定：如果a原本在b的前面，而a==b，排序之后 a 可能会出现在 b 的后面。

时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。

       空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

 写一个排序的父类Sort构造器复制副本和通用函数

//排序父类
public abstract class Sort {
    public int[] arr;
    public Sort(){}//无参
    public Sort(int[] arr) {
        this.arr = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {//建一个副本用来操作
            this.arr[i] = arr[i];
        }
    }
    public abstract void sort();
    public void swap(int i, int j){//构造函数调换位置
        int temp =arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

简单选择排序

工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

时间复杂度为O(n^2)  空间复杂度为S(1)。

时间复杂度：无论是最好最差情况，比较次数一样多，n(n-1)/2，总的时间复杂度O(n^2)

简单选择排序性能上略优于冒泡排序。

//选择排序 时间O(n^2) 空间S(1)  调换次序不稳定
public class SelectionSort extends Sort{
    public  SelectionSort(int[] arr){
        super(arr);//做个副本用于操作
    }
    @Override
    public void sort() {
        for (int i = 0; i < arr.length - 1; i++) {//遍历只到倒数第二个
            for (int j = i + 1; j < arr.length ; j++) {
                if (arr[i] > arr[j]){//判大小
                    swap(i,j);//交换位置
                }
            }
        }
    }
}

简单插入排序

 工作原理：是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

//插入排序O(n^2) S(1) 稳定
public class InsertionSort extends Sort{
    public InsertionSort(int[] arr){
        super(arr);
    }

    @Override
    public void sort() {
        for (int i = 1; i < arr.length; i++) {//从第二个元素开收
            int e = arr[i];//将元素取出来
            int j = 0;
            for ( j = i; j > 0 && arr[j - 1] > e; j--) {
                arr[j] = arr[j - 1];//判大小并调换
            }
            arr[j] = e;//把元素再插入进去
        }
    }
}

冒泡排序

工作原理：重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。越小的元素会经过交换浮于表面，故叫冒泡排序

时间复杂度

• 最好情况下 ：数组本身有序，只需要进行n-1次比较，不需要交换，时间复杂度为O(n)
• 最坏情况下 ：数组为逆序，此时需要比较n*(n-1)/2，并作等数量级的记录移动，时间复杂度为O(n^2)

//冒泡排序   O(n^2) S(1) 稳定
public class BubbleSort extends Sort{
    public BubbleSort(int[] arr){
        super(arr);//构造副本
    }
    @Override
    public void sort() {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {//从后往前交换
                if (arr[j] > arr[j + 1]){
                    swap(j , j + 1);
                }
            }
        }
    }
}

 希尔排序

 1959年Shell发明，第一个突破O(n^2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

理解为先在大致范围内将数据有序化，在使用简单插入排序细微操控。

//希尔排序
public class ShellSort extends Sort{
    public ShellSort(int[] arr){
        super(arr);
    }
    @Override
    public void sort() {
        int len = arr.length;
        for (int gap = len / 2 ; gap > 0 ; gap = gap / 2){
            for (int i = gap; i < len; i++) {
                int e = arr[i];//先取出来
                int j = i;
                while(j - gap >= 0 && arr[j - gap] > e) {//只要相减大于0且左边还有数字大于e
                    arr[j] = arr[j - gap];
                    j = j - gap;
                }
                arr[j] = e;//给值
            }
        }
    }
}