• 排序算法-Java实现


    常见的八种排序分类:

    【冒泡排序】

    原理:相邻两个数据进行两两比较,较大的放在右侧,较小的放在左侧。从开始到最后,所以最后一位是最大的。重复上述操作,除了最后一个

    Java代码:

    1 for (int i = 0; i < arr.length - 1; i++) {
    2             for (int j = 0; j < arr.length - i - 1; j++) {
    3                 if (arr[j] > arr[j + 1]) {
    4                     int temp = arr[j];
    5                     arr[j] = arr[j + 1];
    6                     arr[j + 1] = temp;
    7                 }
    8             }
    9 }

     【快速排序】

     

    原理:先从数列中取出一个数作为key值;将比这个数小的数全部放在它的左边,大于或等于它的数全部放在它的右边;对左右两个小数列重复第二步,直至各区间只有1个数

     java代码:

     1 public static void quickSort(int[] arr, int low, int high) {
     2         int i, j, temp, t;
     3         if (low > high) return;
     4         i = low;
     5         j = high;
     6         //temp就是基准位
     7         temp = arr[low];
     8 
     9         while (i < j) {
    10             //先看右边,依次往左递减
    11             while (temp <= arr[j] && i < j) {
    12                 j--;
    13             }
    14             //再看左边,依次往右递增
    15             while (temp >= arr[i] && i < j) {
    16                 i++;
    17             }
    18             //如果满足条件则交换
    19             if (i < j) {
    20                 t = arr[j];
    21                 arr[j] = arr[i];
    22                 arr[i] = t;
    23             }
    24 
    25         }
    26         //最后将基准为与i和j相等位置的数字交换
    27         arr[low] = arr[i];
    28         arr[i] = temp;
    29         //递归调用左半数组
    30         quickSort(arr, low, j - 1);
    31         //递归调用右半数组
    32         quickSort(arr, j + 1, high);
    33     }

    【插入排序】

    原理:直接插入排序是将一个待排序的记录,插入到前面已经排好序的有序序列中去,如此反复循环,直到全部排好顺序为止。

     1 public void insertSort() {
     2         int i, j, temp;
     3         for (i = 1; i < array.length; i++) {
     4             temp = array[i];
     5             for (j = i - 1; j >= 0; j--) {
     6                 if (temp > array[j]) {
     7                     break;
     8                 } else {
     9                     array[j + 1] = array[j];
    10                 }
    11             }
    12             array[j + 1] = temp;
    13         }
    14     }

    【选择排序】

     

    原理:简单选择排序是每一趟从待排序的数据元素中选择最小(或最大)的一个元素作为首元素,直到所有元素排完为止,属于不稳定排序。 

     1 public void selectSort() {
     2         int i, j, index;
     3         for (i = 0; i < array.length; i++) {
     4             index = i;
     5             for (j = i + 1; j < array.length; j++) {//遍历找到最小值
     6                 if (array[j] < array[index]) {
     7                     index = j;
     8                 }
     9             }//将遍历出来的最小值,放在前面
    10             int temp = array[i];
    11             array[i] = array[index];
    12             array[index] = temp;
    13         }
    14 }

    参考文档:

    https://baijiahao.baidu.com/s?id=1630690516749462635&wfr=spider&for=pc

    https://blog.csdn.net/qq_42857603/article/details/81605124

  • 相关阅读:
    查询快递单号-宅急送快递接口
    对路由转发的浅显理解
    对SpringCloud Zuul 的基本使用总结
    对SpringCloud Hystrix的使用个人总结
    对SpringBoot开箱即用使用方法的浅显理解
    对SpringCloud Hystrix服务降级的浅显理解
    金玉良言
    2种运行时织入的动态代理模式原理和调用流程比较
    记录手动启动Oracle数据库的方式
    基于SpringBoot搭建一个带数据库访问的WEB项目(记录所需的依赖,配置,驱动安装等注意事项)
  • 原文地址:https://www.cnblogs.com/starstarstar/p/11093911.html
Copyright © 2020-2023  润新知