冒泡排序

/*** 冒泡排序 比較好理解* 兩兩相比 較大的放后面* 時間復雜度O(n^2)*//*** 改進前的冒泡排序算法進行100,000數據排序運行時間為：3829ms* 優化后的冒泡排序算法進行100,000數據排序運行時間為：3551ms*/ public static void bubbleSort(int[] array){ //原始的冒泡排序，比較的次數是固定的int len=array.length;int temp=0;for(int i=0;i<len-1;i++){for(int j=0;j<len-1-i;j++){if(array[j]>array[j+1]){temp=array[j];array[j]=array[j+1];array[j+1]=temp;}}} }public static void bubbleSort2(int[] array){ //改進的冒泡排序，有序時無需比較int len=array.length;int temp=0;boolean flag=true;for(int i=0;i<len-1;i++){for(int j=0;j<len-1-i;j++){if(array[j]>array[j+1]){flag=false;temp=array[j];array[j]=array[j+1];array[j+1]=temp;}}if(flag){ //如果有序 則跳出循環break;}else {flag=true;}} }

插入排序

/*** 插入排序,將無序元素依次插入到有序數組中* 和選擇排序很類似。但是其時間取決于數組的初始順序* 時間復雜度為O(n^2)*//*** 由于數據量大時可能存在一堆數據后移的情況，所以時間并不一定比選擇排序快* 插入排序算法進行50,000數據排序運行時間為：1280ms*/ public static void insertSort(int[] array){int temp=0;int len=array.length;for(int i=1;i<len;i++){for(int j=i;j>0;j--){if(array[j]<array[j-1]){temp=array[j];array[j]=array[j-1];array[j-1]=temp;}}} }

選擇排序

/*** 選擇排序* 與冒泡排序不同，無需頻繁進行交換的操作，時間較冒泡排序短* 時間復雜度為O(n^2)*//*** 選擇排序算法進行50,000數據排序運行時間為：626ms*/public static void selectSort(int[] array){int len=array.length;int temp=0;for (int i=0;i<len;i++){int min=i; //min為最小值對應的索引for(int j=i;j<len;j++){ //內層循環的目的是為了找到最小值if(array[j]<array[min]){min=j;}}temp=array[min];array[min]=array[i];array[i]=temp;} }

希爾排序

/*** 希爾排序* 插入排序的變種，慢慢地調整數組的順序，使插入排序效率變高* 最壞情況下時間復雜度為O(n^(1-2))*//*** 希爾排序的效率肯定是要比插入排序要高的* 希爾排序算法進行50,000數據排序運行時間為：705ms*/ public static void shellSort(int[] array){int len=array.length;int h=1;while(h<len/3)h=3*h+1; //希爾排序的增量，相鄰增量應該盡可能互斥！！！ h=1,4,13,40,121...int temp=0;while (h>=1){for (int i=h;i<len;i++){for(int j=i;j>=h;j-=h){if(array[j]<array[j-h]){temp=array[j];array[j]=array[j-h];array[j-h]=temp;}}}h/=3;} }

快速排序

/*** 快速排序* 使用遞歸的方法，有一些難以理解，多看幾遍就好* 主要思想就是設定pivot，將所有比pivot大的放右邊，比pivot小的放左邊* 平均的時間復雜度為O(nlogn) ,有序情況下的復雜度為O(n^2)*//*** 快排是真的快 ,比冒泡插入選擇希爾要快上好多* 快速排序算法進行50,000數據排序運行時間為：4.00ms*/ public static void quickSort(int[] array, int left, int right){if(left>right){ //遞歸結束的條件!!! 沒有這個 遞歸就出不來了return;}int L=left,R=right;int pivot=array[left]; //pivot隨意設置，這里我們設置pivot為最左邊的元素while (left<right){while (array[right]>=pivot && right>left){ //一定要大于等于或者小于等于 不然數字相同可能出現死循環right--; //右指針不斷后移}if(right>left){array[left]=array[right]; //左右指針不重合時，將right的值賦給left}while (array[left]<=pivot && right>left){left++; //左指針開始移動}if(left<right){array[right]=array[left];}}array[left]=pivot; //完成第一次排序quickSort(array,L,left-1);quickSort(array,left+1,R); }

歸并排序

/*** 歸并排序* 同樣使用遞歸，采用分而治之的想法，通過遞歸的方式將若干個有序序列合并為一個* 時間復雜度為 O(nlogn)，同樣非常快*//*** 歸并排序算法進行50,000數據排序運行時間為：4.90ms*/public static void merge(int[] array,int left,int mid,int right){ //進行歸并操作的函數int[] temp=new int[right-left+1]; //建立緩存數組int i=left,j=mid+1;int index=0; //temp的索引while (i<=mid && j<=right){if(array[i]<=array[j]){ // temp[index]=array[i]; // i++; // index++;temp[index++]=array[i++]; //這段代碼可以簡化成這個形式}else {temp[index++]=array[j++];}}while (i<=mid){temp[index++]=array[i++];}while (j<=right){temp[index++]=array[j++];}for (int k=left;k<=right;k++){ //將temp傳回arrayarray[k]=temp[k-left];} }public static void mergeSort(int[] array,int left,int right){ //歸并排序if(left>=right){return;}int mid=(left+right)/2;mergeSort(array,left,mid);mergeSort(array,mid+1,right); //先分解成最小的merge(array,left,mid,right); //再合并 }

基數排序

/*** 基數排序* 空間換時間，所以時間復雜度最低，為 O(d(n+r)) r是基數(基本都是10),d為長度。。。 可趨近于O(n)* PS:我反而覺得基數排序比較復雜，提前需要設置很多變量和數組*//*** 基數排序算法進行50,000數據排序運行時間為：2.35ms*/ public static void radixSort(int[] array){int max=array[0];for (int i=1;i<array.length;i++){if(array[i]>max){max=array[i]; //首先找到數組中的最大數}}int times=(max+"").length(); //得到桶排序的輪數，也就是最大數有幾位int[][] temp=new int[10][array.length]; //定義10個桶，每個桶的容量為元素總個數int t=1; //t表示第幾輪int n=1; //每過一輪n*10，為了得到相應位的數字int num;int[] orderTemp=new int[10]; //數組orderTemp[i]用來表示該位是i的數的個數while (t<=times){for(int i=0;i<array.length;i++){num=(array[i]/n)%10;temp[num][orderTemp[num]]=array[i];orderTemp[num]++;}int index=0;for (int i=0;i<10;i++){if(orderTemp[i]>0){ //如果桶中元素大于0for (int j=0;j<orderTemp[i];j++){array[index++]=temp[i][j];}}orderTemp[i]=0; //一定要把桶子清空哦！！}n*=10;t++;} }

堆排序

/*** 堆排序* 1)將待排序的序列構造成一個大頂堆* 2)將根節點與末尾元素交換，末尾元素就為最大值* 3)剩余數據重新構造成一個大頂堆* 4)不斷執行操作，完成排序* 時間復雜度為O(nlogn)*//*** 堆排序算法進行50,000數據排序運行時間為：4.07ms*/public static void adjustHeap(int[] arr,int i, int length){ //調整一個以i為頂點的子樹int temp=arr[i];for (int k=i*2+1;k<length;k=k*2+1){if(k+1<length && arr[k]<arr[k+1]){k++; //如果左葉子小于右葉子，k就變成右葉子}if (temp<arr[k]){ //對子樹進行調整. 注意！這里要用temp來比較不能用a[i]，我們目的是把temp進行移動arr[i]=arr[k];i=k;} else {break; //說明該子樹已然是一個最大堆，直接跳出循環即可}}arr[i]=temp; }public static void heapSort(int[] arr){for(int i=arr.length/2-1;i>=0;i--){ //i從最后一個非葉子節點開始。位置為i=arr.length/2-1adjustHeap(arr,i,arr.length); //該步驟為建立一個最大堆}for (int i=arr.length-1;i>0;i--){int temp=arr[i];arr[i]=arr[0];arr[0]=temp;adjustHeap(arr,0,i);} }

完結撒花~

總結

以上是生活随笔為你收集整理的距离矢量路由算法的java代码_八大排序算法比较（附Java代码）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。