1. import java.util.Arrays; 
  2.  
  3. /** 
  4.  * 各种排序方法 
  5.  *  
  6.  * @author zhezi 
  7.  *  
  8.  */ 
  9. public class Sort { 
  10.  
  11.     /** 
  12.      * 1.直接插入排序,asc 
  13.      */ 
  14.     public void insertSort(int[] arr, int low, int high) { 
  15.         for (int i = low + 1; i < high; i++) { 
  16.             if (arr[i] < arr[i - 1]) { // i < i-1 
  17.                 int temp = arr[i]; 
  18.                 arr[i] = arr[i - 1]; // i-1 后移 
  19.                 int j = i - 2
  20.                 for (; j >= low && (temp < arr[j]); j--) { // i 与 
  21.                     // i-1之前的元素进行比较(找出最小值) 
  22.                     arr[j + 1] = arr[j]; // i-2 后移到 i-1 
  23.                 } 
  24.                 arr[j + 1] = temp; // i插入到合适位置 
  25.             } 
  26.         } 
  27.         /** 输出 **/ 
  28.         for (int k = 0; k < arr.length; k++) { 
  29.             System.out.print(arr[k] + ","); 
  30.         } 
  31.         System.out.println(); 
  32.     } 
  33.  
  34.     /** 
  35.      * 2.折半插入排序(二分查找) 
  36.      */ 
  37.     public void binInsertSort(int[] arr, int low, int high) { 
  38.         for (int i = low + 1; i < high; i++) { 
  39.             int temp = arr[i]; 
  40.             int hi = i - 1
  41.             int lo = low; // 设置初始期间 
  42.             while (lo <= hi) { 
  43.                 int mid = (lo + hi) / 2
  44.                 if (temp < arr[mid]) { 
  45.                     hi = mid - 1
  46.                 } else { 
  47.                     lo = mid + 1
  48.                 } 
  49.             } 
  50.             for (int j = i - 1; j > hi; j--) { // 移动元素 
  51.                 arr[j + 1] = arr[j]; 
  52.             } 
  53.             arr[hi + 1] = temp; // 插入元素 
  54.         } 
  55.         // 输出 
  56.         for (int k = 0; k < arr.length; k++) { 
  57.             System.out.print(arr[k] + ","); 
  58.         } 
  59.         System.out.println(); 
  60.     } 
  61.  
  62.     /** 
  63.      * 3.希尔排序 
  64.      */ 
  65.     int[] delta = { 321 }; 
  66.  
  67.     /** 步长序列,步长值必须互质,且最后一个步长值必须为1 **/ 
  68.  
  69.     public void shellSort(int[] arr, int low, int high, int[] delta) { 
  70.         for (int i = 0; i < delta.length; i++) { 
  71.             shellInsert(arr, low, high, delta[i]); 
  72.         } 
  73.         for (int k = 0; k < arr.length; k++) { 
  74.             System.out.print(arr[k] + ","); 
  75.         } 
  76.         System.out.println(); 
  77.     } 
  78.  
  79.     public void shellInsert(int[] arr, int low, int high, int deltaK) { 
  80.         for (int i = low + deltaK; i < high; i++) { 
  81.             if (arr[i] < arr[i - deltaK]) { 
  82.                 int temp = arr[i]; 
  83.                 int j = i - deltaK; 
  84.                 for (; j >= low && temp < arr[j]; j = j - deltaK) { 
  85.                     arr[j + deltaK] = arr[j]; 
  86.                 } 
  87.                 arr[j + deltaK] = temp; 
  88.             } 
  89.         } 
  90.     } 
  91.  
  92.     /** 
  93.      * 4.冒泡排序                    --两两位置相比较,找到最大的,放到最后 
  94.      */ 
  95.     public void bubbleSort(int[] arr, int low, int high) { 
  96.         for (int i = low; i < high; i++) { // 循环次数 
  97.             for (int j = low; j < high - i - 1; j++) { // 两两位置相比较,找出最大的 
  98.                 if (arr[j] > arr[j + 1]) { 
  99.                     int temp = arr[j]; 
  100.                     arr[j] = arr[j + 1]; 
  101.                     arr[j + 1] = temp; 
  102.                 } 
  103.             } 
  104.         } 
  105.         for (int k = 0; k < arr.length; k++) { 
  106.             System.out.print(arr[k] + ","); 
  107.         } 
  108.         System.out.println(); 
  109.     } 
  110.  
  111.     /** 
  112.      * 5.快速排序            ---找到枢轴元素,分为两个子序列,左边都比枢轴小,右边都比枢轴大,再对子序列排序 
  113.      */ 
  114.     public void quickSort(int[] arr, int low, int high) { 
  115.         if (low < high) { 
  116.             int pa = partition(arr, low, high); 
  117.             quickSort(arr, low, pa - 1); 
  118.             quickSort(arr, pa + 1, high); 
  119.         } 
  120.         /** 输出 **/ 
  121.         for (int k = 0; k < arr.length; k++) { 
  122.             System.out.print(arr[k] + ","); 
  123.         } 
  124.         System.out.println(); 
  125.     } 
  126.  
  127.     /** 将序列划分为两列,返回枢轴元素的位置 **/ 
  128.     public int partition(int[] arr, int low, int high) { 
  129.         int pivot = arr[low]; // 使用arr[low]作为枢轴元素 
  130.         while (low < high) { // 从两端向内扫描 
  131.             while (low < high && (arr[high] >= pivot)) { 
  132.                 high--; 
  133.             } 
  134.             arr[low] = arr[high]; // 将小于pivot的元素移向低端 
  135.             while (low < high && (arr[low] <= pivot)) { 
  136.                 low++; 
  137.             } 
  138.             arr[high] = arr[low]; // 将大于pivot的元素移向高端 
  139.         } 
  140.         arr[low] = pivot; 
  141.         return low; 
  142.     } 
  143.  
  144.     /** 
  145.      * 6.简单选择排序          ---每一次遍历,找到最小值放到前面 
  146.      */ 
  147.     public void selectSort(int[] arr, int low, int high) { 
  148.         for (int i = low; i < high; i++) { 
  149.             int min = i; 
  150.             for (int j = min + 1; j < high; j++) { 
  151.                 if (arr[j] < arr[min]) { 
  152.                     min = j; 
  153.                 } 
  154.             } 
  155.             if (i != min) { 
  156.                 int temp = arr[i]; 
  157.                 arr[i] = arr[min]; 
  158.                 arr[min] = temp; 
  159.             } 
  160.         } 
  161.         /** 输出 **/ 
  162.         for (int k = 0; k < arr.length; k++) { 
  163.             System.out.print(arr[k] + ","); 
  164.         } 
  165.         System.out.println(); 
  166.     } 
  167.  
  168.     /** 
  169.      * 7.堆排序 
  170.      */ 
  171.     public void heapSort(int[] arr) { 
  172.         int n = arr.length; 
  173.         for (int i = n / 2; i > 0; i--) { // 初始化建堆 
  174.             heapAdjust(arr, i - 1, n); 
  175.         } 
  176.  
  177.         for (int i = n - 2; i >= 0; i--) { // 不断输出堆顶元素并调整新堆 
  178.             int temp = arr[i + 1]; // 交换堆顶元素与堆底元素 
  179.             arr[i + 1] = arr[0]; 
  180.             arr[0] = temp; 
  181.             heapAdjust(arr, 0, i + 1); // 调整 
  182.         } 
  183.         /** 输出 **/ 
  184.         for (int k = 0; k < arr.length; k++) { 
  185.             System.out.print(arr[k] + ","); 
  186.         } 
  187.         System.out.println(); 
  188.     } 
  189.  
  190.     /** 调整为小顶堆 **/ 
  191.     private void heapAdjust(int[] arr, int low, int high) { 
  192.         int temp = arr[low]; // 顶端元素 
  193.         int j = low * 2 + 1// 左边子元素 
  194.  
  195.         while (j <= high - 1) { // 从第一个子元素逐渐向下筛选 
  196.             if (j < high - 1 && arr[j] < arr[j + 1]) { // 找到最大的子元素 
  197.                 j++; 
  198.             } 
  199.             if (temp >= arr[j]) { // 若顶端元素temp比孩子元素都小,插入到顶端 
  200.                 break
  201.             } 
  202.             arr[(j - 1) / 2] = arr[j]; 
  203.             j = 2 * j + 1
  204.         } 
  205.         arr[(j - 1) / 2] = temp; 
  206.     } 
  207.  
  208.     /** 
  209.      * 8.归并排序 
  210.      */ 
  211.     public void mergeSort(int[] arr, int low, int high) { 
  212.         if (low < high) { 
  213.             mergeSort(arr, low, (high + low) / 2); 
  214.             mergeSort(arr, (high + low) / 2 + 1, high); 
  215.             merge(arr, low, (low + high) / 2 + 1, high); 
  216.         } 
  217.         /** 输出 **/ 
  218.         for (int k = 0; k < arr.length; k++) { 
  219.             System.out.print(arr[k] + ","); 
  220.         } 
  221.         System.out.println(); 
  222.     } 
  223.  
  224.     /** 归并操作将基本单位归并成整个有序的数组 **/ 
  225.     private void merge(int[] list, int left, int right, int last) { 
  226.         int[] temp = new int[list.length];// 临时数组 
  227.         int j = 0
  228.         int lowIndex = left; 
  229.         int mid = right - 1
  230.         int n = last - lowIndex + 1
  231.         while (left <= mid && right <= last) { 
  232.             if (list[left] < list[right]) { 
  233.                 temp[j++] = list[left++]; 
  234.             } else { 
  235.                 temp[j++] = list[right++]; 
  236.             } 
  237.         } 
  238.         while (left <= mid) { 
  239.             temp[j++] = list[left++]; 
  240.         } 
  241.         while (right <= last) { 
  242.             temp[j++] = list[right++]; 
  243.         } 
  244.         for (j = 0; j < n; j++) { 
  245.             list[lowIndex + j] = temp[j]; 
  246.         } 
  247.     } 
  248.  
  249.     /** 
  250.      *9.计数排序                ---适用于待排序的数组元素最大值已经给定的情况下。 
  251.      *                          b[] 存放正确排序的结果 
  252.      *                          c[] 存放每个元素在序列中出现的次数 
  253.      *                          k   为序列中的最大值 
  254.      */ 
  255.     public void countSort(int[] arr, int[] b, int k) { 
  256.         int[] c = new int[k + 1]; 
  257.         for (int i = 0; i < k; i++) { 
  258.             c[i] = 0
  259.         } 
  260.         for (int i = 0; i < arr.length; i++) { 
  261.             c[arr[i]]++;                                //存放a中元素等于i的元素个数 
  262.         } 
  263.         for (int i = 1; i <= k; i++) { 
  264.             c[i] += c[i - 1];                           //存放a中元素<=i的元素个数 
  265.         } 
  266.         for (int i = arr.length - 1; i >= 0; i--) {     //把a中每个元素放入b中正确的位置. 
  267.             b[c[arr[i]] - 1] = arr[i]; 
  268.             c[arr[i]]--;                                //a中如果有元素的值相等此句是必须的. 
  269.         } 
  270.     } 
  271.     /**返回序列中的最大值**/ 
  272.     public static int getMaxNumber(int[] a) { 
  273.         int max = 0
  274.         for (int i = 0; i < a.length; i++) { 
  275.             if (max < a[i]) { 
  276.                 max = a[i]; 
  277.             } 
  278.         } 
  279.         return max; 
  280.     } 
  281.  
  282.     /** 
  283.      * 10.基数排序          ---将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零. 然后,从最低位开始, 依次进行一次排序. 
  284.      *                          radix 设定的基数 
  285.      *                          d     数组中最多位数 
  286.      */ 
  287.     public void radixSort(int[] arr,int radix,int d){ 
  288.          //定义一个临时数组大小和data数组相等   
  289.         int[] temp = new int[arr.length];   
  290.         //定义一个位计数器,用来存放当前位的元素有多少个   
  291.         int[] bucket = new int[radix];   
  292.    
  293.         int rate = 1;   
  294.         for (int i = 0; i < d; i++) {   
  295.             //将data数组中的各个元素复制到temp数组中   
  296.             System.arraycopy(arr, 0, temp, 0, arr.length);   
  297.             //将bucket数组的各个元素重置0   
  298.             Arrays.fill(bucket, 0);   
  299.                
  300.             for (int j = 0; j < arr.length; j++) {   
  301.                 int index = (temp[j] / rate) % radix;   
  302.                 bucket[index] += 1;   
  303.             }   
  304.                
  305.             for (int j = 1; j < bucket.length; j++) {   
  306.                 bucket[j] = bucket[j] + bucket[j - 1];   
  307.             }   
  308.    
  309.             for (int j = arr.length - 1; j >= 0; j--) {   
  310.                  int index = (temp[j] / rate) % radix;   
  311.                  arr[--bucket[index]] = temp[j];   
  312.             }   
  313.             //接着rate乘以10并对十位进行相应排序   
  314.             rate *= radix;   
  315.         }   
  316.         /** 输出 **/ 
  317.         for (int k = 0; k < arr.length; k++) { 
  318.             System.out.print(arr[k] + ","); 
  319.         } 
  320.     } 
  321.      
  322.     public static void main(String[] args) { 
  323.         int[] arr = { 2653481113483215 }; 
  324.         /** 待排序数组 **/ 
  325.         int low = 0
  326.         /** 排序期间的起始位 **/ 
  327.         int high = arr.length; 
  328.         /** 排序期间的末位 **/ 
  329.         int[] delta = { 531 }; 
  330.         Sort s = new Sort(); 
  331.         // s.insertSort(arr, low, high); 
  332.         // s.binInsertSort(arr, low, high); 
  333.         // s.shellSort(arr, low, high, delta); 
  334.         // s.bubbleSort(arr, low, high); 
  335.         // s.quickSort(arr, low, high-1); 
  336.         // s.selectSort(arr, low, high); 
  337.         // s.heapSort(arr); 
  338.         //s.mergeSort(arr, low, high - 1); 
  339.         //int[] b = new int[arr.length]; 
  340.         //s.countSort(arr, b, Sort.getMaxNumber(arr)); 
  341.         /** 输出 **/ 
  342. //      for (int k = 0; k < b.length; k++) { 
  343. //          System.out.print(b[k] + ","); 
  344. //      } 
  345.         s.radixSort(arr, 102); 
  346.     }