JavaDS-排序

最新推荐文章于 2024-07-25 22:04:02 发布
最新推荐文章于 2024-07-25 22:04:02 发布
阅读量95 收藏
点赞数
分类专栏： JavaDB 文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YeZh1Yong_Cr/article/details/129051997
版权

一、插入排序

1. 直接插入排序

假定第一个元素有序，从第二个元素开始，把它放到 tmp，然后令 j 每次等于它前一个，然后依次跟 tmp 中的值进行比较，直到所有数据全部有序。

/**
     * 时间复杂度：
     * 最坏：O(N^2)
     * 最好：O(N)
     * 适合于：数据量不多，整体基本趋于有序
     * 空间复杂度：O(1)
     * 稳定性：  稳定
     * 一个本身就稳定的排序，可以实现为不稳定的排序
     * 但是一个本身就不稳定的排序 能实现为稳定的排序吗？？
     *
     * @param array
     */

    public static 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. 希尔排序（缩小增量排序）

希尔排序是直接排序的一个优化。采用分组的思想，通过多次分组，控制分组变量对每个组进行插入排序，而分组变量是逐次减少的，也就是缩小增量，这样可以让越大的数据越靠后，从而减小工作量。

    /**
     * 希尔排序
     * O(N^1.3)
     * 不是稳定的排序
     *
     * @param array
     * @param gap
     */

    public static 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 {
                    break;
                }
            }
            array[j + gap] = tmp;
        }
    }

    public static void shellSort(int[] array) {
        int gap = array.length;
        while (gap > 1) {
            gap /= 2;
            shell(array, gap);
        }
    }

二、选择排序

1. 直接选择排序

选择排序的思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

首先用 i 下标遍历数组，minIndex 存储最小值的下标，然后用 j 下标从 i 后一个开始遍历，遇到比 minIndex 小的就更新 minIndex ，最后交换 i 下标和 minIndex下标的值。

    /**
     * 选择排序
     * 时间复杂度：O(N^2)     和数据有序无序无关
     * 空间复杂度：O(1)
     * 稳定性： 不稳定
     *
     * @param array
     */

    public static 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;
                }
            }
            if (i != minIndex) {
                swap(array, minIndex, i);
            }
        }
    }

    private static void swap(int[] array, int i, int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

选择排序的另一个思路：

用两个变量存储最左边和最右边的元素，然后分别往中间靠拢，如果小就放到最左边，大就放到最右边。

    public static void selectSort2(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            int minIndex = left;
            int maxIndex = left;
            for (int j = left + 1; j <= right; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
                if (array[j] > array[maxIndex]) {
                    maxIndex = j;
                }
            }
            //最小值到前面
            swap(array, minIndex, left);
            //如果max下标正好是 left ， 说明已经把最大值从 left 换到 minIndex 位置
            if (maxIndex == left){
                maxIndex = minIndex;
            }
            //最大值到后面
            swap(array, maxIndex, right);
            left++;
            right--;
        }
    }

2. 堆排序 

  /**
     * 堆排序
     * 时间复杂度： O(n*logn)
     * 空间复杂度： O(1)
     * 稳定性：不稳定的算法
     *
     * @param array
     */
    public static void heapSort(int[] array) {
        createBigHeap(array);
        int end = array.length - 1;
        while (end > 0) {
            swap(array, 0, end);
            shiftDown(array, 0, end);
            end--;
        }
    }

    public static void createBigHeap(int[] array) {
        for (int parent = (array.length - 1 - 1) / 2; parent >= 0; parent--) {
            shiftDown(array, parent, array.length);
        }
    }

    private static void shiftDown(int[] array, int parent, int len) {
        int child = (2 * parent) + 1;
        while (child < len) {
            if (child + 1 < len && array[child] < array[child + 1]) {
                child++;
            }
            if (array[child] > array[parent]) {
                swap(array, child, parent);
                parent = child;
                child = 2 * parent + 1;
            } else {
                break;
            }
        }
    }

三、交换排序

1. 冒泡排序

    /**
     * 冒泡排序
     * 时间复杂度：（不考虑优化）： O(n^2)
     * 空间复杂度：O(1)
     * 稳定性：稳定的排序
     *
     * @param array
     */
    public static void bubbleSort(int[] array) {
        //最外层控制趟数
        for (int i = 0; i < array.length - 1; i++) {
            boolean flg = false;
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                    flg = true;
                }
            }
            if (flg == false) {
                break;
            }
        }
    }

2. 快速排序

（1）Hoare版

   /**
     * 快速排序
     * 时间复杂度：O(N*logN)
     * 空间复杂度：O(logN)    树的高度
     * 稳定性：不稳定的排序
     *
     * @param array
     * @param start
     * @param end   问题：
     *              当我们给定的数据 是有序的时候，这个快排的时间复杂度是O(n^2)
     *              空间复杂度：O(n)
     */
    private static void quick(int[] array, int start, int end) {
        //注意大于号必须写，预防1 2 3 4 5 6  直接没有左树，或者没有右树
        if (start >= end) {
            return;
        }
        int pivot = partitionHoare(array, start, end);
        quick(array, start, pivot - 1);
        quick(array, pivot + 1, end);
    }

    private static int partitionHoare(int[] array, int left, int right) {
        int i = left;
        int pivot = array[left];
        while (left < right) {
            //从左边开始找，必须先走右边。如果走左边，相遇之后的数据可能比基准大
            while (left < right &&      //预防外部循环到相等后，后面都比基准大
                    array[right] >= pivot) {    // 不能少等号，少了当有数据相等时会死循环
                right--;
            }
            //right下标值小于pivot了
            while (left < right &&
                    array[left] <= pivot) {
                left++;
            }
            //left下标值大于pivot
            swap(array, left, right);
        }
        //交换 和原来的left
        swap(array, left, i);
        return left;
    }

    public static void quickSort(int[] array) {
        quick(array, 0, array.length - 1);
    }

（2）挖坑法

    private static int partition(int[] array, int left, int right) {
        int pivot = array[left];
        while (left < right) {
            while (left < right && array[right] >= pivot) {
                right--;
            }
            array[left] = array[right];    //
            while (left < right &&
                    array[left] <= pivot) {
                left++;
            }
            array[right] = array[left];    //
            swap(array, left, right);
        }
        array[left] = pivot;
        return left;
    }

（3）前后指针

    private static int partitionPrevCur(int[] array, int left, int right) {
        int prev = left ;
        int cur = left+1;
        while (cur <= right) {
            if(array[cur] < array[left] && array[++prev] != array[left]) {
                swap(array,cur,prev);
            }
            cur++;
        }
        swap(array,prev,left);
        return prev;
    }

3. 快速排序优化

问题：当数据有序的时候，快速排序的时间复杂度会达到最大，而且空间复杂度也会随之改变。

快速排序采用分而治之的思想，按照前面分析时间复杂度的时候有提到，一开始有图例所示数据，进行分而治之正好找到中间，

 导致左边和右边的数据是均分的，那么最后的结果就可能会是接近于满二叉树的情况。

当按照上述所示方式进行划分时，效率就非常高，因为结果的 O(N*logN) 的推导就源自于此。

但是如果在划分的过程中数据一旦分布不均匀（比如有序时），就可能让子数据全部偏向一边，这样时间复杂度就会达到最高 O(n^2) 。

那么要怎么样才能达到均分的情况呢，这就用到第一种解决方式，三数取中法，这种方法可以对快速排序进行优化。

    private static void quick(int[] array, int start, int end) {
        if (start >= end) {
            return;
        }
        System.out.println("start: " + start + " end: " + end);

        //*在执行partition找基准之前，尽量解决划分不均匀的问题*//
        int index = findMidValOfIndex(array, start, end);
        swap(array, start, index);

        int pivot = partitionPrevCur_3(array, start, end);
        quick(array, start, pivot - 1);
        quick(array, pivot + 1, end);
    }

    //三数取中法
    private static int findMidValOfIndex(int[] array, int start, int end) {
        int midIndex = (start + end) / 2;
        if (array[start] < array[end]) {
            if (array[midIndex] < array[start]) {
                return start;
            } else if (array[midIndex] > array[end]) {
                return end;
            } else {
                return midIndex;
            }
        } else {
            if (array[midIndex] > array[start]) {
                return start;
            } else if (array[midIndex] < array[end]) {
                return end;
            } else {
                return midIndex;
            }
        }
    }

还可以采用另一种方式对快速排序进行进一步的优化，在递归到小的子区间时，考虑使用插入排序。

    private static void quick(int[] array, int start, int end) {
        if (start >= end) {
            return;
        }
        if (end - start + 1 <= 15) {
            //对start和end区间范围内使用插入排序
            insertSort(array, start, end);
            return;
        }

        //*在执行partition找基准之前，尽量解决划分不均匀的问题*//
        int index = findMidValOfIndex(array, start, end);
        swap(array, start, index);

        int pivot = partitionPrevCur_3(array, start, end);
        quick(array, start, pivot - 1);
        quick(array, pivot + 1, end);
    }

    private static void insertSort(int[] array, int left, int right) {
        for (int i = left + 1; i <= right; i++) {
            int tmp = array[i];
            int j = i - 1;
            for (; j >= left; j--) {
                if (array[j] > tmp) {
                    array[j + 1] = array[j];
                } else {
                    //array[j+1] = tmp;
                    break;
                }
            }
            array[j + 1] = tmp;
        }
    }

4. 快速排序非递归

    public static void quickSortNotRecursive(int[] array) {
        Stack<Integer> stack = new Stack<>();
        int start = 0;
        int end = array.length - 1;
        int pivot = partition_2(array, start, end);
        //1. 判断左边是否有两个元素
        if (pivot > start + 1) {
            stack.push(start);
            stack.push(pivot - 1);
        }
        //2. 判断右边是否有两个元素
        if (pivot < end - 1) {
            stack.push(pivot + 1);
            stack.push(end);
        }
        while (!stack.empty()) {
            end = stack.pop();
            start = stack.pop();
            //3. 判断左边是否有两个元素
            if (pivot > start + 1) {
                stack.push(start);
                stack.push(pivot - 1);
            }
            //4. 判断右边是否有两个元素
            if (pivot < end - 1) {
                stack.push(pivot + 1);
                stack.push(end);
            }
        }
    }

四、归并排序

1. 归并排序

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

核心步骤是将序列分解，然后将有序的子序列合并。

    /**
     * 归并排序
     * 时间复杂度：O(N*logN)
     * 空间复杂度：O(N)
     * 稳定性：稳定
     *
     * @param array
     */
    public static void mergeSort(int[] array) {
        mergeSortChild(array, 0, array.length - 1);
    }

    private static void mergeSortChild(int[] array, int left, int right) {
        if (left == right) {
            return;
        }
        int mid = (left + right) / 2;
        mergeSortChild(array, left, mid);
        mergeSortChild(array, mid + 1, right);

        //合并
        merge(array, left, mid, right);
    }

    //用合并两个有序数组的方式处理！
    private static void merge(int[] array, int left, int mid, int right) {
        int s1 = left;
        int e1 = mid;
        int s2 = mid + 1;
        int e2 = right;
        int[] tmpArr = new int[right - left + 1];
        int k = 0;
        while (s1 <= e1 && s2 <= e2) {
            if (array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];
            } else {
                tmpArr[k++] = array[s2++];
            }
        }
        while (s1 <= e1) {
            tmpArr[k++] = array[s1++];
        }
        while (s2 <= e1) {
            tmpArr[k++] = array[s2++];
        }
        //tmpArr当中的数据为有序的数据
        for (int i = 0; i < k; i++) {
            array[i + left] = tmpArr[i];
        }
    }

2. 非递归的归并排序

    public static void mergeSortNotRecursive(int[] array) {
        int gap = 1;
        while (gap < array.length) {
            for (int i = 0; i < array.length; i += gap * 2) {
                int left = i;
                int mid = left + gap - 1;
                int right = mid + gap;
                //注意处理越界问题
                if (mid >= array.length) {
                    mid = array.length - 1;
                }
                if (right >= array.length) {
                    right = array.length - 1;
                }
                merge(array, left, mid, right);
            }
            gap *= 2;
        }
    }

3. 海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序

前提：内存只有1G，需要排序的数据有100G

因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序的最常用的外部排序。

1. 先把文件切分成200分，每个512M

2. 分别对512M排序（把这512M数据读取到内存中，使用快排（或者其他的排序），写回文件当中），因为内存已经可以放的下，所以任意排序方式都可以

3. 进行2路归并，同时对200份有序文件做归并过程，最终结果就有序了

神的宠儿yu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaDS_code
03-22
在这个JavaDS_code项目中，我们可能还会遇到更高级的数据结构，如堆（用于优先队列或排序）、哈希表（提供快速的查找和插入操作）和堆栈（用于回溯或递归计算）。这些数据结构的实现通常包括插入、删除、查找等基本...
JavaDS:JavaDS_HomeWork_Author
03-17
如果"JavaDS-master"是项目源码的名称，那么里面应该包含了该项目的所有源代码文件，可能包括配置文件、数据库连接类、业务逻辑类等。通过阅读和分析这些代码，我们可以更深入地了解JavaDS在实际项目中的应用和实现...
java 自定义对象排序
sinat_34393490的博客
09-05 1178
自定义对象排序 Arrays 位置 java.util包， 其中.sort 对指定数据进行升序的方式排序   方法一：对自定义对象 必需 要实现 Comparable 接口 并且重写里面 compareTo 方法 import java.util.Arrays; /** * 使用arrays对指定数据进行升序排序 * @author Administrator，，这里是调用处 *...
最优合并问题
qq_43542311的博客
05-04 822
问题描述 给定k个排好序的序列s1,s2, …, sk，用2路合并算法将这k个序列合并成一个序列。假设采用的2路合并算法合并2个长度分别为m和n的序列需要m+n-1次比较。试设计一个算法确定合并这个序列的最优合并顺序，使所需的总比较次数最少。 为了进行比较，还需要确定合并这个序列的最差合并顺序，使所需的总比较次数最多。 算法分析 对于给定的k个待合并序列，计算最多比较次数和最少比较次数合并方案，...
c语言-最优合并问题
weixin_44924819的博客
10-06 2725
问题描述： 给定k个排好序的序列s1,s2,…,sk，用2路合并算法将这k个序列合并成一个序列。假设采用的2路合并算法合并2个长度分别为m和n的序列需要m+n-1次比较。试设计一个算法确定合并这个序列的最优合并顺序，使所需的总比较次数最少。 为了进行比较，还需要确定合并这个序列的最差合并顺序，使所需的总比较次数最多。 算法设计：对于给定的k个待合并序列，计算最多比较次数和最少比较次数合并方案。 数据输入：由文件input.txt给出输入数据。第1行有1个正整数k，表示有k个待合并序列。接下来的1行中，有k个
JavaDS--计数排序
sunjiac的博客
04-22 143
前面所讲的排序都需要进行比较才能排序------比较类型的排序算法 桶排序 场景：数据局密集，几种在某个范围中 时间复杂度：O(N) ， N：表示区间中元素的个数 空间复杂度：O(M) ，M: 表示区间中元素种类的个数 稳定性：稳定 实现代码： public static void countSort(int[] array){ //1.统计元素的范围 ...
JavaDS--排序、插入排序、希尔排序
sunjiac的博客
04-08 108
排序 概念： 排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 平时的上下文中，如果提到排序，通常指的是排升序。 稳定性： 两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。 看一个排序算法是否稳定： 该排序算法在进行的过程中是否将跨元素进行交换或者夸元素进行插入---->是：则不稳定 插入排序 直接...
JavaDS--选择排序、堆排序
sunjiac的博客
04-08 183
选择排序 每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。 时间复杂度：O(N^2) 空间复杂度：O(1) 稳定性：不稳定 public static void selectSort(int[] array){ for(int i=0;i<array.length-1;i++){ /...
JavaDS--归并排序、冒泡排序
sunjiac的博客
04-22 138
归并排序 原理：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使 子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并 **合并两个有序数组、一个数组分成两部分，两部分都有序 ** [left,mid) [mid,right) 在排序过程中重复利用两个数组，减少元素的复制过程 public static void mergeDate(int[] arrar,in...
JavaDS-二叉树
YeZh1Yong 的博客
02-12 201
二叉树详解及相关OJ题
JavaDS —— 排序
hong_z_c的博客
07-24 1119
Java 语言实现 七大排序算法加 计数排序
JavaDS:Java数据结构和算法
05-24
##Java数据结构与算法数组栈队列：优先级队列链表：单链表 双端链表 有序链表 双向链表 链表ADT二叉树：完全二叉树 红黑树堆图哈希表递归###查找：二分查找###排序：冒泡排序选择排序插入排序希尔排序归并排序快速...
Java语言-数据结构与算法视频教程 （第一部分）
07-03
|____08.JavaDS_简单排序_插入排序.mp4 |____07.JavaDS_简单排序_选择排序.mp4 |____06.JavaDS_简单排序_冒泡排序.mp4 |____05.JavaDS_存储对象的数组和大O表示法.mp4 |____04.JavaDS_有序数组和二分查找.mp4 |____...
【算法】插入排序 与 希尔排序 概念+图解+代码【Python C C++】
最新发布
2302_79596028的博客
07-25 454
【算法】插入排序 与 希尔排序 概念+图解+代码【Python C C++】
c语言（7.23）
fhgfyrsg的博客
07-23 595
【代码】c语言（7.23）
java常用8大排序
zzp1224的博客
07-24 713
Java中的八大排序算法是编程中常用的排序方法，每种排序算法都有其独特的特点和应用场景。
7种常见排序算法的C++实现及其复杂度与稳定性
ZY52678的博客
07-24 444
在排序过程中，相等的元素在最终排序完成后可能会改变它们原始的相对顺序。换句话说，如果两个元素在原始数组中是相邻的，并且它们的值相同，但在排序后的数组中它们的相对顺序发生了变化，那么这个排序算法就是不稳定的。举个例子来说明不稳定排序算法：假设我们有一个数组[5, 3, 4,5, 5]并且我们使用快速排序算法对其进行排序。在快速排序的过程中，我们选择第一个元素 5 作为基准。然后我们对数组进行分区，使得所有小于 5 的元素都在 5 的左边，所有大于 5 的元素都在 5 的右边。
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 881
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 186
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值