Java尚硅谷数据结构与算法学习记录(8)-排序算法

排序

排序也称排序算法(Sort Algorithm),排序是将一组数据,依指定的顺序进行排列的过程。排序的分类:

  1. 内部排序:
    指将需要处理的所有数据都加载到内部存储器中进行排序。
  2. 外部排序法:
    数据量过大,无法全部加载到内 存中,需要借助外部存储进行
    排序。
    Java尚硅谷数据结构与算法学习记录(8)-排序算法_第1张图片

冒泡排序

冒泡排序(Bubble Sorting)的基本思想是:通过对待排序序列从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素逐渐从前移向后部,就象水底下的气泡一样逐渐向上冒。
因为排序的过程中,各元素不断接近自己的位置,如果一趟比较下来没有进行过交换,就说明序列有序,因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。

思路分析:原始数组:3, 9, -1, 10, 20

第一趟排序
(1) 3, 9, -1, 10, 20 // 如果相邻的元素逆序就交换
(2) 3, -1, 9, 10, 20
(3) 3, -1, 9, 10, 20
(4) 3, -1, 9, 10, 20

第二趟排序
(1) -1, 3, 9, 10, 20 //交换
(2) -1, 3, 9, 10, 20
(3) -1, 3, 9, 10, 20

第三趟排序
(1) -1, 3, 9, 10, 20
(2) -1, 3, 9, 10, 20

第四趟排序
(1) -1, 3, 9, 10, 20

小结冒泡排序规则:
(1) 一共进行 数组的大小-1 次 大的循环
(2)每一趟排序的次数在逐渐的减少
(3) 如果我们发现在某趟排序中,没有发生一次交换, 可以提前结束冒泡排序。这个就是优化

代码实现:

//冒泡排序      时间复杂度为O(n^2)
    public static void bubbleSort(int[] arr) {
        int temp = 0;//临时变量
        boolean flag = false;//标识变量 表示没发生交换
        for (int i = 0; i < arr.length - 1; i++) {//i表示当前是第i+1趟排序
            //第i+1趟排序就是把第i+1大的数放在倒数第i+1的位置
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (!flag) {
                break;//在一趟排序中一次交换也没发生 则说明数组已经有序 break即可
            } else {
                flag = false;//重置flag 进行下一次标识
            }
        }
    }

选择排序

选择式排序也属于内部排序法,是从欲排序的数据中,按指定的规则选出某一元素,再依规定交换位置后达到排序的目的。
它的基本思想是:第一次从arr[0] 到arr[n-1]中选取最小值,与arr[0]交换,第二次从arr[1]到arr[n-1]中选取最小值,与arr[1]交换,第三次从arr[2]到arr[n-1]中选取最小值,与arr[2]交换,…,第i次从arr[i-1]到arr[n-1]中选取最小值,与arr[i-1]交换,…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值,与arr[n-2]交换,总共通过n-1次,得到一个按排序码从小到大排列的有序序列。

思路分析:
原始的数组 : 101, 34, 119, 1
第一轮排序 : 1, 34, 119, 101
第二轮排序 : 1, 34, 119, 101
第三轮排序 : 1, 34, 101, 119

说明:

  1. 选择排序一共有 数组大小 - 1 轮排序
  2. 每1轮排序,又是一个循环, 循环的规则(见代码)
    2.1先假定当前这个数是最小数
    2.2 然后和后面的每个数进行比较,如果发现有比当前数更小的数,就重新确定最小数,并得到下标
    2.3 当遍历到数组的最后时,就得到本轮最小数和下标
    2.4 交换 [见代码]

代码实现:

    //选择排序      时间复杂度为O(n^2)
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;//第一轮默认最小值下标是0
            int min = arr[i];//第一轮默认最小值为第一个数
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {       //如果按从大到小排序则改成min < arr[j]即可
                    min = arr[j];//重置最小值
                    minIndex = j;//重置最小值下标
                }
            }
            //交换  优化:如果最小值没变化就不必交换
            if (minIndex != i) {
                arr[minIndex] = arr[i]; //arr[0]=101->arr[3]=101
                arr[i] = min;//arr[0]=101->arr[0]=1
            }
        }
    }

插入排序(简单插入)

插入排序(Insertion Sorting)的基本思想是:把n个待排序的元素看成为一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含有n-1个元素,排序过程中每次从无序表中取出第一个元素,把它的排序码依次与有序表元素的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表。
思路分析(图示):
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第2张图片
代码实现:

 //插入排序
    public static void insertSort(int[] arr) {
        int insertVal = 0;//待插入的数
        int insertIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            insertVal = arr[i];//待插入的数
            insertIndex = (i) - 1;//带插入位置的索引 插入到前一位 所以-1
            //说明:1、insertIndex >= 0 保证在给insertIndex找插入位置时不越界
            //     2、insertVal < arr[insertIndex] 说明还没找到插入位置
            //     3、需要将arr[insertIndex]后移
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }//退出循环时 表示已经找到要插入的位置
            if (insertIndex + 1 != i) {//优化:如果找的的要插入位置就是其本身所在位置 则无需再赋值
                arr[insertIndex + 1] = insertVal;
            }

            // System.out.println("第" + i + "轮插入排序后:" + Arrays.toString(arr));
        }
}

希尔排序

简单的插入排序可能存在的问题.
数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是:
{2,3,4,5,6,6}
{2,3,4,5,5,6}
{2,3,4,4,5,6}
{2,3,3,4,5,6}
{2,2,3,4,5,6}
{1,2,3,4,5,6}
结论: 当需要插入的数是较小的数时,后移的次数明显增多,对效率有影响.
因此出现了希尔排序:希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序
基本思想:希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止
思路分析:(图示)
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第3张图片
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第4张图片
代码实现:
1、对有序序列在插入时采用交换法

  //希尔排序-----交换法
    public static void shellSort(int[] arr) {
        int temp = 0;
        int count = 0;
        //增量gap  逐渐缩小增量
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //遍历各组中所有元素 共gap组 步长gap
            for (int i = gap; i < arr.length; i++) {
                for (int j = i - gap; j >= 0; 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));
        }
    }

2、对有序序列在插入时采用移动法(效率更高)

//希尔排序-----移位法(对交换法进行优化  速度快了)
    public static void shellSort2(int[] arr) {
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            //从第gap个元素开始 逐个对其所在组进行直接插入排序
            for (int i = gap; i < arr.length; i++) {
                //直接插入排序
                int j = i;//保存待插入位置的下标 类似insertIndex
                int temp = arr[j];//保存要插入的数据 类似insertVal
                if (arr[j]<arr[j-gap]) {
                    while (j-gap>=0&&temp<arr[j-gap]) {
                        //移动
                        arr[j]=arr[j-gap];
                        j-=gap;
                    }
                    //退出while循环后就表示找到了插入的位置
                    arr[j]=temp;
                }
            }
        }
    }

快速排序

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

示意图:
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第5张图片
基准数可以选取中间数 也可以选取第一个数 选哪个数都可以 随意
韩老师的快排没大听懂 下面的代码是听罗召勇老师讲的 感觉更好理解

代码实现:

  public static void quickSort(int[] arr, int start, int end) {
        if (start<end) {
            //将数组中的第0个数字 设置为基准数
            int stard = arr[start];
            //记录需要排序的下标
            int low = start;
            int high = end;
            while (low < high) {
                //右边的数比基准数大 则向左移动high指针
                while (low < high && arr[high] >= stard) {
                    high--;
                }//退出此while循环说明当前a[high]
                arr[low] = arr[high];//用high位的数覆盖low位的数
                //左边的数比基准数小 则向右移动low指针
                while (low < high && arr[low] <= stard) {
                    low++;
                }//退出此while循环说明当前a[low]>stard
                arr[high] = arr[low];
            }
            //low和high指针相遇时 将基准数赋给此下标处
            arr[low] = stard;
            //System.out.println("第一次快速排序后的数组为:" + Arrays.toString(arr));
            //递归
            //处理所有比基准数小的数字
            quickSort(arr,start,low);
            //处理所有比基准数大的数字
            quickSort(arr,low+1,end);
        }
    }

归并排序

归并排序(MERGE-SORT)是利用归并的思想实现的排序方法,该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起,即分而治之)。

基本思想图示:
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第6张图片
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第7张图片
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第8张图片
代码实现:

 //归并排序
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            //向左递归分解
            mergeSort(arr, 0, mid, temp);
            //向右递归分解
            mergeSort(arr, mid + 1, right, temp);
            //合并
            merge(arr, left, right, mid, temp);
        }
    }

    //合并

    /**
     * @param arr   需要排序的原始数组
     * @param left  左边有序序列的初始索引
     * @param right 右边有序序列的初始索引
     * @param mid   中间索引
     * @param temp  做中转的数组
     * @return void
     * @author lylicoo
     * @date 2020/6/22 20:07
     */
    public static void merge(int[] arr, int left, int right, int mid, int[] temp) {
        //
        int i = left;//初始化i,左边有序序列的初始索引
        int j = mid + 1;//初始化k,右边有序序列的初始索引
        int t = 0;//指向temp数组的当前索引
        //1、先把左右两边数组按照规则填充到temp数组
        // 直到左右两边的有序序列有一边处理完毕
        while (i <= mid && j <= right) {
            //若左边序列的当前元素<=右边序列的当前元素
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t++;
                i++;
            } else {
                temp[t] = arr[j];
                t++;
                j++;
            }
        }//两种情况退出当前while循环
        //2、把有剩余元素的一边的数据依次全部填充到temp
        while (i <= mid) {
            temp[t] = arr[i];
            t++;
            i++;
        }
        while (j <= right) {
            temp[t] = arr[j];
            t++;
            j++;
        }

        //3、将temp数组的元素拷贝到arr 注意:并不是每次都拷贝所有
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }
    }

基数排序

基数排序(radix sort)属于“分配式排序”(distribution sort),又称“桶子法”(bucket sort)或bin sort,顾名思义,它是通过键值的各个位的值,将要排序的元素分配至某些“桶”中,达到排序的作用,是桶排序的扩展

基本思想:将所有待比较数值统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

举例图示:将数组 {53, 3, 542, 748, 14, 214} 使用基数排序, 进行升序排序。
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第9张图片
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第10张图片
代码实现:

//基数排序
    public static void radixSort(int[] arr) {

        //得到数组中的最大数的位数
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        int maxLength = (max + "").length();
        //定义一个二维数组 表示10个桶 每个桶又是一个一维数组
        //说明:二维数组包含十个一位数组 为了防止放入数据时桶大小不够 所以每个桶的大小设为arr.length
        int[][] bucket = new int[10][arr.length];
        //记录每个桶中的数据个数 如:bucketElementCounts[0] 表示bucket[0]这个桶中存放的数据个数
        int[] bucketElementCounts = new int[10];
        //针对每个元素对应位进行处理
        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            for (int j = 0; j < arr.length; j++) {
                int digitOfElement = arr[j] / n % 10;//取个位
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                bucketElementCounts[digitOfElement]++;//放入个位对应的桶中
            }
            int index = 0;
            //遍历每一个桶 依次取出数据 放入原来数组中
            for (int k = 0; k < bucketElementCounts.length; k++) {
                if (bucketElementCounts[k] != 0) {
                    //有数据 就循环该桶 即第k个桶 即第k个一维数组
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        //取出数据 放入原来数组
                        arr[index] = bucket[k][l];
                        index++;
                    }
                }
                bucketElementCounts[k] = 0;//桶要清空
            }
            System.out.println("第"+(i+1)+"轮排序后的数组:"+Arrays.toString(arr));
        }
 }

基数排序的说明:
1、基数排序是对传统桶排序的扩展,速度很快.
2、基数排序是经典的空间换时间的方式,占用内存很大, 当对海量数据排序时,容易造成 OutOfMemoryError 。
3、基数排序是稳定的。
注:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是稳定的;否则称为不稳定的。
4、有负数的数组,一般不用基数排序来进行排序

堆排序

堆排序是利用堆这种数据结构而设计的一种排序算法,堆排序是一种选择排序
堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值,称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。
每个结点的值都小于或等于其左右孩子结点的值,称为小顶堆
一般升序采用大顶堆,降序采用小顶堆

堆排序思路分析:(见ppt图解)
1).将无序序列构建成一个堆,根据升序降序需求选择大顶堆或小顶堆;
2).将堆顶元素与末尾元素交换,将最大元素"沉"到数组末端;
3).重新调整结构,使其满足堆定义,然后继续交换堆顶元素与当前末尾元素,反复执行调整+交换步骤,直到整个序列有序。
代码实现:升序

package com.datastructures.tree.heap;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;

public class HeapSort {
    public static void main(String[] args) {
        //对该数组进行升序排列
        //int[] arr = {4, 6, 8, 5, 9,0,-1,22,-88};
        //heapSort(arr);
        //测试堆排序的速度   随机给80000个数  ---
        int[] arr=new int[800000];
        for (int i=0;i<800000;i++){
            arr[i]=(int)(Math.random()*800000);//[0,800000)
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间是:"+date1Str);
        heapSort(arr);
        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后的时间是:"+date2Str);
    }

    //编写方法实现堆排序
    public static void heapSort(int[] arr) {
        int temp = 0;
        //1)将无序序列构建成一个堆,根据升序降序需求选择大顶堆或小顶堆;
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }
       // System.out.println("调整后的堆为:" + Arrays.toString(arr));
        //2)将堆顶元素与末尾元素交换,将最大元素"沉"到数组末端;
        //3)重新调整结构,使其满足堆定义,然后继续交换堆顶元素与当前末尾元素,反复执行调整+交换步骤,直到整个序列有序。
        for (int j = arr.length - 1; j > 0; j--) {
            //交换
            temp = arr[j];
            arr[j] = arr[0];//调整好的堆 最大值肯定在数组的第一位
            arr[0] = temp;
            adjustHeap(arr, 0, j);
        }
       // System.out.println("堆排序的结果:" + Arrays.toString(arr));


    }

    //将一个数组(二叉树)调整成一个大顶堆

    /**
     * 功能:将以i为父节点的树 调整成大顶堆
     *
     * @param arr    待调整的数组
     * @param i      i表示非叶子节点在数组中的索引
     * @param length 对length个数据进行调整  没调整一次length-1
     */
    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[i] = arr[k];
                i = k;//i指向k继续循环比较
            } else {
                break;
            }
        }//for循环结束后 以i为父节点的树的最大值已经放在了最顶部
        arr[i] = temp;//将temp的值放在调整后的位置
    }

}

常用排序算法对比
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第11张图片
Java尚硅谷数据结构与算法学习记录(8)-排序算法_第12张图片

你可能感兴趣的:(Java尚硅谷数据结构与算法学习记录(8)-排序算法)