排序算法(Java版)

vampire-wpre2024-05-15 1:07

目录

今天我们学习一种算法：排序算法（本文的排序默认是从小到大顺序）！！！

1、直接插入排序

算法原理： 每次将无序序列中的第一个插入到有序序列当中，使有序序列仍为有序，第一趟排序默认第一个元素是有序的，类比于生活中的摸牌，每次将新的排插入已有的牌当中。直接插入排序的算法原理很简单，我们只需要找到每个元素该插入到哪个位置即可。

代码实现：

java 复制代码 
    public void InsertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if (array[j] > tmp) {
                    array[j + 1] = array[j];
                } else {
                    array[j + 1] = tmp;
                    break;
                }
            }
            array[j + 1] = tmp;
        }
    }

代码图解：

2、希尔排序

算法原理： 希尔排序又称缩小增量排序，原理是先选定一个数作为分组的组数，将数组进行分组，接着分别对每个组进行排序，每组排序好之后，缩小分组的组数，重复上述步骤，直到组数为1。对每个组进行排序，我们使用插入排序的方法进行排序。

代码实现：

java 复制代码 
    public void ShellSort(int[] array) {
        int gap = array.length;
        //分成gap组,对每一组进行插入排序
        while (gap > 1) {
            gap /= 2;
            shell(array, gap);
        }
    }
	//对每组进行插入排序
    public void shell(int[] array, int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i - gap;
            for (; j >= 0; j -= gap) {
                if (array[j] > tmp) {
                    array[j + gap] = array[j];
                } else {
                    array[j + gap] = tmp;
                    break;
                }
            }
            array[j + gap] = tmp;
        }
    }

3、直接选择排序

算法原理： 每次待排序序列中选择最小的元素和待排序的第一个元素交换
代码实现：

java 复制代码 
    public void SelectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            //交换minIndex下标和i下标的值
            int tmp = array[minIndex];
        	array[minIndex] = array[i];
        	array[i] = tmp;
        }
    }

4、堆排序

算法原理： 堆排序是借用堆这种数据结构来实现的一种排序算法，如果升排序，建立大根堆；如果排降序，建立小根堆 。建堆之后：

1、交换0下标元素和最后一个元素的值

2、然后重新将数组进行向下调整为大根堆

重复这两个步骤，直到全部有序

代码实现：

java 复制代码 
    public void HeapSort(int[] array) {
        //先创建大堆
        createBigHeap(array);
        int end = array.length - 1;
        while (end >= 0) {
        	//交换
            int tmp = array[0];
        	array[0] = array[end];
        	array[end] = tmp;
        	
            ShiftDown(array, 0, end);
            end--;
        }
    }
    
    public void createBigHeap(int[] array) {
        for (int parent = (array.length - 1 - 1) / 2; parent >= 0; parent--) {
            ShiftDown(array, parent, array.length);
        }
    }
    
    public void ShiftDown(int[] array, int parent, int end) {
        int child = parent * 2 + 1;
        while (child < end) {
			if (child + 1 < end && array[child] < array[child + 1]) {
            	child++;
        	}
            if (array[child] > array[parent]) {
            	//交换
                int tmp = array[parent];
        		array[parent] = array[child];
	        	array[child] = tmp;
	        	
                parent = child;
                child = parent * 2 + 1;
            } else {
                break;
            }
        }
    }

5、冒泡排序

算法原理： 遍历数组，每次比较相邻两个元素的大小，如果大的数字在前则交换两个元素的位置，这样就完成了一趟冒泡排序，此时最大的数到了最后，然后对前n-1个数进行相同的操作，直到有序。
代码实现：

java 复制代码 
    public void BubbleSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            for (int j = i; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                	//交换
                    int tmp = array[j];
	        		array[j] = array[j+1];
		        	array[j+1] = tmp;
                }
            }
        }
    }

问题：如果遍历一遍数组已经有序了，就不用再继续比较下去了，因此对上面代码进行优化

优化后:

java 复制代码 
    public void BubbleSort(int[] array) {
        boolean flg = false;
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = i; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                	//交换
                    int tmp = array[j];
	        		array[j] = array[j+1];
		        	array[j+1] = tmp;
                    flg = true;
                }
            }
            if (!flg) {
                break;
            }
        }
    }

6、快速排序

算法原理： 快速排序的基本思想就是：选定一个基准，通过一趟快速排序之后，能把数据分割为两部分，左边部分比基准的值小，右边的部分比基准的值大，接着再按照这个方法分别对基准左边部分和右边部分进行递归，重复这个步骤直到整个序列都有序。快速排序的最重要部分就是如何将序列分割成两部分，常见的分割方法有hoare法和挖坑法
Hoare法分割： 先选定一个基准（默认是第一个元素），定义left、right下标，left从序列最右边开始找比基准小的值（升序排序），找到之后停下来，接着让left从最左边开始找比基准大的值，找到之后停下来，将找到的这两个值交换，当left和right相遇时(left=right)，交换基准的值和left/right下标的值，这样left/right下标左边的元素全都比left/right下标的值小,右边的元素都比它大，这样就分割好了。

图解：

挖坑法：

和Hoare法的区别是：挖坑法是边找边交换，如图

6.1 递归实现

代码实现：

java 复制代码 
    public void QuickSort(int[] arr) {
        quick(arr, 0, arr.length - 1);
    }

    public void quick(int[] arr, int left, int right) {
    	//递归结束的条件
        if (left >= right) {
            return;
        }
        //进行分割
        int pio = partition(arr, left, right);
        quick(arr, 0, pio - 1);
        quick(arr, pio + 1, right);
    }

hoare法分割

java 复制代码 
    public int partition(int[] arr, int left, int right) {

        int tmp = arr[left];
        int i = left;
        while (left < right) {
            while (left < right && arr[right] >= tmp) {
                right--;
            }
            while (left < right && arr[left] <= tmp) {
                left++;
            }
            //交换
			int tmp = array[right];
	        array[right] = array[left];
		    array[left] = tmp;
        }
        //交换
		int tmp = array[i];
	    array[i] = array[left];
		array[left] = tmp;
        return left;
    }

挖坑法分割

java 复制代码 
    public int partition(int[] arr, int left, int right) {
        int tmp = arr[left];
        while (left < right) {
            while (left < right && arr[right] >= tmp) {
                right--;
            }
            arr[left] = arr[right];
            while (left < right && arr[left] <= tmp) {
                left++;
            }
	        array[right] = array[left];
        }
        arr[left] = tmp;
        return left;
    }

优化： 如果待排序序列是：1、2、3、4、5这种有序的序列，假如还是取第一个元素为基准，就会出现左边没有小于基准的值，如何让每次分割都是均匀分割？方法很简单，取序列最左边、最右边和中间位置的三个元素的中位数作为基准，再进行Hoare法或者挖坑法分割，此时每次都能均匀分割，如图

优化后：

java 复制代码 
    public void QuickSort(int[] arr) {
        quick(arr, 0, arr.length - 1);
    }

    public void quick(int[] arr, int left, int right) {
        //递归
        if (left >= right) {
            return;
        }
        //中位数的值作为基准
        int midIndex = midThreeIndex(arr, left, right);
        //交换
        int tmp = arr[left];
        arr[left] = arr[midIndex];
        arr[midIndex] = tmp;    
        int pio = partition(arr, left, right);
        quick(arr, 0, pio - 1);
        quick(arr, pio + 1, right);
    }
    public int partition(int[] arr, int left, int right) {
        int tmp = arr[left];
        int i = left;
        while (left < right) {
            while (left < right && arr[right] >= tmp) {
                right--;
            }
            while (left < right && arr[left] <= tmp) {
                left++;
            }
            swap(arr, right, left);
        }
        swap(arr, i, left);
        return left;
    }

6.2 非递归实现

原理： 利用栈这个数据结构来实现。首先先对序列进行一次分割（Hoare法或者挖坑法都可以），将基准左边部分的left、right下标入栈，再将右边部分的left、right下标入栈，然后出栈两个元素作为新的left、right来进行分割，重复上述步骤，直到栈为空

代码实现：

java 复制代码 
    public void QuickSortNoRecursion(int[] arr) {
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = arr.length - 1;
        int pio = partition(arr, left, right);
        if (pio > left + 1) {
            stack.push(left);
            stack.push(pio - 1);
        }
        if (pio < right - 1) {
            stack.push(pio + 1);
            stack.push(right);
        }
        while (!stack.isEmpty()) {
            right = stack.pop();
            left = stack.pop();
            pio = partition(arr, left, right);
            if (pio > left + 1) {
                stack.push(left);
                stack.push(pio - 1);
            }
            if (pio < right - 1) {
                stack.push(pio + 1);
                stack.push(right);
            }
        }
    }

7、归并排序

原理： 归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；归并排序的思想是：先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

7.1 递归实现

递归思路： 先将序列进行分解，直到分解为单个元素为一组，然后再进行合并。合并：开辟新的数组，新的数组存储的是合并之后且有序的子序列，再开辟的新数组的元素拷贝回原数组

java 复制代码 
    public void mergeSort(int[] arr) {
        merge(arr, 0, arr.length - 1);
    }

    public void merge(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int mid = (left + right) / 2;
        //分解
        merge(arr, left, mid);
        merge(arr, mid + 1, right);
        //合并
        mergeFun(arr, left, mid, right);
    }

    //合并
    public void mergeFun(int[] arr, int left,
                          int mid, int right) {
        int s1 = left;
        int e1 = mid;
        int s2 = mid + 1;
        int e2 = right;
        int k = 0;
        int[] tmp = new int[right - left + 1];//开辟新的数组
        while (s1 <= e1 && s2 <= e2) {
            if (arr[s1] < arr[s2]) {
                tmp[k++] = arr[s1++];
            } else {
                tmp[k++] = arr[s2++];
            }
        }

        while (s1 <= e1) {
            tmp[k++] = arr[s1++];
        }
        while (s2 <= e2) {
            tmp[k++] = arr[s2++];
        }
        //此时tmp有序了,拷回到原数组

        for (int i = 0; i < k; i++) {
            arr[left + i] = tmp[i];
        }
    }

7.2 非递归实现

非递归省去了分解的步骤，直接对数组进行合并

java 复制代码 
    //非递归
    public void mergeSortN(int[] arr) {
        mergeN(arr);
    }

    //没有分解的过程
    private void mergeN(int[] arr) {
        int gap = 1;
        while (gap <= arr.length) {
            for (int i = 0; i < arr.length; i = i + 2 * gap) {
                int mid = i + gap - 1;
                if (mid >= arr.length) {
                    mid = arr.length - 1;
                }
                int right = mid + gap;
                if (right >= arr.length) {
                    right = arr.length - 1;
                }
                mergeFun(arr, i, mid, right);
            }
            gap *= 2;
        }
    }
    public void mergeFun(int[] arr, int left,
                          int mid, int right) {
        int s1 = left;
        int e1 = mid;
        int s2 = mid + 1;
        int e2 = right;
        int k = 0;
        int[] tmp = new int[right - left + 1];
        while (s1 <= e1 && s2 <= e2) {
            if (arr[s1] < arr[s2]) {
                tmp[k++] = arr[s1++];
            } else {
                tmp[k++] = arr[s2++];
            }
        }

        while (s1 <= e1) {
            tmp[k++] = arr[s1++];
        }
        while (s2 <= e2) {
            tmp[k++] = arr[s2++];
        }
        //此时tmp有序了,拷回到原数组

        for (int i = 0; i < k; i++) {
            arr[left + i] = tmp[i];
        }
    }

8、性能分析

性能包括：时间复杂度、空间复杂度、稳定性

排序算法 平均时间复杂度 空间复杂度 稳定性
插入排序 O(n^2) O(1) 稳定
希尔排序 O(和增量有关) O(1) 不稳定
选择排序 O(n^2) O(1) 不稳定
堆排序 O(n*logn) O(1) 不稳定
冒泡排序 O(n^2) O(1) 稳定
快速排序 O(n*logn) O(logn) 不稳定
归并排序 O(n*logn) O(n) 稳定
相关推荐
xlsw_2 小时前
java全栈day20--Web后端实战(Mybatis基础2)
java·开发语言·mybatis
神仙别闹2 小时前
基于java的改良版超级玛丽小游戏
java
黄油饼卷咖喱鸡就味增汤拌孜然羊肉炒饭3 小时前
SpringBoot如何实现缓存预热？
java·spring boot·spring·缓存·程序员
XH华3 小时前
初识C语言之二维数组(下)
c语言·算法
暮湫3 小时前
泛型（2）
java
超爱吃士力架3 小时前
邀请逻辑
java·linux·后端
南宫生3 小时前
力扣-图论-17【算法学习day.67】
java·学习·算法·leetcode·图论
转码的小石3 小时前
12/21java基础
java
不想当程序猿_3 小时前
【蓝桥杯每日一题】求和——前缀和
算法·前缀和·蓝桥杯
李小白664 小时前
Spring MVC(上)
java·spring·mvc
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程