数据结构和算法——排序算法（下）

1、基数排序

1、基数排序：又称桶子排序，它是通过键值的各个位的值，将要排序的元素fenp至某些“桶”中，达到排序的作用。基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法。基数排序是使用空间换时间的经典算法。

2、基排序基本思想：将所有待排序数补全成统一长度的数，数位短的前面用0补齐，然后从低位开始，依次排序，最后就会得到一个有序序列。

下面画一张图，让大家更直观得看到基数排序是怎么实现的。

 下面我们代码实现一波：

 public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {4,3,76,4,332,12,45,6,5,3,234};
        radixSort(arr);
    }
    public static void radixSort(int[] arr){
        //1、计算出数组中最大的数的位数
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
        }
        //测试找出最大值是否正确
//        System.out.println("max= "+ max);
        //2、计算出最大数的位数
        int maxLength = (max + "").length();
        //3、创建十个桶，用二维数组表示，
        int[][] bucket = new int[10][arr.length];
        //4、定义一个一维数组，存放每个桶中每次放入的数据

        int[] bucketElems = new int[10];
        
        //5、将无序序列中的元素依次拿出，依次计算出个位，十位，百位的数，依次放入对应的桶中
        for (int i = 0 ,n =1; i <maxLength ; i++ ,n *= 10) {
            for (int j = 0; j < arr.length; j++) {
                //取出对应的个位，十位，百位数
                int elems = arr[j] / n  % 10;
                //放入对应的桶中
                bucket[elems][bucketElems[elems]] = arr[j];
                bucketElems[elems]++;
            }
            int index = 0;
            for (int j = 0; j < bucketElems.length; j++) {
                if (bucketElems[j] != 0){
                    for (int k = 0; k < bucketElems[j]; k++) {
                        //取出元素放入arr数组
                        arr[index++] = bucket[j][k];
                    }
                }
                //没一轮过后需要将其置为空，为下一轮准备
                bucketElems[j] = 0;

            }
            System.out.println("第" + (i + 1) + "轮基数排序后的结果为：" + Arrays.toString(arr));

        }
    }

}

 

2、归并排序 

1、归并排序：归并排序是利用归并的思想实现的排序方法，该排序算法采用经典的分治策略。将问题分成一些小的问题然后递归求解，然后将分的阶段得到的各答案"修补"在一起完成排序。

下面画一张图带你理解归并思想：

代码演示：

public class test5 {
    public static void main(String[] args) {
        int arr[] = {4, 6, 76, 32, 45, 7, 9, 1};
        int temp[] = new int[arr.length];
        mergeSort(arr, 0, arr.length - 1, temp);
        System.out.println(Arrays.toString(arr));

    }

    //编写分阶段的方法
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (right + left) / 2;
            //向左递归切分
            mergeSort(arr, left, mid, temp);
            //向右递归切分
            mergeSort(arr, mid + 1, right, temp);
            //合
            merge(arr, left, right, mid, temp);
        }

    }

    //编写合阶段的方法

    /**
     * @param arr   待排序数组
     * @param left  左边有序序列索引
     * @param right 右边有序序列索引
     * @param temp  中转数组
     */
    public static void merge(int[] arr, int left, int right, int mid, int[] temp) {
        int i = left;
        int j = mid + 1;
        int t = 0;

        //把分完的俩个数组按照比较将小的数优先放到temp数组中
        while (i <= mid && j <= right) {
            if (arr[i] < arr[j]) {
                temp[t] = arr[i];
                i += 1;
                t += 1;
            } else {
                temp[t] = arr[j];
                j += 1;
                t += 1;
            }
        }

        //把剩余的数依次加入temp数组
        while (i <= mid) {
            temp[t] = arr[i];
            i += 1;
            t += 1;
        }
        while (j <= right) {
            temp[t] = arr[j];
            j += 1;
            t += 1;
        }


        System.out.println("排序之后的结果为" + Arrays.toString(temp));

        //3.把temp数组的元素拷贝到temp
        t = 0;
        int tempLeft = left;
        System.out.println("templeft" + tempLeft + " " + "right" + right);
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }
    }

}

3、希尔排序

1、希尔排序：希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

2、希尔排序思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；每一轮根据结算逐渐减少增量，每组包含的关键词越来越多，当增量减至1时，整个数组恰被分成一组，算法便终止。 

public class shellSort {
    public static void main(String[] args) {
        int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
    }


    //整合希尔排序
    public static void shellSort(int[] arr) {
        int temp = 0;
        int count = 0;
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //希尔排序第一轮。是将十个数据分成了五组
            for (int i = gap; i < arr.length; i++) {
                //遍历各组中所有的元素（共5组，每组2个元素）步长为5
                for (int j = i - gap; j >= 0; j = j - gap) {
                    //如果当前元素大于加上步长的那个元素，说明需要交换
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
            System.out.println("希尔排序第" + (++count) + "次：" + Arrays.toString(arr));
        }
    }

4、堆排序

1、堆排序：堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。

2、堆：堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆。每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。一般升序采用大顶堆，降序采用小顶堆 。

3、堆排序思想：将待排序的数列先构成一个大顶堆或者小顶堆，此时二叉树的的根节点是整个数列的最大值/最小值，将根节点和二叉树末尾节点进行交换，重复对剩余节点构造大顶堆/小顶堆就可以得到一个有序序列。

4、注意：堆排序中没有构建二叉树，而是以循序存储二叉树的方式来完成堆数组的操作。

public class HeapSort {
    public static void main(String[] args) {

        int[] arr = {4, 6, 8, 5, 9, 42, 4, 5, 202, 342342, 2, 45, 4, 23, 234, 5, 3, 2, 42};
        heapSort(arr);
    }

    //堆排序方法：
    public static void heapSort(int arr[]) {
        int temp = 0;
        System.out.println("堆排序！");
        //完成最终代码
        //1、将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {//i非叶子节点
            adjustHeap(arr, i, arr.length);
        }

       
        //2、将堆顶元素与末尾元素交换，将最大元素“沉”到数组末端

        for (int j = arr.length - 1; j > 0; j--) {
            //交换
            temp = arr[j];
            arr[j] = arr[0];//最大值和j交换
            arr[0] = temp;
            adjustHeap(arr, 0, j);
        }
        System.out.println(Arrays.toString(arr));
    }
    //将一个数组（二叉树）调整成一个大顶堆

    /**
     * @param i      : 表示非叶子节点在数组中的索引
     * @param length : 表示对多少个元素继续进行调整，length逐渐减少
     */
    public static void adjustHeap(int[] arr, int i, int length) {
        int temp = arr[i];//先取出当前元素的值，保存为临时变量

        //开始调整
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && arr[k] < arr[k + 1]) {//当左子节点的值小于右子节点
                k++;//指向右子节点
            }
            if (arr[k] > temp) {
                arr[i] = arr[k];//把大的节点放到父结点位置上
                i = k;//i指向k，继续循环比较
            } else {
                break;
            }
            //for循环结束后，我们已经将以i为父结点的树的最大值放在了最顶部
            arr[i] = temp;//把temp值放到调整后的位置
        }
    }


}