浅入浅出 Java 排序玩转的JAVA排序算法

最新推荐文章于 2024-04-29 10:55:41 发布
最新推荐文章于 2024-04-29 10:55:41 发布
阅读量122 收藏
点赞数
分类专栏： Java基础篇 文章标签： java 数据结构 排序算法 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44848573/article/details/105935108
版权

在这里插入图片描述

文章目录

1.排序的概念

(1).将一组数据按相应的规则排列顺序。

2.冒泡排序的实现

实现思路：

  • 分析：int arr[] = {2, 5, 3, 6, 9};
  • 假设数组的长度为为5,即arr.length=5,
  • 第一次元素交换的次数为4 ，第一趟 j=0 0+4
  • 第二次元素交换的次数为3 , 第二趟 j=1 1+3
  • 第三次元素交换的次数为2 ，第三趟 j=2 2+2
  • 第四次元素交换的次数为1 第四趟 j=3 1+3
  • 趟数就等于arr.length-1
  • 循环的次数：arr.length-j-1 (j为趟数) 具体代码实现，如下
public static void sortFinal(int[] arr) {
        boolean flag = true;  //标示减少循环的趟数
        for (int j = 0; j < arr.length - 1; j++) { //循环的趟数
             System.out.println("第"+(j+1)+"趟");
            flag = true;
            for (int i = 0; i < arr.length - 1 - j; i++) { //循环的次数
                System.out.print("第"+(i+1)+"次");
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    flag = false;
                }
                System.out.println(Arrays.toString(arr));
            }
            if (flag) {
                break;
            }
        }
 
    }

3.内置引用数据类型的排序

内置类实现排序都是实现：java.lang.Comparable---->compareTo()

举例：Integer,String 底层实现

 public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }
 public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }
 public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;
 
        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

Integer（比较的是基本数据类型的大小），Character （比较的是Unicode码之差），Date(时间的大小) 。
String比较分为两种情况：
第一点：其中一个是另一个起始的字符窜，返回两个字符窜的长度差
第二点：否则就是返回的第一个不相等的Unicode的之差。

public static void InnerTypeTest(){
        Integer integer=5;
        System.out.println(integer.compareTo(5)); //比较的是基本数据类型大小
        Character character='c';
        System.out.println(character.compareTo('c')); //比较的Unicode码只差
        //字符窜比较两种情况：
        //其中一个是另一个起始的字符窜,返回两个字符窜的长度差
        //否则返回Unicode之差
        String str="abc";  //字符窜比较
        System.out.println(str.compareTo("abcd"));  //返回-1
        System.out.println(str.compareTo("ccd")); //返回Unicode的码之差
        Date date=new Date();
        System.out.println(date.compareTo(new Date())); //比较时间大小
 
    }

4.自定义实现数组和集合的排序

public class Utils {
 
    public static void main(String[] args) {
        String[] arrStr = {"ab", "rg", "e", "a", "abcd", "abc", "def"};
        sort(Arrays.asList(arrStr), new StringCom());
        System.out.println(Arrays.toString(arrStr));
    }
 
    /**
     * 自定义排序规则实现对集合的排序
     * @param list
     * @param com
     * @param <T>
     */
    public static <T> void sort(List<T> list, Comparator<T> com) {
        Object[] arr = list.toArray();
        sort(arr, com);
        for (int i = 0; i < arr.length; i++) {
            list.set(i, (T) arr[i]);
        }
    }
 
    /**
     * 自定义排序规则实现对数组的排序
     * @param <T>
     */
    public static <T> void sort(Object[] arr, Comparator<T> com) {
        Boolean flag = true;
        for (int j = 0; j < arr.length - 1; j++) {
            flag = true;
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (com.compare((T) arr[i], (T) arr[i + 1]) < 0) {
                    Object temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
    }
 
    /**
     * 容器排序
     * @param list
     * @param <T>
     */
    public static <T extends Comparable<T>> void sort(List<T> list) {
        Object[] arr = list.toArray();
        sort(arr);
        for (int i = 0; i < arr.length; i++) {
            list.set(i, (T) arr[i]);
        }
    }
 
    /**
     * 泛型数组排序
     * @param arr
     */
    public static <T extends Comparable<T>> void sort(T[] arr) {
        Boolean flag = true;
        for (int j = 0; j < arr.length - 1; j++) {
            flag = true;
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (((Comparable) arr[i]).compareTo(arr[i + 1]) > 0) {
                    T temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
    }
 
    /**
     * 数组排序
     */
    public static void sort(Object[] arr) {
        Boolean flag = true;
        for (int j = 0; j < arr.length - 1; j++) {
            flag = true;
            for (int i = 0; i < arr.length - 1 - j; i++) {
                if (((Comparable) arr[i]).compareTo(arr[i + 1]) > 0) {
                    Object temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
    }
}

自定义规则类　StringCom

public class StringCom implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        int len1=o1.length();
        int len2=o2.length();
        return -(len1-len2);
    }
}

5.TreeSet和TreeMap 实现排序

  1. Person类 （调用TreeSet和TreeMap无参构造）
public class Person implements Comparable<Person> {
    private String name;
    private String password;
 
    public Person() {
    }
 
    public Person(String name, String password) {
        this.name = name;
        this.password = password;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = password;
    }
 
    @Override
    public int compareTo(Person o) {
 
        return -(this.password.length()-o.password.length());
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}　

测试方法

/**
 * 使用TreeSet的空构造的方法实现排序,需要在自定义的类中实现java.lang.Comparable--->compareTo
 * 的方法，然后自定义相应的排序规则
 */
public static  void langComparableTest(){
    Person p1=new Person("张三","123");
    Person p2=new Person("张四","1234");
    Person p3=new Person("张五","12345");
    Person p4=new Person("张六","123456");
    TreeSet<Person> treeSet=new TreeSet<Person>();
    treeSet.add(p1);
    treeSet.add(p2);
    treeSet.add(p3);
    treeSet.add(p4);
    System.out.println(treeSet);
}

/**
 * TreeMap类似TreeSet ，无参构造
 */
public static void langComparableTreeMapTest(){
    Person p1=new Person("张三","123");
    Person p2=new Person("张四","1234");
    Person p3=new Person("张五","12345");
    Person p4=new Person("张六","123456");
    TreeMap<Person,String> treeMap=new TreeMap<Person,String>();
    treeMap.put(p1,"adad");
    treeMap.put(p2,"adad");
    treeMap.put(p3,"adad");
    treeMap.put(p4,"adad");
    System.out.println(treeMap.keySet());
}

Uers（调用TreeSet和TreeMap有参构造）

public class User {
 
    private String name;
    private String passwprd;
 
    public User() {
    }
 
    public User(String name, String passwprd) {
        this.name = name;
        this.passwprd = passwprd;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getPasswprd() {
        return passwprd;
    }
 
    public void setPasswprd(String passwprd) {
        this.passwprd = passwprd;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", passwprd='" + passwprd + '\'' +
                '}';
    }
}　

测试方法

/**
 * 使用TreeSet的有参构造的方法实现排序,需要在自定义的类中实现java.util.Comparator--->compare
 */
public static void UtilComparatorTest(){
    User u1=new User("张三","123");
    User u2=new User("张四","1234");
    User u3=new User("张五","12345");
    User u4=new User("张六","123456");
 
    TreeSet<User> treeSet=new TreeSet<User>(new Comparator<User>() {
        @Override
        public int compare(User o1, User o2) {
            return -(o1.getPasswprd().length()-o2.getPasswprd().length());
        }
    });
    treeSet.add(u1);
    treeSet.add(u2);
    treeSet.add(u3);
    treeSet.add(u4);
    System.out.println(treeSet);
}

/**
 *  TreeMap类似TreeSet 有参构造
 */
public static void UtilComparatorTreeMapTest(){
    User u1=new User("张三","123");
    User u2=new User("张四","1234");
    User u3=new User("张五","12345");
    User u4=new User("张六","123456");

    TreeMap<User,String> treeMap=new TreeMap<User,String>(new Comparator<User>() {
        @Override
        public int compare(User o1, User o2) {
            return -(o1.getPasswprd().length()-o2.getPasswprd().length());
        }
    });
    treeMap.put(u1,"adad");
    treeMap.put(u2,"adad");
    treeMap.put(u3,"adad");
    treeMap.put(u4,"adad");
    System.out.println(treeMap.keySet());
}

6.Collections工具 类排序

public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("ab");
        list.add("abcd");
        list.add("abc");
        //默认规则的排序
        Collections.sort(list);
        for (String str:list){
            System.out.println(str);
        }
        //自定义规则的排序
        Collections.sort(list,new StringCom());
        for (String str:list){
            System.out.println(str);
        }
    }

每天进步一丢地

完成

阿福研习社
关注
专栏目录
玩转十大经典排序算法（动图+Java代码）
clonechen
03-07 3270
总结 选择排序 实现一： /** * 选择排序1 * 每次遍历查找剩余元素的最小值然后放到对应的位置 * * @param arr */ public static void SelectionSort1(int[] arr) { int n = arr.length; for (int i = 0;...
从理论到实践：手写线程池，玩转Java并发编程！
最新发布
孤芳不自赏
08-25 496
Hello，大家好呀！我是小米，一个爱技术、爱分享的29岁程序猿。今天我要和大家聊聊Java中的线程池实现，并带大家一步步实现一个简单的线程池。线程池在多线程编程中非常常见，它能帮我们管理和调度线程，避免频繁创建和销毁线程带来的开销，从而提升系统的性能。在正式开工之前，先让我们简单聊一下线程池的作用和基本原理。大家可能会问，为什么要用线程池？直接用new Thread()来创建线程不是也可以吗？是的，直接创建线程也可以解决并发问题，但如果任务数量很大，每次创建新线程会消耗系统资源，而且线程的创建和销毁是相对
java常见八种排序算法
06-29
java最常见的八种排序算法
JAVA内置排序方法
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
12-21 2390
排序是按特定顺序组织数据项集合的过程，通常是升序或降序。有许多不同的算法可用于对数据进行排序，包括冒泡排序、选择排序、插入排序、归并排序和快速排序等。 Java 是一种编程语言，它提供了许多用于对数据进行排序的内置方法，包括Arrays.sort() 和 Collections.sort() 这些方法使用高效的排序算法来快速高效地对数据进行排序。
Java实现各种内部排序算法
2301_79098686的博客
04-29 317
/有元素交换，则该序列初始状况不是有序的if(flag == false){ //本趟遍历后没有发生交换，说明表已经有序思想：基于分治的思想：在待排序表中任取一个元素pivot作为基准，通过一趟排序将待排序表划分为独立的两部分，使得一部分中所有元素小于等于pivot，另一部分中所有元素大于pivot，则pivot放在了其最终位置上，这个过程称为一趟快速排序。而后递归地对两个子表重复上述过程，直到每部分内只有一个元素或空为止。
Java常用内排序算法
Java相关领域
09-05 320
目录 1、冒泡排序（Bubble Sort） 2、快速排序（Quick Sort） 3、选择排序（Selection Sort） 4、堆排序（Heap Sort） 5、插入排序（Insertion Sort） 6、希尔排序（Shell Sort） 7、归并排序（Merge Sort） 其他排序 8、计数排序（Counting Sort） 9、桶排序（Bucket Sort） ...
java内置排序实现_java实现4种内部排序
weixin_33177758的博客
02-27 182
两种插入类排序：直接插入排序：public static void insertSort(int[] arr, int len){for(int i=1; iint temp = arr[i];int j=i-1;while(j>=0 && temparr[j+1] = arr[j];--j;}arr[j+1] = temp;}}折半插入排序：public static vo...
算法面试专题课(Java版)，Google面试官带你高质量刷题视频教程
08-11
8. **Java编程技巧**：强调Java语言特性在算法实现中的作用，如泛型、枚举、异常处理、多线程等，以及如何写出高效、优雅的Java代码。 9. **面试技巧**：分享如何有效地表达自己的思路，清晰地阐述解题过程，以及...
实现算法可视化使用java + swing<Play Data Structures in Java&gt
01-14
项目中的《Java语言玩转数据结构》可能是配套的教材或指南，提供了关于如何使用Java实现数据结构和算法的详细指导。这本书可能涵盖了基础的数据结构，如数组、链表、栈和队列，以及更复杂的数据结构，如树（二叉树、...
基于Java swing的拼图游戏，两种玩法（数字和图片）.zip
12-17
本项目“基于Java Swing的拼图游戏，两种玩法（数字和图片）”正是利用了这一特性，为我们呈现了一个有趣的学习和实践案例。下面将深入探讨该项目的核心知识点以及其应用场景。 首先，我们来看项目的基本结构。...
java 内置排序_八大常见内排序java实现
weixin_39913472的博客
02-24 307
虽然排序算法烂大街了，但是哥依然用java实现了一遍，只为自己练练手，后面可以时不时的回头看看。。。仅此而已，各位可以提意见，莫喷！！一、冒泡排序基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换1 /**2 * 冒泡排序3 *@paramda...
java七大内部排序算法
Java_Programmer1的博客
07-29 258
冒泡排序
java常见的内部排序算法
qq_41035192的博客
01-03 188
1.插入排序： 插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入 2.希尔排序： 先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序 3.选择排序： 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，再从剩余未排序元素中...
Java 提供的默认排序算法
矩阵Matrix
10-19 636
Java 提供的默认排序算法
用Java实现常见的8种内部排序算法
hello_1566的博客
05-01 648
一、插入类排序 插入类排序就是在一个有序的序列中，插入一个新的关键字。从而达到新的有序序列。插入排序一般有直接插入排序、折半插入排序和希尔排序。 1. 插入排序 1.1 直接插入排序 /** * 直接比较，将大元素向后移来移动数组 */ public static void InsertSort(int[] A) { for(int i = 1; i < A.length; i++) { int temp = A[i]; //temp 用于存储元素，防止后面移动
快速排序-------------java实现
一颗小陨石的博客
10-29 224
一、基本思想 选择一个基准数，通过一趟排序将待排序数据分成两个独立的部分，其中一部分的所有数都比基准数小，另一部分都比基准数大，然后再使用此方法递归对两部分数据进行快排，最终实现整个数据的有序。 二、详解排序过程 现有待排序数据： {-21, 312, 44, 11, -23, 2, 10}; 蓝色为左哨兵，记为left，黄色为右哨兵记为right，红色为基数 基数=(左哨兵坐标+右...
基础复习第二十二天 泛型的使用
小东学java
02-28 350
泛型的使用
JAVA默认排序算法问题
热门推荐
sells2012的专栏
02-06 1万+
1. 为什么写这篇文章 这篇文章的根源是在产品中发现了一个诡异的bug：只能在产品环境下重现，在我的本地开发环境无法重现，而双方的代码没有任何区别。最后用remote debug的方法找到异常所在： Exception in thread "main" java.lang.IllegalArgumentException: Comparison  method violates
Java中自带的排序算法Arrays.sort()和Collections.sort()
qq_40531768的博客
04-16 3758
如果我们需要对一个基本类型数组进行排序，我们可以使用Arrays.sort()方法,不过只能升序; 如果我们需要排序一个对象列表List，我们可以使用Collection.sort()方法或者ArrayList自带的sort方法; Arrays.sort()和Collections.sort()都提供自然升序,但是如果想要升序(也可以降序)就需要使用...
Java排序算法实现：插入排序与冒泡排序
"Java版本的排序算法包括插入排序和冒泡排序，这两种都是基础的排序方法，适用于数据规模较小的情况。这些算法通过比较和交换元素的位置来实现排序。" Java中的排序算法是计算机科学中非常重要的概念，尤其在处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值