排序

 

1.直接选择排序：

思想：

第一次从R [0]〜[R [N-1]中选取最小值，与R [0]交换，第二次从R [1]〜[R [N-1]中选取最小值，与[R [ 1]交换，...​​，第I次从ř[I-1]〜[R [N-1]中选取最小值，与[R [I-1]交换，...​​，第n-1个次从ř[N-2]〜[R [N-1]中选取最小值，与[R [N-2]交换，总共通过n-1个次，得到一个按排序码从小到大排列的有序序列。

/**
     * 简单选择排序
     *
     * @param arr
     */
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;//每一趟循环比较时，min用于存放较小元素的数组下标，这样当前批次比较完毕最终存放的就是此趟内最小的元素的下标，避免每次遇到较小元素都要进行交换。
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            //进行交换，如果min发生变化，则进行交换
            if (min != i) {
                swap(arr,min,i);
            }
        }
    }

2.冒泡排序：

基本思想：

对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序

public static void bubbleSort(int []arr) {
        for(int i =0;i<arr.length-1;i++) {
            for(int j=0;j<arr.length-i-1;j++) {//-1为了防止溢出
                if(arr[j]>arr[j+1]) {
                    int temp = arr[j];
                     
                    arr[j]=arr[j+1];
                     
                    arr[j+1]=temp;
            }
            }    
        }
    }

3.直接插入排序

基本思想：

每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。

假设有一组无序序列R0，R1，...，RN-1。

（1）我们先将这个序列中下标为0的元素视为元素个数为1的有序序列。

（2）然后，我们要依次把R1，R2，...，RN-1插入到这个有序序列中。所以，我们需要一个外部循环，从下标1扫描到N-1。

（3）接下来描述插入过程。假设这是要将Ri插入到前面有序的序列中。由前面所述，我们可知，插入Ri时，前i-1个数肯定已经是有序了。

所以我们需要将Ri和R0~Ri-1进行比较，确定要插入的合适位置。这就需要一个内部循环，我们一般是从后往前比较，即从下标i-1开始向0进行扫描。

/**
     * 插入排序
     *
     */
    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                swap(arr,j,j-1);
                j--;
            }
        }
    }

参考链接：https：  //www.cnblogs.com/chengxiao/p/6103002.html

4.堆排序

基本思想：

每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆;或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆

该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是：

大顶堆：arr [i]> = arr [2i + 1] && arr [i]> = arr [2i + 2]  

小顶堆：arr [i] <= arr [2i + 1] && arr [i] <= arr [2i + 2]  

     将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。建堆时，先从求最后一层非叶子节点开始，向上调整成堆。调整成堆后，将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余的N-1个元素重新构造成一个堆，这样会得到ñ个元素的次小值。如此反复执行，便能得到一个有序序列了。

【叶子节点就是没有孩子，非叶子节点就是有孩子】

    //节点k进行筛选，a:堆数据  n:堆中有效数据个数 k:待筛选节点
    public static void heapOne(int[] a,int n,int k){

        int k1=2*k+1;//左孩子
        int k2=2*k+2;
        if(k1>=n&&k2>=n) return;

        int a1=0;
        int a2=0;
        if(k1<n) a1=a[k1];//左孩子值
        if(k2<n) a2=a[k2];

        if(a[k]<=a1 && a[k]<=a2) return;

        if(a1<a[k]){
            int t=a[k];
            a[k]=a[k1];        //筛选子树
            a[k1]=t;
            heapOne(a,n,k1);
        }
        else if(a2<a[k]){
            int t=a[k];
            a[k]=a[k2];        //筛选子树
            a[k2]=t;
            heapOne(a,n,k2);
        }


    }


    public static void heapSort(int[] a){

        //建立初始堆 ,开始的元素是最后一层非叶子节点【最后一个叶子的节点的父节点】
        for(int i=(a.length-1)/2;i>=0;i--){
            heapOne(a,a.length,i);
        }
        int n = a.length;//剩余元素数
        while(n>0){
            System.out.println(a[0]+" ");//输出栈顶元素
            a[0]=a[n-1];//最后一个元素移到堆顶
            n--;
            heapOne(a,n,0);  //从0号元素开始调整
        }

        System.out.println();

    }


    public static void main(String[] args) {
        int[] a = {1,2,3,6,8,5,19,20,16,4,2,7,13,0,11};
        heapSort(a);
    }