数据结构与算法之排序算法

内部排序

插入排序

直接插入排序

是对于欲排序的元素以插入的方式找寻元素的适当位置,以达到排序的目的
思路:
插入排序(Insertion Sorting)的基本思想是:把n个待排序的元素看成为一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含有n-1个元素,排序过程中每次从无序表中取出第一个元素,把它的排序码依次与有序表元素的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表。
在这里插入图片描述
如上图,我们所说的有序表是前面有括号包着的表,后面是无序表。我们每一次都把无序表的第一个元素插入到有序表中,并与有序表的最后一个元素比较,如果比它大就查到后面去,如果比它小,就一个一个往前比较,直到找到位置位置。
代码实现

// 插入排序
public static void insertSort(int[] arr){
    // 使用逐步推导的方式来讲解,便于理解
    // 从最后一个开始 遍历到最后一个
    for (int i = 1; i < arr.length; i++) {
        // 定义待插入的数
        int insertVal = arr[i];
        int insertIndex = i-1; //既arr[1]的前面这个数的下标
        // 给insertVal 找到插入的位置
        // insertIndex >= 0 保证不越界
        // insertVal<arr[insertIndex] 说明待插入的数还没有找到位置
        while(insertIndex >= 0 && insertVal<arr[insertIndex]) {
            arr[insertIndex + 1] = arr[insertIndex]; // 原来的数往后移
            insertIndex--;
        }
        // 当退出while循环时,说明插入的位置找到了 insertIndex+1
        arr[insertIndex+1] = insertVal;
    }
}

测试一下大概4秒

希尔排序

希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序。

  • 基本思想
    希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止
    在这里插入图片描述
    代码实现
// 使用逐步推导的方式编写 希尔排序 不适用这个
public static void shellSort(int[] arr) {
    int temp = 0;
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
        // 循环分组 10/2 = 5 5/2 = 2 1/2 = 0
        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;
                }
            }
        }
    }
}

// 对交换式的希尔排序进行优化
public static void shellSort2(int[] arr) {
    // 增量gap,并逐步地缩小增量
    for (int gap = arr.length / 2; gap > 0; gap /= 2) {
        // 从第gap个元素开始逐个对其所在的组进行直接插入排序
        for (int i = gap; i < arr.length; i++) {
            int j = i;
            int temp = arr[j];
            if (arr[j] < arr[j - gap]) {
                // 如果小于零,证明还没找到位置
                while (j - gap >= 0 && temp < arr[j - gap]) {
                    // 让前一位的值往后移动一位
                    arr[j] = arr[j-gap];
                    // 索引往前挪一位
                    j -= gap;
                }
                // 当退出while循环后,就给temp找到了插入的位置
                arr[j] = temp;
            }
        }
    }
}

选择排序

基本介绍:选择排序也属于内部排序法,是从想要排序的数据中,按指定的规则选出某一元素,再依次规定交换位置后达到排序的目的。
简单点说就是跟冒泡法相反,把最小的推到前面去

public static void selectSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        int min = arr[i];
        for (int j = i + 1; j < arr.length; j++) {
            if (min > arr[j]) { //说明假定的最小是并不是最小
                min = arr[j]; // 重置min
                minIndex = j; // 重置minIndex
            }
        }
        // 将最小值,放在arr[0],交换\
        if (minIndex != i) {
            arr[minIndex] = arr[i];
            arr[i] = min;
        }
    }
}

测试一下大概9秒

简单选择排序

堆排序

交换排序

冒泡排序

基本介绍: 对待排序序列从前向后(从下标较小的元素开始),依次比较相邻元素的值,若发现逆序则交换,使值较大的元素组件从前移向后部,就像水底下气泡一样逐渐向上冒。
因为排序的过程中,各元素不断接近自己的位置,如果一趟比较下来没有进行过交换,就说明序列有序,因此要在排序过程中设置表示flag判断元素是否进行过交换。从而减少不必要的比较。
每一次循环都会把最大的确定下来。

package sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class BubbleSort {
    public static void main(String[] args) {
        // int arr[] = {3,9,-1,10,20};
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000); //生成一个[0,8000000) 的数
        }
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String data1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间=" + data1Str);
        bubbleSort(arr);
        Date data2 = new Date();
        String data2Str = simpleDateFormat.format(data2);
        System.out.println("排序前的时间=" + data2Str);

        //System.out.println(Arrays.toString(arr));

    }

    public static void bubbleSort(int[] arr) {
        // 时间复杂度 o(n^2)
        int temp = 0;
        boolean flag = false; // 标识变量,标识是否进行过交换
        // 时间复杂度 o(n^2)
        int temp = 0;
        boolean flag = false; // 标识变量,标识是否进行过交换
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 1; j < arr.length-i; j++) {
                if (arr[j-1]>arr[j]){
                    flag = true;
                    temp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = temp;
                }
            }
            if (!flag){
                break;
            } else {
                flag = false;
            }
        }
    }
}

测试一下大概10s

快速排序

在这里插入图片描述
思路图
在这里插入图片描述
代码

public static void quickSort(int[] arr, int left, int right) {
    int l = left; // 左下标
    int r = right; // 右下标
    // 中轴值
    int pivot = arr[(left + right) / 2];
    int temp = 0; // 临时变量,作为交换时使用
    // while循环的目的是让比pivot小的放到左边
    // 比pivot值 大的值放到右边
    while (l < r) {
        // 在pivot的左边一直找,找到大于等于pivot的值,才退出
        while (arr[l] < pivot) {
            l += 1;
        }
        // 在pivot的右边一直找,找到小于等于pivot的值,才退出
        while (arr[r] > pivot) {
            r -= 1;
        }
        // 如果l>=r成立 说明pivot的左右两边的值,已经按照左边全部都是
        // 小于等于pivot值,右边全部大于等于pivot的值
        if (l >= r) {
            break;
        }

        // 交换
        temp = arr[l];
        arr[l] = arr[r];
        arr[r] = temp;

        // 如果交换完后发现,发现这个arr[l] == pivot 值, 要r-- 前移一步
        if (arr[l] == pivot) {
            r -= 1;
        }
        // 如果交换完后发现,发现这个arr[r] == pivot 值, 要l++ 后移一步
        if (arr[r] == pivot) {
            l += 1;
        }
    }

    // 如果l == r 必须l++ , r-- 否则会出现栈溢出
    if (l==r) {
        l+=1;
        r-=1;
    }
    // 向左递归
    if (left < r) {
        quickSort(arr,left,r);
    }
    // 向右递归
    if (right > l) {
        quickSort(arr,l,right);
    }
}

下面我们拿一个例子来解析一下这个代码
黑色箭头代表left 蓝色箭头代表right
起步的时候,我们可以获取到中值为 0 在第五个元素上
在这里插入图片描述
看代码,因为我们先移动left,所以当移动到 78
在这里插入图片描述
然后我们移动right,移动到 -567 退出循环
在这里插入图片描述
交换两个元素后left元素继续往左移动,到90停下,right往左移动,到-10停下
在这里插入图片描述
交换完毕后,又开始从left开始往后移动,当移动到0时退出循环
然后移动right,移动到-23后停下
在这里插入图片描述
交换
在这里插入图片描述
然后此时注意!

// 如果交换完后发现,发现这个arr[l] == pivot 值, 要r-- 前移一步
if (arr[l] == pivot) {
    r -= 1;
}
// 如果交换完后发现,发现这个arr[r] == pivot 值, 要l++ 后移一步
if (arr[r] == pivot) {
    l += 1;
}

right的值跟中值相等,left往前挪一位
在这里插入图片描述
因为此时我们又一次运行了循环体,所以我们依旧要交换一次这两者的值
交换完毕后,因为arr[l] 的值跟 中值相等, r往左挪一位
在这里插入图片描述
此时,因为 left 等于 中值(不用移动),right 大于中值(往左移),最后它们都移动到了中值
在这里插入图片描述
于是退出循环,此时判断 如果l 跟 r 相等,我们分别往右移和往左移,然后再次调用自己,实现递归
在这里插入图片描述
以此类推!!

归并排序

该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解,而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起,即分而治之)

在这里插入图片描述
在这里插入图片描述在这里插入图片描述
代码实现

package sort;

import java.util.Arrays;

public class MergetSort {
    public static void main(String[] args) {
        int arr[] = {8,4,5,7,1,3,6,2};
        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 = (left + right) /2; //中间索引
            // 向左递归进行分解
            mergeSort(arr,left,mid,temp);
            // 向右递归进行分解
            mergeSort(arr,mid+1,right,temp);
            // 合并
            merge(arr,left,mid,right,temp);

        }
    }

    // 合并的方法
    /**
     *
     * @param arr 待排序的数组
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引
     * @param right 右边索引
     * @param temp 做中转的数组
     */
    public static void merge(int[] arr,int left ,int mid,int right,int[] temp) {
        int i = left; // 初始化i,左边有序序列的初始索引
        int j = mid + 1; // 初始化j,表示右边有序序列的初始是索引
        int t = 0; // 指向temp数组的当前索引

        // 先把左右两边的数据 按规则填充到temp 数组
        // 直到左右两边的有序序列有一边处理完毕为止
        while(i <= mid && j <= right) { // 继续
            // 如果左边的有序序列的当前元素,小于等于右边有序序列的当前元素
            // 即将左边的当前元素,拷贝到temp数组
            // 然后 t++ , i++
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t += 1;
                i += 1;
            } else { // 反之
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }

        // 把有剩余数据的一边的数据依次全部填充到temp
        while(i<=mid) { // 左边的有序序列还有剩余的元素,就全部填充到temp
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }
        while(j<=right) {
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }


        // 将temp数组的元素拷贝到 arr
        // 注意,并不是每次都拷贝所有
        t = 0;
        int tempLeft = left;
        System.out.printf("tempLeft=%d right=%d \n",tempLeft,right);
        while(tempLeft <= right) { // 第一次合并 tempLeft = 0 , right = 1 // tempLeft = 2 , right = 3
            arr[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }

    }
}

基数排序

基数排序法是属于稳定性的排序,基数排序法的是效率高的稳定性排序法
图解:
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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个桶,每个桶就是一个一维数组
    int[][] bucket = new int[10][arr.length];
    // 为了记录每个桶中,实际存放了多少个数据,我们定义一个一维数组来记录每个桶每次放入的数据的个数
    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) {
                // 循环该桶,放入
                for (int l = 0; l < bucketElementCounts[k]; l++) {
                    // 取出元素放入到arr中
                    arr[index++] = bucket[k][l];
                }
            }
            bucketElementCounts[k] = 0;
        }
        System.out.println("arr = "+ Arrays.toString(arr));
    }
}

从算法可知,我们是利用空间来提高速度的。

外部排序

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值