Java数据结构与算法（排序）

最新推荐文章于 2023-12-26 23:33:25 发布
最新推荐文章于 2023-12-26 23:33:25 发布
阅读量70 收藏
点赞数
分类专栏： # Java数据结构与算法 文章标签： java 算法
博客包含书籍、B站、其他博主博客等内容，只为了记录笔记，作业，问题，软件配置等，为了以后方便查阅，如有侵权，请联系删除
本文链接：https://blog.csdn.net/qq_51022106/article/details/125911953
版权

文章目录

一、简单排序

1.1 comparable接口

Java提供了一个接口Comparable就是用来定义排序规则的，在这里我们以案例的形式对Comparable接口做一个简单的回顾
需求：
1.定义一个学生类Student，具有年龄age和姓名username两个属性，并通过Comparable接口提供比较规则；
2.定义测试类Test，在测试类Test中定义测试方法Comparable getMax(Comparable c1,Comparable c2)完成测试

学生类：

package sort;

/**
 * @author wxs_blue
 * @create 2022-07-19 22:58
 */
public class Student implements Comparable<Student> {
    private String username;
    private int age;

    public Student(String username, int age) {
        this.username = username;
        this.age = age;
    }

    public Student() {
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Student o) {
        return this.getAge() - o.getAge();
    }

    @Override
    public String toString() {
        return "Student{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }
}

测试方法：

public static void main(String[] args) {
        Student s1 = new Student("zhangsan", 18);
        Student s2 = new Student("wangwu", 20);

        Comparable max = getMax(s1,s2);
        System.out.println(max);
    }

    public static Comparable getMax(Comparable c1,Comparable c2){
        int cmp = c1.compareTo(c2);
        if (cmp>=0){
            return c1;
        }else {
            return c2;
        }
    }

结果：
在这里插入图片描述

1.2 冒泡排序

排序原理：

  1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
  2. 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
    在这里插入图片描述

案例需求：
排序前：{4,5,6,3,2,1}
排序后：{1,2,3,4,5,6}

冒泡排序：

package sort;

/**
 * @author wxs_blue
 * @create 2022-07-19 23:07
 */
public class Bubble {
    /*
    对数组中的元素进行排序
     */
    public static void sort(Comparable[] a){
        for (int i = a.length-1; i >=0 ; i--) {
            for (int j = 0; j < i; j++) {
                if(greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }
    }
    /*
    比较大小
     */
    public static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
    交换位置
     */
    public static void exch(Comparable[] a,int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试方法：

@Test
    public void testBubble(){
        Integer[] a = {4,5,6,3,2,1};
        Bubble.sort(a);
        System.out.println(Arrays.toString(a));

    }

结果：
在这里插入图片描述

按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2)

1.3 选择排序

排序原理：

  1. 每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引
  2. 交换第一个索引处和最小值所在的索引处的值
    在这里插入图片描述

案例需求：
排序前：{4,6,8,7,9,2,10,1}
排序后：{1,2,4,5,7,8,9,10}

选择排序：

package sort;

/**
 * @author wxs_blue
 * @create 2022-07-19 23:37
 */
public class Selection {

    /*
    对数组进行排序
     */

    public static void sort(Comparable[] a){

        for (int i = 0; i <= a.length-2; i++) {
            //假设本次遍历，最小值所在的索引是i
            int minIndex = i;
            for (int j = i+1; j < a.length; j++) {
                if (greater(a[minIndex],a[j])){
                    //交换最小值所在的索引
                    minIndex = j;
                }
                //交换i索引处和minIndex索引处的值
                exch(a,i,minIndex);
            }
        }
    }

    /*
    比较大小
     */

    public static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
    交换位置
     */

    public static void exch(Comparable[] a,int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试类：

@Test
    public void testSelection(){
        Integer[] a = {4,6,8,7,9,2,10,1};
        Selection.sort(a);
        System.out.println(Arrays.toString(a));

    }

结果：
在这里插入图片描述

根据大O推导法则，保留最高阶项，去除常数因子，时间复杂度为O(N^2);

1.4 插入排序

排序原理：

  1. 把所有的元素分为两组，已经排序的和未排序的；
  2. 找到未排序的组中的第一个元素，向已经排序的组中进行插入；
  3. 倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位；
    在这里插入图片描述

案例需求：
排序前：{4,3,2,10,12,1,5,6}
排序后：{1,2,3,4,5,6,10,12}

插入排序：

package sort;

/**
 * @author wxs_blue
 * @create 2022-07-19 23:53
 */
public class Insertion {
    /*
    对数组进行排序
     */
    public static void sort(Comparable[] a){

        for (int i = 1; i < a.length; i++) {

            //当前元素为a[i],依次和i前面的元素比较，找到一个小于等于a[i]的元素
            for (int j = i; j > 0 ; j--) {
                if (greater(a[j-1],a[j])){
                    //交换元素
                    exch(a,j-1,j);
                } else {
                    //找到了该元素，结束
                    break;
                }
            }

        }
    }

    /*
    比较大小
     */
    public static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
    交换位置
     */
    public static void exch(Comparable[] a,int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试方法：

@Test
    public void testInsertion(){
        Integer[] a = {4,3,2,10,12,1,5,6};
        Insertion.sort(a);
        System.out.println(Arrays.toString(a));

    }

结果：
在这里插入图片描述

按照大O推导法则，保留函数中的最高阶项那么最终插入排序的时间复杂度为O(N^2).

二、高级排序

之前我们学习过基础排序，包括冒泡排序，选择排序还有插入排序，并且对他们在最坏情况下的时间复杂度做了分析，发现都是O(N^2)，而平方阶通过我们之前学习算法分析我们知道，随着输入规模的增大，时间成本将急剧上升，所以这些基本排序方法不能处理更大规模的问题，接下来我们学习一些高级的排序算法，争取降低算法的时间复杂度最高阶次幂。

2.1 希尔排序

希尔排序是插入排序的一种，又称“缩小增量排序”，是插入排序算法的一种更高效的改进版本。

前面学习插入排序的时候，我们会发现一个很不友好的事儿，如果已排序的分组元素为{2,5,7,9,10}，未排序的分组元素为{1,8}，那么下一个待插入元素为1，我们需要拿着1从后往前，依次和10,9,7,5,2进行交换位置，才能完成真正的插入，每次交换只能和相邻的元素交换位置。那如果我们要提高效率，直观的想法就是一次交换，能把1放到更前面的位置，比如一次交换就能把1插到2和5之间，这样一次交换1就向前走了5个位置，可以减少交换的次数，这样的需求如何实现呢？接下来我们来看看希尔排序的原理。

排序原理：

  1. 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
  2. 对分好组的每一组数据完成插入排序；
  3. 减小增长量，最小减为1，重复第二步操作。

案例需求：
排序前：{9,1,2,5,7,4,8,6,3,5}
排序后：{1,2,3,4,5,5,6,7,8,9}

希尔排序：

package sort;

/**
 * @author wxs_blue
 * @create 2022-07-21 15:44
 */
public class Shell {

    /*
    对数组进行排序
     */
    public static void sort(Comparable[] a){
        int N = a.length;
        //确定增量值
        int h = 1;
        while (h<N/2){
            h = h*2+1;
        }

        //当增量h<1,排序结束
        while (h>=1){
            //找到待插入元素
            for (int i = h; i < N; i++) {
                //a[i]就是待插入的元素
                //把a[i]插入到a[i-h],a[i-2h],a[i-3h]...序列中
                for (int j = i; j >=h ; j-=h) {
                    //a[j]就是待插入元素，依次和a[j-h],a[j-2h],a[j-3h]进行比较，如果a[j]小，那么交换位置，如果不小于，a[j]大，则插入完成。
                    if (greater(a[j-h],a[j])){
                        exch(a,j,j-h);
                    }else {
                        break;
                    }
                }
            }
            h = h/2;
        }
    }

     /*
    比较大小
     */

    public static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
    交换位置
     */

    public static void exch(Comparable[] a,int i, int j){
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试方法：

@Test
    public void Shell(){
        Integer[] a = {9,1,2,5,7,4,8,6,3,5};
        Shell.sort(a);
        System.out.println(Arrays.toString(a));

    }

结果：
在这里插入图片描述

在希尔排序中，增长量h并没有固定的规则，有很多论文研究了各种不同的递增序列，但都无法证明某个序列是最好的，这里就不做分析

希尔排序和插入排序性能比较

我们可以使用事后分析法对希尔排序和插入排序做性能比较。
在资料的测试数据文件夹下有一个reverse_shell_insertion.txt文件，里面存放的是从100000到1的逆向数据，我们可以根据这个批量数据完成测试。测试的思想：在执行排序前前记录一个时间，在排序完成后记录一个时间，两个时间的时间差就是排序的耗时。
在这里插入图片描述
测试代码：

import sort.Insertion;
import sort.Shell;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class SortCompare {
    public static void main(String[] args) throws Exception{
        ArrayList<Integer> list = new ArrayList<>();
        //读取reverse_arr.txt文件
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("reverse_shell_insertion.txt")));
        String line=null;
        while((line=reader.readLine())!=null){
            //把每一个数字存入到集合中
            list.add(Integer.valueOf(line));

        }

        reader.close();

        //把集合转换成数组
        Integer[] arr = new Integer[list.size()];


        list.toArray(arr);

        testInsertion(arr);//使用插入排序耗时：20859

        testShell(arr);//使用希尔排序耗时：31
    }


    public static void testInsertion(Integer[] arr){
        //使用插入排序完成测试
        long start = System.currentTimeMillis();
        Insertion.sort(arr);
        long end= System.currentTimeMillis();
        System.out.println("使用插入排序耗时："+(end-start));
    }

    public static void testShell(Integer[] arr){
        //使用希尔排序完成测试
        long start = System.currentTimeMillis();
        Shell.sort(arr);
        long end = System.currentTimeMillis();
        System.out.println("使用希尔排序耗时："+(end-start));
    }

}

结果：

在这里插入图片描述
在这里插入图片描述

通过测试发现，在处理大批量数据时，希尔排序的性能确实高于插入排序。

2.2 归并排序

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

排序原理：

  1. 尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止。
  2. 将相邻的两个子组进行合并成一个有序的大组；
  3. 不断的重复步骤2，直到最终只有一个组为止。
    在这里插入图片描述
    案例需求：
    排序前：{8,4,5,7,1,3,6,2}
    排序后：{1,2,3,4,5,6,7,8}

归并排序：

package sort;

/**
 * @author wxs_blue
 * @create 2022-07-21 16:54
 */
public class Merge {
    //归并所需要的辅助数组
    private static Comparable[] assist;

    /*
    对整个数组进行排序
     */
    public static void sort(Comparable[] a){
        assist = new Comparable[a.length];
        int lower = 0;
        int high = a.length-1;
        sort(a,lower,high);
    }

    /*
    对数组从lower到high之间的元素进行排序
     */
    private static void sort(Comparable[] a, int lower, int high){
        //安全性检验
        if (high<=lower){
            return;
        }

        //防止数据过大，超出整形范围
        int mid = lower + (high - lower) / 2;

        //对lower到mid之间的元素分组
        sort(a,lower,mid);

        //对mid到high之间的元素分组
        sort(a,mid+1,high);

        //对lower到mid这组数据 和 mid到high这组数据 进行归并 并 排序
        merge(a,lower,mid,high);

    }

    private static void merge(Comparable[] a, int lower, int mid, int high){
        //定义3个指针
        int i = lower;
        int p1 = lower;
        int p2 = mid + 1;

        //比较左边小组和右边小组中的元素大小，哪个小，就把哪个数据填充到assist数组中
        while (p1<=mid&&p2<=high){
            if (less(a[p1],a[p2])){
                assist[i++] = a[p1++];
            } else {
                assist[i++] = a[p2++];
            }
        }

        //上面的循环结束后，如果退出循环的条件是p1<=mid，则证明左边小组中的数据已经归并完毕，如果退出循环的条件是p2<=hi,则证明右边小组的数据已经填充完毕；
        //所以需要把未填充完毕的数据继续填充到assist中,//下面两个循环，只会执行其中的一个
        while (p1<=mid){
            assist[i++] = a[p1++];
        }
        while (p2<=high){
            assist[i++] = a[p2++];
        }

        //到现在为止，assist数组中，从lo到hi的元素是有序的，再把数据拷贝到a数组中对应的索引处
        for (int index = lower; index <= high; index++) {
            a[index] = assist[index];
        }
    }

    /*
       比较v元素是否小于w元素
    */
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    /*
    数组元素i和j交换位置
     */
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试方法：

 @Test
    public void testMerge(){
        Integer[] arr = {8, 4, 5, 7, 1, 3, 6, 2};
        Merge.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

结果：
在这里插入图片描述

根据大O推导法则，忽略底数，最终归并排序的时间复杂度为O(nlogn);

归并排序的缺点：

  • 需要申请额外的数组空间，导致空间复杂度提升，是典型的以空间换时间的操作

归并排序与希尔排序性能测试

在资料的测试数据文件夹下有一个reverse_shell_insertion.txt文件，里面存放的是从100000到1的逆向数据，我们可以根据这个批量数据完成测试。测试的思想：在执行排序前前记录一个时间，在排序完成后记录一个时间，两个时间的时间差就是排序的耗时。

测试代码：

import sort.Merge;
import sort.Shell;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class SortCompare {
    public static void main(String[] args) throws Exception{
        ArrayList<Integer> list = new ArrayList<>();
        //读取a.txt文件
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("reverse_merge_shell.txt")));
        String line=null;
        while((line=reader.readLine())!=null){
            //把每一个数字存入到集合中
            list.add(Integer.valueOf(line));
        }
        reader.close();
        //把集合转换成数组
        Integer[] arr = new Integer[list.size()];
        list.toArray(arr);

        testMerge(arr);//使用归并排序耗时：1200

        testShell(arr);//使用希尔排序耗时：1277

    }


    public static void testMerge(Integer[] arr){
        //使用插入排序完成测试
        long start = System.currentTimeMillis();
        Merge.sort(arr);
        long end= System.currentTimeMillis();
        System.out.println("使用归并排序耗时："+(end-start));

    }


    public static void testShell(Integer[] arr){
        //使用希尔排序完成测试
        long start = System.currentTimeMillis();
        Shell.sort(arr);
        long end = System.currentTimeMillis();
        System.out.println("使用希尔排序耗时："+(end-start));

    }

}

结果：
在这里插入图片描述

在这里插入图片描述

通过测试，发现希尔排序和归并排序在处理大批量数据时差别不是很大。

2.3 快速排序

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

排序原理：

  1. 首先设定一个分界值，通过该分界值将数组分成左右两部分；
  2. 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
  3. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
  4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
    在这里插入图片描述
    案例需求：
    排序前:{6, 1, 2, 7, 9, 3, 4, 5, 8}
    排序后:{1, 2, 3, 4, 5, 6, 7, 8, 9}

快速排序：

package sort;

/**
 * @author wxs_blue
 * @create 2022-07-21 22:41
 */
public class Quick {

    /*
    对整个数组进行排序
     */
    public static void sort(Comparable[] a){
        int lower = 0;
        int high = a.length-1;
        sort(a,lower,high);
    }

    /*
    对lower到high之间的元素进行排序
     */
    private static void sort(Comparable[] a,int lower,int high){
        if(high<=lower){
            return;
        }

        int partition = partition(a,lower,high);

        //对左边分组中的元素进行排序
        sort(a,lower,partition-1);

        //对右边分组中的元素进行排序
        sort(a,partition+1,high);
    }

    public static int partition(Comparable[]a,int lower,int high){
        //把最左边的元素当做基准值
        Comparable key = a[lower];

        //定义两测指针
        int left = lower;
        int right = high+1;

        //进行切分
        while (true){

            //先从右往左扫描，找到一个比基准值小的元素
            while (less(key,a[--right])){
                if (right==lower){
                    break;
                }
            }

            //再从左往右扫描，找一个比基准值大的元素
            while (less(a[++left],key)){
                if (left==high){
                    break;
                }
            }

            //扫描完了所有元素，结束循环
            if(left>=right){
                break;
            } else {
                //交换left和right索引处的元素
                exch(a,left,right);
            }
        }
        //交换最后rigth索引处和基准值所在的索引处的值
        exch(a,lower,right);

        //right就是切分的界限
        return right;
    }

    /*
   比较v元素是否小于w元素
*/
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    /*
    数组元素i和j交换位置
     */
    private static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

测试方法：

@Test
    public void testQuick(){
        Integer[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 8};
        Quick.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

结果：
在这里插入图片描述

最优情况下快速排序的时间复杂度为O(nlogn)
最坏情况下，快速排序的时间复杂度为O(n^2)

快速排序和归并排序的区别：

  • 快速排序是另外一种分治的排序算法，它将一个数组分成两个子数组，将两部分独立的排序。快速排序和归并排序是互补的：归并排序将数组分成两个子数组分别排序，并将有序的子数组归并从而将整个数组排序，而快速排序的方式则是当两个数组都有序时，整个数组自然就有序了。在归并排序中，一个数组被等分为两半，归并调用发生在处理整个数组之前，在快速排序中，切分数组的位置取决于数组的内容，递归调用发生在处理整个数组之后。

三、排序的稳定性

稳定性的定义：

  • 数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保证A元素依然在B元素的前面，可以说这个该算法是稳定的。
    在这里插入图片描述
    稳定性的意义：
  • 如果一组数据只需要一次排序，则稳定性一般是没有意义的，如果一组数据需要多次排序，稳定性是有意义的。
  • 例如要排序的内容是一组商品对象，第一次排序按照价格由低到高排序，第二次排序按照销量由高到低排序，如果第二次排序使用稳定性算法，就可以使得相同销量的对象依旧保持着价格高低的顺序展现，只有销量不同的对象才需要重新排序。这样既可以保持第一次排序的原有意义，而且可以减少系统开销。

常见排序算法的稳定性：

  • 冒泡排序：
    只有当arr[i]>arr[i+1]的时候，才会交换元素的位置，而相等的时候并不交换位置，所以冒泡排序是一种稳定排序算法。
  • 选择排序:
    选择排序是给每个位置选择当前元素最小的,例如有数据{5(1)，8 ，5(2)， 2， 9 },第一遍选择到的最小元素为2，所以5(1)会和2进行交换位置，此时5(1)到了5(2)后面，破坏了稳定性，所以选择排序是一种不稳定的排序算法。
  • 插入排序：
    比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么把要插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
  • 希尔排序：
    希尔排序是按照不同步长对元素进行插入排序 ,虽然一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以希尔排序是不稳定的。
  • 归并排序：
    归并排序在归并的过程中，只有arr[i]<arr[i+1]的时候才会交换位置，如果两个元素相等则不会交换位置，所以它并不会破坏稳定性，归并排序是稳定的。
  • 快速排序：
    快速排序需要一个基准值，在基准值的右侧找一个比基准值小的元素，在基准值的左侧找一个比基准值大的元素，然后交换这两个元素，此时会破坏稳定性，所以快速排序是一种不稳定的算法。
Java数据结构实现折半查找的算法过程解析
08-19
主要介绍了Java数据结构实现折半查找的算法过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java利用二分法进行排序
EatingSoilLang
12-18 5096
二分法排序 二分法排序是直接插入排序的改进版本，直接插入排序插入到前方集合中时采用的方式是逐个比较，二分法则是采用二分比较，与直接排序算法最大的区别在于查找插入位置时使用的是二分查找的方式，在速度上有一定提升。 1、算法思想 总共有N个元素，当插入第i个元素时，对前面的0~i-1个元素进行折半，先跟他们中间的那个元素比，如果小，那么再对前一半的元素进行折半，否则对后一半的元素进行折半，知道左<右，然后再把第i个元素前一位于目标位置之间的所有元素后移，再把第i个元素放在目标位置上。 举例： 例如有个
堆排序
沐雨金鳞
09-25 243
https://img2018.cnblogs.com/blog/1469176/201903/1469176-20190329000545588-1486048945.gif /** * 堆排序演示 */ class HeapSort { public static void main(String[] args) { // int[] arr = {5, 1, 7, 3, 1, 6, 9, 4}; int[] arr = {16, 7, 3, 20, 17,.
排序的稳定性
枸杞仙人的博客
02-08 550
排序稳定性定义意义常见算法稳定性冒泡排序选择排序插入排序希尔排序归并排序快速排序 定义 数组arr中有若干元素，其中A元素和B元素相等，并且A元素在B元素前面，如果使用某种排序算法排序后，能够保证A元素依然在B元素的前面，可以说这个该算法是稳定的。 意义 如果一组数据只需要一次排序，则稳定性一般是没有意义的，如果一组数据需要多次排序，稳定性是有意义的。例如要排序的内容是一组商品对象，第一次排序按照价格由低到高排序，第二次排序按照销量由高到低排序，如果第二次排序使用稳定性算法，就可以使得相同销量的对象依旧保
头歌 编程题实训-查找
m0_54699006的博客
12-26 1188
【代码】头歌 编程题实训-查找。
java数据结构与算法.pdf
01-04
Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点进行详细解释。 1. **数据结构**： - **稀疏数组**：当大量数据中大部分为零或...
Java数据结构与算法源代码
02-04
数据结构与算法的定义 1.广义上理解数据结构与算法： 数据结构是指一组数据的存储结构。算法就是操作数据的一组方法。 ps:图书馆管理员将书籍分门别类“存储”，按照一定规律编号，就是书籍这种“数据的存储结构...
java数据结构与算法.zip
最新发布
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
java二分法排序_二分法排序讲解『附视频』
weixin_28900461的博客
02-19 1136
二分法排序讲解『附视频』时间：2017-06-22来源：华清远见JAVA学院算法一直是Java编程学习中的重点和难点，今天华清Java学院小编就和大家分享一下Java中的二分法排序。①二分法排序的基本思想二分法排序是一种快速排序算法，二分法排序的基本思想与直接插入排序一样，在插入第i(i≥1)个元素时，前面i−1个元素已经排好序。区别在于寻找插入位置的方法不同，二分法排序是采用折半查找法...
二分法(java)
m0_65144570的博客
06-12 1891
二分法是一种常见的算法思想，也称为二分查找、折半查找。其核心思想是通过将目标数据与有序的数据序列进行比较，每次查找都将数据序列一分为二，确定目标数据在哪一半中，直到找到目标数据或者确定目标数据不存在。将数据序列按照某种方式排序（一般是从小到大）。确定要查找的目标数据。确定查找的范围，在数据序列的左边界和右边界之间。每次将查找的范围一分为二，找到中间位置的数据，与目标数据进行比较。如果中间位置的数据等于目标数据，则查找成功，返回该位置；否则，判断目标数据在左边还是右边，缩小查找的范围。
Java基础部分-二分查找以及排序*
saber_qing的博客
04-01 454
这篇文章建立在一定的学习基础上，适用于复习查看
二分查找-面试选择题
Yang_Ming_Lei的博客
05-17 797
二分面试选择题
java二分排序算法
m0_54123296的博客
08-09 1075
java 二分排序
二分法插入排序算法原理及JAVA实现
学习亦游戏
06-13 9863
基本思想：插入排序的基本操作是在一个有序表中进行查找和插入，用折半查找实现查找步骤。 复杂度：时间复杂度 O(n2)  空间复杂度O(1) JAVA源代码（成功运行）： package testSortAlgorithm; public class BinaryInsertionSort { public static void main(String[] args) {
学习Java算法 | 快速掌握排序算法和二分查找的实现方法
亮点菌
04-06 830
本文主要提到了在学习Java编程中，掌握常见的排序算法和二分查找的重要性。排序算法可以提高程序效率，二分查找可以降低程序时间复杂度。对于刚刚入门Java编程或者想要提高编程实力的人来说，掌握常见的排序算法和二分查找是一个必要的技能。建议先学习一些基础的排序算法，比如插入排序、快速排序等，然后再学习二分查找。
Java 二分查找
sxwn123的专栏
06-09 6739
Java 二分查找
Java面试系列文：算法、数据结构、基础设计模式
技术专家
02-15 726
大厂面试高频基础面试题。建议复制到自己的笔记当中，跳槽前必备！ 要求 能够用自己语言描述二分查找算法 能够手写二分查找代码 能够解答一些变化后的考法 1.算法描述 前提：有已排序数组 A（假设已经做好） 定义左边界 L、右边界 R，确定搜索范围，循环执行二分查找（3、4两步） 获取中间索引 M = Floor((L+R) /2) 中间索引的值 A[M] 与待搜索的值 T 进行比较 ① A[M] == T 表示找到，返回中间索引 ② A[M] > T，中间值右侧的其它元素都大于 T，无需比较，中间索引左
PAT甲级1001
湛蓝的天空
01-09 390
1001. A+B Format (20) 时间限制 400 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue Calculate a + b and output the sum in standard
递归算法 折半查找
waoshiwerr的博客
07-10 5759
（一）递归算法 折半查找 BinarySearch(函数命名了解大驼峰命名 法) 目的 节省时间在一组有序数列中查找一个数。通过查找中间值进行不断比较。 代码如下： int BinarySEarch(int*a,/*数组*/，intx/*想要传入的数组*/，int left /*最左边的数字*/，int right) { int middle； if（left<=right）/*判断数组的左边的数字和右边的数字*/ { middle = （left<=right） { middle =
java数据结构与算法排序
09-08
Java提供了多种数据结构和算法排序的实现。以下是一些常见的排序算法： 1. 冒泡排序（Bubble Sort）：通过不断比较相邻元素并交换，将最大（或最小）的元素逐渐“冒泡”到最后（或最前）位置。时间复杂度为O(n^2)。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

陌上人如玉এ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值