久久国产成人av_抖音国产毛片_a片网站免费观看_A片无码播放手机在线观看,色五月在线观看,亚洲精品m在线观看,女人自慰的免费网址,悠悠在线观看精品视频,一级日本片免费的,亚洲精品久,国产精品成人久久久久久久

搜索
分享

幾種常用排序算法

最近剛上班,，在公司每天除了學(xué)習(xí)業(yè)務(wù)以外就是打打醬油,，利用空余時間整理了幾個排序算法
Java代碼  收藏代碼
  1. /** 
  2.  * @author txin0814 E-mail:[email protected] 
  3.  * @version 1.0 
  4.  * @date Apr 1, 2011 2:28:06 PM 
  5.  * @description 排序類的 基類 
  6.  */  
  7.   
  8. public abstract class BaseSorter<E extends Comparable<E>> {  
  9.       
  10.     public abstract void sort(E[] array,int from,int len);  
  11.       
  12.     public final void sort(E[] array){  
  13.         sort(array,0,array.length);  
  14.     }  
  15.       
  16.     protected final void swap(E[] array,int from,int to){  
  17.         E temp = array[from];  
  18.         array[from] = array[to];  
  19.         array[to] = temp;  
  20.     }  
  21. }  
  22.   
  23. /** 
  24.  * @author txin0814 E-mail:[email protected] 
  25.  * @version 1.0 
  26.  * @date Apr 1, 2011 2:34:47 PM 
  27.  * @description 插入排序 該算法在數(shù)據(jù)規(guī)模小的時候十分高效， 
  28.  *              該算法每次插入第K+1到前K個有序數(shù)組中一個合適位置,， 
  29.  *              K從0開始到N-1,從而完成排序 
  30.  */  
  31.   
  32. public class InsertSorter<E extends Comparable<E>> extends BaseSorter<E>{  
  33.       
  34.     //當(dāng)SORT_TYPE為false時按降序排列 為TRUE時按升序排列  
  35.     public static boolean SORT_TYPE = false;   
  36.   
  37.     @Override  
  38.     public void sort(E[] array, int from, int len) {  
  39.         E tmp=null;  
  40.         for(int i=from+1;i<from+len;i++){  
  41.             tmp=array[i];  
  42.             int j=i;  
  43.             for(;j>from;j--){  
  44.                 if(SORT_TYPE){  
  45.                     if(tmp.compareTo(array[j-1])<0){  
  46.                         array[j]=array[j-1];  
  47.                     }else break;  
  48.                 }else{  
  49.                     if(tmp.compareTo(array[j-1])>0){  
  50.                         array[j]=array[j-1];  
  51.                     }else break;  
  52.                 }  
  53.             }  
  54.             array[j]=tmp;  
  55.         }  
  56.           
  57.         /*for (E e : array) { 
  58.             System.out.println(e); 
  59.         }*/  
  60.   
  61.     }  
  62.   
  63.     public static void main(String[] args) {  
  64.         Integer[] elem = {32, 43, 1, 3, 54, 4, 19};  
  65.         InsertSorter<Integer> insertsort = new InsertSorter<Integer>();  
  66.         //InsertSorter.SORT_TYPE = true;  
  67.         insertsort.sort(elem);  
  68.         for (Integer integer : elem) {  
  69.             System.out.println(integer);  
  70.         }  
  71.     }  
  72. }  
  73.   
  74.   
  75. /** 
  76.  * @author txin0814 E-mail:[email protected] 
  77.  * @version 1.0 
  78.  * @date Apr 1, 2011 2:53:29 PM 
  79.  * @description 冒泡排序 算法思想是每次從數(shù)組末端開始比較相鄰兩元素，把第i小的冒泡到數(shù)組的第i個位置。 
  80.  *              i從0一直到N-1從而完成排序,。（當(dāng)然也可以從數(shù)組開始端開始比較相鄰兩元素， 
  81.  *              把第i大的冒泡到數(shù)組的第N-i個位置,。i從0一直到N-1從而完成排序,。) 
  82.  */  
  83.   
  84. public class BubbleSorter<E extends Comparable<E>> extends BaseSorter<E> {  
  85.   
  86.     //當(dāng)SORT_TYPE為false時按降序排列 為TRUE時按升序排列  
  87.     public static boolean SORT_TYPE = false;   
  88.   
  89.     public final void bubble_down(E[] array, int from, int len) {  
  90.         for (int i = from; i < from + len; i++) {  
  91.             for (int j = from + len - 1; j > i; j--) {  
  92.                 if (array[j].compareTo(array[j - 1]) > 0) {  
  93.                     swap(array, j - 1, j);  
  94.                 }  
  95.             }  
  96.         }  
  97.     }  
  98.   
  99.     public final void bubble_up(E[] array, int from, int len) {  
  100.         for (int i = from + len - 1; i >= from; i--) {  
  101.             for (int j = from; j < i; j++) {  
  102.                 if (array[j].compareTo(array[j + 1]) > 0) {  
  103.                     swap(array, j + 1, j );  
  104.                 }  
  105.             }  
  106.         }  
  107.     }  
  108.   
  109.     @Override  
  110.     public void sort(E[] array, int from, int len) {  
  111.         if (SORT_TYPE) {  
  112.             bubble_up(array, from, len);  
  113.         } else {  
  114.             bubble_down(array, from, len);  
  115.         }  
  116.     }  
  117.       
  118.     public static void main(String[] args) {  
  119.         Integer[] elem = {32, 43, 1, 3, 54, 4, 19};  
  120.         BubbleSorter<Integer> bsort = new BubbleSorter<Integer>();  
  121.         //BubbleSorter.DWON = true;  
  122.         //bsort.sort(elem);  
  123.         //BubbleSorter.SORT_TYPE = true;  
  124.         bsort.sort(elem, 0, elem.length);  
  125.         for (Integer integer : elem) {  
  126.             System.out.println(integer);  
  127.         }  
  128.     }  
  129.   
  130. }  
  131.   
  132. /** 
  133.  * @author txin0814 E-mail:[email protected] 
  134.  * @version 1.0 
  135.  * @date Apr 1, 2011 3:17:42 PM 
  136.  * @description 選擇排序 選擇排序相對于冒泡來說，它不是每次發(fā)現(xiàn)逆序都交換,， 
  137.  *              而是在找到全局第i小的時候記下該元素位置,，最后跟第i個元素交換，從而保證數(shù)組最終的有序,。 
  138.  *              相對與插入排序來說,，選擇排序每次選出的都是全局第i小的，不會調(diào)整前i個元素了 
  139.  */  
  140.   
  141. public class SelectSorter<E extends Comparable<E>> extends BaseSorter<E> {  
  142.   
  143.     @Override  
  144.     public void sort(E[] array, int from, int len) {  
  145.         for (int i = 0; i < len; i++){  
  146.             int smallest = i;  
  147.             int j = i + from;  
  148.             for(;j < from + len ; j++){  
  149.                 if(array[j].compareTo(array[smallest]) < 0){  
  150.                     smallest = j;  
  151.                 }  
  152.             }  
  153.             swap(array,i,smallest);  
  154.         }  
  155.     }  
  156.       
  157.     public static void main(String[] args){  
  158.         Integer[] elem = {12,20,2,5,1,25,55,15};  
  159.         SelectSorter<Integer> sort = new SelectSorter<Integer>();  
  160.         sort.sort(elem);  
  161.         for (Integer integer : elem) {  
  162.             System.out.println(integer);  
  163.         }  
  164.     }  
  165.   
  166. }  

    本站是提供個人知識管理的網(wǎng)絡(luò)存儲空間，所有內(nèi)容均由用戶發(fā)布,，不代表本站觀點,。請注意甄別內(nèi)容中的聯(lián)系方式、誘導(dǎo)購買等信息,，謹防詐騙,。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點擊一鍵舉報,。
    轉(zhuǎn)藏 分享 獻花（0）

    0條評論

    發(fā)表

    請遵守用戶 評論公約

    類似文章 更多