Java中几种基于比较的排序

最新推荐文章于 2023-08-08 14:30:23 发布
最新推荐文章于 2023-08-08 14:30:23 发布
阅读量194 收藏
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cccc_csdn_li/article/details/106358541
版权

排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。平时的上下文中，如果提到排序，通常指的是排升序（非降序）。通常意义上的排序，都是指的原地排序(in place sort)。

稳定性，两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。

直接插入排序
原理：整个区间被分为有序区间和无序区间，每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。

实现：

	public static void insertSort(int[] array) {
        int tmp = 0;
        for (int i = 1; i < array.length; i++) {
            tmp = array[i];
            int j;
            for (j = i-1; j >= 0 ; j--) {
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

性能分析：
时间复杂度：最坏情况是O(n^2)，最好情况(有序的情况)O(n)；
空间复杂度：O(1)；
稳定性：稳定的排序。
插入排序，初始数据越接近有序，时间效率越高。

希尔排序
原理：希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

实现：

    public static void shell(int[] array,int gap) {
        int tmp = 0;
        for (int i = gap; i < array.length; i+=1) {
            tmp = array[i];
            int j;
            for (j = i-gap; 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[] drr = {5,3,1};
        for (int i = 0; i < drr.length; i++) {
            shell(array,drr[i]);
        }
    }

性能分析：
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：不稳定排序

选择排序
原理：每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。

实现：

    public static void selectSort(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = i+1; j < array.length ; j++) {
                if(array[j] < array[i]) {
                    int tmp = array[j];
                    array[j] = array[i];
                    array[i] = tmp;
                }
            }
        }
    }

性能分析：
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：不稳定排序

堆排序
原理：基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。（排升序要建大堆；排降序要建小堆。）

实现：

    public static void adjustDown(int[] array,int root,int len) {
        int parent = root;
        int child = 2*parent+1;
        while (child < len) {
            if(child+1 < len && array[child] < array[child+1]) {
                child++;
            }
            if(array[child] > array[parent]) {
                int tmp = array[child];
                array[child] = array[parent];
                array[parent] = tmp;
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

    public static void createHeap(int[] array) {
        for (int i = (array.length-1-1)/2; i>= 0 ; i--) {
            adjustDown(array,i,array.length);
        }
    }
    
    public static void heapSort(int[] array) {
        createHeap(array);
        int end = array.length-1;
        while (end > 0) {
            int tmp = array[0];
            array[0] = array[end];
            array[end] = tmp;
            adjustDown(array,0,end);
            end--;
        }
    }

性能分析：
时间复杂度：O(n*(logn))
空间复杂度：O(1)
稳定性：不稳定排序

冒泡排序
原理：在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。

实现：

    public static void bubbleSort(int[] array) {
        //i  表示趟数
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }
    
    //优化
    public static void bubbleSort1(int[] array) {
        boolean flg = false;
        //i  表示趟数
        for (int i = 0; i < array.length-1; i++) {
            flg = false;
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flg = true;
                }
            }
            if(flg == false) {
                return;
            }
        }
    }

性能分析：
时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定排序

快速排序
原理：首先从待排序区间选择一个数，作为基准值(pivot)； 然后，Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；最后采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

实现：

    //递归实现
    public static int partition(int[] array,int low,int high) {
        int tmp = array[low];
        while (low < high) {
            while (low < high && array[high] >= tmp) {
                high--;
            }
            array[low] = array[high];
            while (low < high && array[low] <= tmp) {
                low++;
            }
            array[high] = array[low];
        }
        array[low] = tmp;
        return low;
    }

    public static void insert_sort(int[] array,int start,int end) {
        int tmp = 0;
        for (int i = start+1; i <= end; i++) {
            tmp = array[i];
            int j;
            for (j = i-1; j >= start ; j--) {
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

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

    public static void three_num_mid(int[] array,int left,int right) {
        int mid = (left+right)/2;
        if(array[left] > array[right]) {
            swap(array,left,right);
        }
        if(array[mid] > array[left]) {
            swap(array,left,mid);

        }
        if(array[mid] > array[right]) {
            swap(array,mid,right);
        }
    }

    public static void quick(int[] array,int left,int right) {
        if(left >= right) {
            return;
        }
        if(right-left+1 <= 100) {
            insert_sort(array,left,right);
            return;
        }

        three_num_mid(array,left,right);

        int par = partition(array, left, right);
        quick(array,left,par-1);
        quick(array,par+1,right);
    }

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


    //非递归实现快速排序
    public static void quickSort(int[] array) {
        Stack<Integer> stack = new Stack<>();

        int left = 0;
        int right = array.length-1;

        int par = partition(array,left,right);

        if(par > left+1) {
            stack.push(left);
            stack.push(par-1);
        }
        if(par < right-1) {
            stack.push(par+1);
            stack.push(right);
        }
        while (!stack.empty()) {
            right = stack.pop();
            left = stack.pop();
            par =  partition(array,left,right);

            if(par > left+1) {
                stack.push(left);
                stack.push(par-1);
            }
            if(par < right-1) {
                stack.push(par+1);
                stack.push(right);
            }
        }

    }

性能分析：
时间复杂度：最好O(n * log(n))，最坏O(n^2)
空间复杂度：最好O(log(n))， 最坏O(n)
稳定性：不稳定排序

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

实现：

	//递归实现
    public static void merge(int[] array,int low,int mid,int high) {
        int s1 = low;
        int s2 = mid+1;
        int len = high-low+1;
        int[] ret = new int[len];
        int i = 0;
        while (s1 <= mid && s2 <= high) {
            if(array[s1] <= array[s2]) {
                ret[i++] = array[s1++];
            }else {
                ret[i++] = array[s2++];
            }
        }

        while (s1 <= mid) {
            ret[i++] = array[s1++];
        }

        while (s2 <= high) {
            ret[i++] = array[s2++];
        }

        for (int j = 0; j < ret.length; j++) {
            array[j+low] = ret[j];
        }

    }

    public static void mergeSortInternal(int[] array,int low,int high) {
        if(low >= high) {
            return;
        }
        int mid = (low+high)>>>1;
        mergeSortInternal(array,low,mid);
        mergeSortInternal(array,mid+1,high);
        merge(array,low,mid,high);
    }
    public static void mergeSort1(int[] array) {
        mergeSortInternal(array,0,array.length-1);
    }

    //非递归实现归并排序
    public static void mergeSort(int[] array) {
        for (int gap = 1; gap < array.length; gap *= 2) {
            mergeNor(array,gap);
        }
    }

    public static void mergeNor(int[] array,int gap) {
        int[] ret = new int[array.length];
        int k = 0;
        int s1 = 0;
        int e1 = s1+gap-1;
        int s2 = e1+1;
        int e2 = s2+gap-1 < array.length ? s2+gap-1 :  array.length-1;

        while (s2 < array.length) {
            while (s1 <= e1 && s2 <= e2) {
                if(array[s1] <= array[s2]) {
                    ret[k++] = array[s1++];
                }else {
                    ret[k++] = array[s2++];
                }
            }
            while (s1 <= e1) {
                ret[k++] = array[s1++];
            }
            while (s2 <= e2) {
                ret[k++] = array[s2++];
            }
            s1 = e2+1;
            e1 = s1+gap-1;
            s2 = e1+1;
            e2 = s2+gap-1 < array.length ? s2+gap-1 :  array.length-1;
        }
        while (s1 <= array.length-1) {
            ret[k++] = array[s1++];
        }

        for (int i = 0; i < ret.length; i++) {
            array[i] = ret[i];
        }
    }

性能分析：
时间复杂度：O(n * log(n))
空间复杂度：O(n)
稳定性：稳定排序

C_LI_JA01
关注
专栏目录
排序——最全的七大排序算法知识汇总
ZhangHahaaha的博客
05-10 535
目录概念什么是排序稳定性排序的分类总览1.插入排序直接插入排序原理代码实现性能分析折半插入排序希尔排序原理代码实现性能分析2.选择排序直接选择排序原理代码实现性能分析堆排序原理代码实现性能分析3.交换排序冒泡排序原理代码实现性能分析快速排序（重要）原理代码实现性能分析4.归并排序归并排序原理代码实现性能分析5.排序总结 概念 排序：一串记录，按照其中的某个或者某些关键字的大小，递增或者递减排列起来的操作。通常意义上的排序都是指原地排序。 什么是排序稳定性 排序稳定性：两个相等的数据，如果经过排序后，排序算法
Java中各个排序算法比较
weixin_59661960的博客
05-23 494
之前我在javase基础中初步了解了一下冒泡排序，现在想根据创建的排序算法总结出它们在各方面的优劣性。 下图为java常见的几种排序： 之前我们在刘老师的数据结构课程上也有学过时间复杂度和空间复杂度的概念，时间复杂度用来描述一个算法的执行时间，空间复杂度则是是对一个算法在运行过程中临时占用存储空间大小的一个度量。 一、交换排序 1、冒泡排序 核心思想是： 1、从第一个元素开始，比较相邻的两个元素。如果第一个比第二个大，则进行交换。 3、轮到下一组相邻元素，执行同样的比较操作，再找下一组，直
Java排序对比
LvLuffy的博客
09-08 404
一、冒泡排序代码：public class BubbleSortClass { public static void main(String[] str) { int[] arr = {20, 6, 14, 10, 7, 19, 8, 9, 11, 18, 16, 13, 15, 5, 1, 4, 12, 2, 3, 17}; int temp;
Java中的排序比较方法
qq_35751236的博客
07-31 227
Java中的排序比较方式：自然排序和比较器排序 一：自然排序：java.lang.Comparable Comparable接口中的方法：CompareTo(Object obj)，该方法返回值为int，正数则代表调用对象比obj大，反之相反。 如下是实现了CompareTo方法的Student类 //**********************************************
比较排序（java）
Zc9741的博客
02-08 258
一、比较排序 1.冒泡排序 算法思想：每次循环将最大/最小的元素顶到最前端，两层for循环 平均时间复杂度：O(n²) 最好时间复杂度：O(n) 空间复杂度：O(1)，仅需常数个辅助空间 稳定性：稳定 代码： public static void main(String[] args) { int[] arr={15,1,6,12,3,7,9,2}; bubbleSort(arr); printArr(arr); } private s
浅谈Java中几种常见的比较器的实现方法
08-29
在Java编程中，比较器（Comparator）是用来比较对象的关键工具，尤其在进行对象数组排序时。本文将深入探讨Java中三种常见的比较器实现方法：覆写`equals()`方法，实现`Comparable`接口以及继承`Comparator`接口。 ...
java源码排序-sortForJava:Java常用的几种排序源代码
05-24
在Java编程语言中，排序是数据处理中非常基础且重要的操作。`sortForJava`项目提供了Java中常用排序算法的源代码实现，帮助开发者更好地理解和掌握这些算法。在这个项目中，我们可以找到五种常见的排序算法，包括...
java堆排序和几种排序方法实现代码.pdf
12-27
Java中的堆排序是一种基于比较的排序算法，它利用了数据结构——堆的特性来实现排序。堆是一个近似完全二叉树的结构，并且满足堆的性质：即父节点的键值总是大于或等于（或者小于或等于）其子节点的键值。在这个例子...
java堆排序和几种排序方法实现代码文.pdf
11-13
Java堆排序是一种基于比较的排序算法，其核心思想是构建一个大顶堆或小顶堆，然后通过调整堆结构来达到排序的目的。在给定的代码中，`HeapSort` 类实现了堆排序的过程。 1. **堆排序流程**： - 首先，将待排序的数...
java中的排序方法,Java中的排序比较方式：自然排序和比较器排序
weixin_35064201的博客
03-14 138
这里所说到的Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是指执行这些排序算法时，比较两个对象“大小”的比较操作。我们很容易理解整型的 i>j 这样的比较方式，但当我们对多个对象进行排序时，如何比较两个对象的“大小”呢？这样的比较 stu1 > stu2 显然是不可能通过编译的。为了解决如何比较两个对象大小的问题，JDK提供了两个接口 java.lang.Co...
Java中七大基于比较的排序算法
流年、烟雨
04-10 1306
目录插入排序直接插入排序基本原理代码实现性能分析折半插入排序代码实现希尔排序基本原理代码实现性能分析选择排序单向选择排序基本原理代码实现性能分析双向选择排序代码实现堆排序基本原理代码实现性能分析冒泡排序基本原理代码实现性能分析快速排序基本原理代码实现（递归和非递归）性能分析归并排序基本原理代码实现性能分析排序总结各种排序算法之间的比较 插入排序 直接插入排序 基本原理 整个区间分为两部分：有序区...
Java:比较与排序
weixin_43770982的博客
06-19 421
1.两种比较接口分析 在“集合框架”中有两种比较接口：Comparable接口和Comparator接口。Comparable是通用的接口，用户可以实现它来完成自己特定的比较，而Comparator可以看成一种算法的实现，在需要容器集合实现比较功能的时候，来指定这个比较器，这可以看成一种设计模式，将算法和数据分离。 前者应该比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较...
Java的比较和排序
tragfarmer的博客
08-21 635
1- Java基本类型和引用类型 2- 什么是栈和堆？ 3- 存储在内存中的原始类型 4- 存储在内存中的引用类型 5- Java中的类型比较 6- 原始类型的比较 7- 引用类型的比较 7.1- 使用==操作符来比较引用类型 7.2- 使用equals(..) 来比较引用类型 7.3- 重写equals(Object)方法 8- 排序字符串数组的例子 9- 对象可以相互比较
六种比较排序算法的JAVA实现
观砚的博客
11-26 258
序言 这里说的六种比较排序算法分别是：冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。如果只记忆代码，我感觉这几种排序很容易就会搞混，然后忘记，毕竟我们关心的是能否出现正确的排序结果，而如何实现的——不好意思，等我有时间再看吧。所以，这里还是希望能够记住排序的思想，那么今后无论使用何种语言，比较排序就不是问题了。 代码之后的时间复杂度、空间复杂度及稳定性分析可能有出入，请批判的...
Java中基于比较的常见七大排序算法
weixin_47252176的博客
03-28 213
一、插入排序（我们按升序进行，下边的所有排序也是按升序进行的） 1.基本步骤： 给定一个数组，我们为了方便插入要排序的元素用bound来作为边界。将[0,bound)设定为已排序区间,将[bound,arr.length)设定为待排序区间。 将bound的值设定为1，想一下，要是只有一个元素，那么它一定是有序的，所以从bound后边的元素开始和bound前边的元素进行比较，要是比找到了比arr[bound]大的元素，就将这个元素向后搬运，要是小于或者等于的时候就找到了要插入的位置，为cur+ 1位置
java8排序-按与设定值最接近的顺序排序
最新发布
qq_37911998的博客
08-08 106
java8排序，降序，多字段排序，设定值最接近的顺序
Java字符串相似度匹配
热门推荐
汐日南莘的博客
11-16 1万+
原文:http://wdhdmx.iteye.com/blog/1343856#bc2319361 package com.xfl.boot.common.utils; /** * Created by XFL * time on 2018/11/16 0:10 * description: */ public class SimilarityUtils { public sta...
简单的字符串相似度匹配加排序
Sean豆子
10-11 3456
今天遇到一个问题，需要将一组字符串，跟结果需要的字符串相比较，根据相似性排列出来，思考了一个下午，想了一个简易的匹配算法，写出代码的时候下班了，回家调试了几次后就成功了，特此将该算法写出来。 思路：将一组字符串存储到list中，用两个for循环，先将list里第一个字符串与完整的结果字符串进行比较，匹配成功的，就跳出循环，匹配不成功，就将第二个字符串与完整的结果字符串进行比较，若成功...
JAVA实现常见排序算法比较
以下是对标题和描述中提到的几种排序算法的详细说明： 1. **希尔排序**（Shell Sort）：希尔排序是一种改进的插入排序，通过设置不同的间隔序列（希尔序列）来减少元素之间的距离，使得元素能更快地达到最终位置。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值