java的排序算法
簡單選擇排序：
package cn.mdj.test;
public class SelectSort {
public static void sort(int array[]){
int len = array.length;
int temp; //臨時變量
int index; //最小元素索引
for(int i=0;i<len;i++){
index = i;//假設第一個元素最小
for(int j=i+1;j<len;j++){//將當前的最小元素與後面元素比較，獲取最小的元素
if(array[j]<array[index]){
index = j;//交換索引，索引永遠指向最小的那個元素
}
}
//與後面元素遍歷完後，看是否需要進行交換
if(index != i){
temp = array[index];
array[index] = array[i];
array[i] = temp;
}
}
}
public static void main(String[] args) {
int[] array = new int[]{1,3,2,6,4,8,5,7,9};
sort(array);
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"、");
}
}
}
簡單插入排序：
package cn.mdj.test;
public class InsertSort {
public static void sort(int[] array){
int len = array.length;
for(int i=1;i<len;i++){
int temp = array[i]; //保存要插入的元素
int j=0; //有序區，內首先有一個元素
//對有序區開始排序，從有序區的後面開始比較大小進行交換
for(j=i-1;j>-1&&temp < array[j];j--){
//如果待插入的元素比其小，則它前面的元素要後移
array[j+1] = array[j];
}
//直到，temp比前面的元素大，即停止，此時的j即該元素的位置，但因j--，所以位置還有要回填1
array[j+1]=temp;
}
}
public static void main(String[] args) {
int[] array = new int[]{1,3,2,6,4,8,5,7,9};
sort(array);
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"、");
}
}
}
簡單冒泡排序：
package cn.mdj.test;
public class BubbleSort {
public static void sort(int[] array){
int len = array.length;
for(int i=0;i<len;i++){
for(int j=i+1;j<len;j++){
if(array[i]>array[j]){
int temp = array[i];
array[i]=array[j];
array[j]= temp;
}
}}}
堆排序：
public class HeapSort {
public static void sort(int[] array){
int len = array.length;
//建立大頂堆
buildMaxHeap(array,len);
for(int i=len-1;i>0;i--){
int temp = array[i];
array[i] = array[0];
array[0] = temp;
MaxHeapify(array,1,i);
}
}
public static void buildMaxHeap(int[] arr,int len){
//從中間元素開始，調整使其變成大頂堆
for(int i=len/2;i>0;i--){
MaxHeapify(arr,i,len);
}
}
public static void MaxHeapify(int[] arr,int index,int len){
int left = 2*index; //當前索引的左孩子
int right = left+1; //當前索引的右孩子
int lagest; //用於儲存最大索引
//如果左葉子節點索引小於堆大小，比較當前值和左葉子節點的值，取值大的索引值
if(left <= len&&arr[left-1]>arr[index-1]){
lagest = left;
}else{
lagest = index;
}
//如果右葉子節點索引小於堆大小，比較右葉子節點和之前比較得出的較大值，取大的索引值
if(right<=len&&arr[right-1]>arr[lagest-1]){
lagest = right;
}
//交換位置，並繼續遞歸調用該方法調整位置。
if(lagest != index){
int temp = arr[index-1];
arr[index-1] = arr[lagest-1];
arr[lagest-1] = temp;
MaxHeapify(arr,lagest,len);
}
}
public static void main(String[] args) {
int[] array = new int[]{1,3,2,6,4,8,5,7,9};
sort(array);
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"、");
}
}
}
希爾排序：
package cn.mdj.test;
public class ShellSort {
public static void sort(int[] array){
int len = array.length;
int h = 1;
while(h<=len/3){ //當分區的區間沒有超過len數據的長度，即 繼續按照固定增量法，增加
h = h*3 + 1; //初始增量，最後得到h為劃分的合理區間
}
while(h>0){ //直到h=1;為止
for(int i=h;i<len;i++){ //和插入排序類似，從分區域的第二個元素開始，所以是i=h;；
//只所以是i++;是因為控制的是外面的，都要分區
int temp = array[i]; //保存第二個元素
int j = array[i-h];//有序區中的一個元素
//開始對有序區中的元素進行排序，從後往前，即從i-h,
for(j=i-h;j>-1&&temp<array[j];j=j-h){ //註意是j-h
//往後移動
array[j+h] = array[j];
}
array[j+h] = temp;
}
h = (h-1)/3; //不斷縮小區間，直到為1
}
}
public static void main(String[] args) {
int[] array = new int[]{1,3,2,6,4,8,5,7,9};
sort(array);
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"、");
}
}
}
快速排序：
package cn.mdj.test;
public class QuickSort {
public static void sort(int[] array){
int len = array.length;
quickSort(array,0,len-1);
}
public static void quickSort(int arr[],int l,int r){
//l 左 r 右
int left = l;
int right = r;
int jizhunzhi = arr[left];
while(left < right){ //左 沒有超過 右的時候
while(left<right&&jizhunzhi<arr[right]){
right--;
}
if(left<right){ //否則當 jizhunzhi>arr[right] 時候，說明要開始交換了
arr[left] = arr[right];
left++;//開始移動到下一個位置
}
//同樣，右邊完成後，左邊要開始了
while(left<right&&jizhunzhi>arr[left]){
left++;
}
if(left<right){//否則 jizhunzhi<arr[left]
arr[right] = arr[left];
right--;
}
}
//最後直到left = right 停止，那麽第一元素，也就是我們假設的jizhunzhi的位置也就確定好了
arr[left] = jizhunzhi;
if(l<left) quickSort(arr,l,right-1);
if(left<r) quickSort(arr,right+1,r);
}
public static void main(String[] args) {
int[] array = new int[]{1,13,2,6,4,8,5,7,9};
sort(array);
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"、");
}
}
}
java的排序算法