zoukankan      html  css  js  c++  java
  • 常用排序算法

    (1)直接插入排序

    1. /** 直接插入排序 **/  
    2. /** 数组是引用类型,元素值将被改变 **/  
    3. public static void insertSort(int[] table) {  
    4.     /** n-1趟扫描 **/  
    5.     for (int i = 1; i < table.length; i++) {  
    6.         /** 每趟将table[i]插入到前面已排序的序列中 **/  
    7.         int temp = table[i], j;  
    8.         /** 将前面较大元素向后移动 **/  
    9.         for (j = i - 1; j > -1 && temp < table[j]; j--) {  
    10.             table[j + 1] = table[j];  
    11.         }  
    12.         /** temp值到达插入位置 **/  
    13.         table[j + 1] = temp;  
    14.     }  
    15. }  


    2希尔排序

    1. /** 希尔排序 **/  
    2.     public static void shellSort(int[] table) {  
    3.         /** 控制增量,增量减半,若干趟扫描 **/  
    4.         for (int delta = table.length / 2; delta > 0; delta /= 2) {  
    5.             /** 一趟中若干组,每个元素在自己所属组内进行直接插入排序 **/  
    6.             for (int i = delta; i < table.length; i++) {  
    7.                 /** 当前待插入元素 **/  
    8.                 int temp = table[i];  
    9.                 /** 相距delta远 **/  
    10.                 int j = i - delta;  
    11.                 /** 一组中前面较大的元素向后移动 **/  
    12.                 /** 继续与前面的元素比较 **/  
    13.                 while (j >= 0 && temp < table[j]) {  
    14.                     table[j + delta] = table[j];  
    15.                     j -= delta;  
    16.                 }  
    17.                 /** 插入元素位置 **/  
    18.                 table[j + delta] = temp;  
    19.             }  
    20.         }  
    21.     }  


    (3)冒泡排序

    1. /** 冒泡排序 **/  
    2.     public static void bubbleSort(int[] table) {  
    3.         /** 是否交换的标记 **/  
    4.         boolean exchange = true;  
    5.         /** 有交换时再进行下一趟,最多n-1趟 **/  
    6.         for (int i = 1; i < table.length && exchange; i++) {  
    7.             /** 假定元素未交换 **/  
    8.             exchange = false;  
    9.             /** 一次比较、交换 **/  
    10.             for (int j = 0; j < table.length - i; j++) {  
    11.                 /** 反序时,交换 **/  
    12.                 if (table[j] > table[j + 1]) {  
    13.                     int temp = table[j];  
    14.                     table[j] = table[j + 1];  
    15.                     table[j + 1] = temp;  
    16.                     /** 有交换 **/  
    17.                     exchange = true;  
    18.                 }  
    19.             }  
    20.         }  
    21.     }  


    (4)快速排序

    1. /** 快速排序 **/  
    2.     public static void quickSort(int[] table) {  
    3.         quickSort(table, 0, table.length - 1);  
    4.     }  
    5.   
    6.     /** 一趟快速排序,递归算法 **/  
    7.     private static void quickSort(int[] table, int low, int high) { // low、high指定序列的下界和上界  
    8.         /** 序列有效 **/  
    9.         if (low < high) {  
    10.             int i = low, j = high;  
    11.             /** 第一个值作为基准值 **/  
    12.             int vot = table[i];  
    13.             /** 一趟排序 **/  
    14.             while (i != j) {  
    15.                 /** 从后向前寻找较小值 **/  
    16.                 while (i < j && vot <= table[j])  
    17.                     j--;  
    18.                 if (i < j) {  
    19.                     /** 较小元素向前移动 **/  
    20.                     table[i] = table[j];  
    21.                     i++;  
    22.                 }  
    23.                 /** 从前向后寻找较大值 **/  
    24.                 while (i < j && table[i] < vot)  
    25.                     i++;  
    26.                 if (i < j) {  
    27.                     /** 较大元素向后移动 **/  
    28.                     table[j] = table[i];  
    29.                     j--;  
    30.                 }  
    31.             }  
    32.             /** 基准值的最终位置 **/  
    33.             table[i] = vot;  
    34.             /** 前端子序列再排序 **/  
    35.             quickSort(table, low, j - 1);  
    36.             /** 后端子序列再排序 **/  
    37.             quickSort(table, i + 1, high);  
    38.         }  
    39.     }  


    (5)直接选择排序

    1. /** 直接选择排序 **/  
    2.     public static void selectSort(int[] table) {  
    3.         /** n-1趟排序 **/  
    4.         for (int i = 0; i < table.length - 1; i++) {  
    5.             /** 每趟在从table[i]开始的子序列中寻找最小元素 **/  
    6.             /** 设第i个数据元素最小 **/  
    7.             int min = i;  
    8.             /** 在子序列中查找最小值 **/  
    9.             for (int j = i + 1; j < table.length; j++)  
    10.                 if (table[j] < table[min])  
    11.                     /** 记住最小元素下标 **/  
    12.                     min = j;  
    13.             /** 将本趟最小元素交换到前边 **/  
    14.             if (min != i) {  
    15.                 int temp = table[i];  
    16.                 table[i] = table[min];  
    17.                 table[min] = temp;  
    18.             }  
    19.         }  
    20.     }  


    (6)堆排序

    1. /** 堆排序 **/  
    2.     public static void heapSort(int[] table) {  
    3.         int n = table.length;  
    4.         /** 创建最小堆 **/  
    5.         for (int j = n / 2 - 1; j >= 0; j--)  
    6.             sift(table, j, n - 1);  
    7.         /** 每趟将最小值交换到后面,再调整成堆 **/  
    8.         for (int j = n - 1; j > 0; j--) {  
    9.             int temp = table[0];  
    10.             table[0] = table[j];  
    11.             table[j] = temp;  
    12.             sift(table, 0, j - 1);  
    13.         }  
    14.     }  
    15.   
    16.     /** 将以low为根的子树调整成最小堆 **/  
    17.     private static void sift(int[] table, int low, int high) {  
    18.         /** low、high是序列下界和上界 **/  
    19.         /** 子树的根 **/  
    20.         int i = low;  
    21.         /** j为i结点的左孩子 **/  
    22.         int j = 2 * i + 1;  
    23.         /** 获得第i个元素的值 **/  
    24.         int temp = table[i];  
    25.         /** 沿较小值孩子结点向下筛选 **/  
    26.         while (j <= high) {  
    27.             /** 数组元素比较(改成<为最大堆) **/  
    28.             if (j < high && table[j] > table[j + 1])  
    29.                 /** j为左右孩子的较小者 **/  
    30.                 j++;  
    31.             /** 若父母结点值较大(改成<为最大堆) **/  
    32.             if (temp > table[j]) {  
    33.                 /** 孩子结点中的较小值上移 **/  
    34.                 table[i] = table[j];  
    35.                 /** i、j向下一层 **/  
    36.                 i = j;  
    37.                 j = 2 * i + 1;  
    38.             } else  
    39.                 j = high + 1;  
    40.         }  
    41.         /** 当前子树的原根值调整后的位置 **/  
    42.         table[i] = temp;  
    43.     }  


    (7)归并排序

    1. /** 归并排序 **/  
    2.     public static void mergeSort(int[] X) {  
    3.         /** 已排序的子序列长度,初值为1 **/  
    4.         int n = 1;  
    5.         /** Y数组长度同X数组 **/  
    6.         int[] Y = new int[X.length];  
    7.         do {  
    8.             /** 一趟归并,将X数组中各子序列归并到Y中 **/  
    9.             mergepass(X, Y, n);  
    10.             /** 子序列长度加倍 **/  
    11.             n *= 2;  
    12.   
    13.             if (n < X.length) {  
    14.                 /** 将Y数组中各子序列再归并到X中 **/  
    15.                 mergepass(Y, X, n);  
    16.                 n *= 2;  
    17.             }  
    18.         } while (n < X.length);  
    19.     }  
    20.   
    21.     /** 一趟归并 **/  
    22.     private static void mergepass(int[] X, int[] Y, int n) {  
    23.         int i = 0;  
    24.         while (i < X.length - 2 * n + 1) {  
    25.             merge(X, Y, i, i + n, n);  
    26.             i += 2 * n;  
    27.         }  
    28.         if (i + n < X.length)  
    29.             /** 再一次归并 **/  
    30.             merge(X, Y, i, i + n, n);  
    31.         else  
    32.             /** 将X剩余元素复制到Y中 **/  
    33.             for (int j = i; j < X.length; j++)  
    34.                 Y[j] = X[j];  
    35.     }  
    36.   
    37.     /** 一次归并 **/  
    38.     private static void merge(int[] X, int[] Y, int m, int r, int n) {  
    39.         int i = m, j = r, k = m;  
    40.         /** 将X中两个相邻子序列归并到Y中 **/  
    41.         while (i < r && j < r + n && j < X.length)  
    42.             /** 较小值复制到Y中 **/  
    43.             if (X[i] < X[j])  
    44.                 Y[k++] = X[i++];  
    45.             else  
    46.                 Y[k++] = X[j++];  
    47.         /** 将前一个子序列剩余元素复制到Y中 **/  
    48.         while (i < r)  
    49.             Y[k++] = X[i++];  
    50.         /** 将后一个子序列剩余元素复制到Y中 **/  
    51.         while (j < r + n && j < X.length)  
    52.             Y[k++] = X[j++];  
    53.     }  
  • 相关阅读:
    thinkphp5 tp5 命名空间 报错 Namespace declaration statement has to be the very first statement in the script
    开启 php 错误 提示 php-fpm 重启 nginx 500错误 解决办法 wdlinux lnmp 一键包 php脚本无法解析执行
    js 设置 cookie 定时 弹出层 提示层 下次访问 不再显示 弹窗 getCookie setCookie setTimeout
    php 二维数组 转字符串 implode 方便 mysql in 查询
    nginx 重启 ps -ef|grep nginx kill -HUP 主进程号
    jquery bootstrap help-block input 表单 提示 帮助 信息
    jquery 倒计时 60秒 短信 验证码 js ajax 获取
    jQuery如何获取同一个类标签的所有的值 遍历
    linux下C语言文件操作相关函数
    gcc,gdb用法
  • 原文地址:https://www.cnblogs.com/dailidong/p/7571143.html
Copyright © 2011-2022 走看看