排序算法总结

---

排序算法总结

---

package com.tulun.src06;

/**

• @author Richard
• @date 2019/9/23 0023-10:33
• *最简单的交换排序,效率极低
• 冒泡排序法
• 冒泡排序法2
• 冒泡排序法的优化：避免有序序列无意义的判断
• 简单的选择排序法
• 选择排序法的优化
• 插入排序
• 希尔排序2
• 插入排序2
• 插入排序3
• 希尔排序*
  */

public class OrderTest {
public static void main(String[] args) {
int[] array={2,5,4,3,1,0};
int[] arr={1,2,3,4,5,6};
//order(array);
//Bubble(array);
//Bubble(arr);
//BubbleSort(array);
//SelectSort(array);
IncertOrder3(array);
}

public static  void  swap(int[] array,int i,int j){
    int temp=array[i];
    array[i]=array[j];
    array[j]=temp;
}
public static void show(int[] array){
    for (int i=0;i<array.length;i++){
        System.out.print(array[i]+"   ");
    }
    System.out.println();
}
//

最简单的交换排序，效率极低

public  static void order(int[] array){
    for (int i=0;i<array.length;i++){
        for (int j=i+1;j<array.length;j++){
            if (array[i]>array[j]){
                swap(array,i,j);
            }
        }
    }
    show(array);
}
//

冒泡排序法

public static void Bubble(int[] array){
    for (int i=0;i<array.length;i++){
        boolean flag=false;//设置一个标记，若序列为有序序列，则跳出循环
        for (int j=0;j<array.length-i-1;j++){
            if (array[j]>array[j+1]){
                swap(array,j,j+1);
                flag=true;
            }

        }
        if (flag==false){
            break;
        }
    }
    show(array);
}
/

/冒泡排序法2

public static void BubbleSort(int[] array){
    for (int i=0;i<array.length;i++){
        for (int j=array.length-2;j>=i;j--){
            if (array[j]>array[j+1]){
                swap(array,j,j+1);
            }
        }
    }
    show(array);
}
//

冒泡排序法2的优化，避免有序序列的无意义判断

public static void BetterBubbleSort(int[] array){
    boolean flag=true;
    for (int i=0;i<array.length && flag;i++){
        flag=false;
        for (int j=array.length-2;j>=i;j--){
            if (array[j]>array[j+1]){
                swap(array,j,j+1);
                flag=true;
            }
        }
    }
}
//

简单选择排序

public static void SelectSort(int[] array){
    for (int i=0;i<array.length;i++){
        int min=i;
        for (int j=i+1;j<array.length;j++){
            if (array[min]>array[j]){
                min=j;
            }
        }
        if (i!=min){
            swap(array,i,min);
        }
    }
    show(array);
}
/

/选择排序的优化

public static void BetterSelectSort(int[] array){//2 5 3 1 4 6 8 7
    for (int i=0;i<array.length/2;i++){
        int min=i;
        int max=array.length-1-i;
        for (int j=i;j<array.length-i;j++){
            if (array[min]>array[j]){
                min=j;
            }
            if (array[max]<array[j]){
                max=j;
            }
        }
        if (i!=min){
            swap(array,i,min);
        }
        if (array.length-1-i!=max){
            swap(array,array.length-1,max);
        }
    }
}

//插入排序

public static void IncertOrder(int[] array){
    for (int i=1;i<array.length;i++){
        if (array[i]<array[i-1]){
            int temp=array[i];
            for (int j=i-1;j>=0 && array[j]>temp;j--){
                array[j+1]=array[j];
                array[j]=temp;
            }
        }
    }
    show(array);
}

//希尔排序2

public static void ShellSorty(int[] array,int gap){
   for (int i=gap;i<array.length;i++){
       int temp=array[i];
       int j=i-gap;
       for (;j>=0 && array[j]>temp;j-=gap){
           array[j+gap]=array[j];
           array[j]=temp;
       }
   }
}
public static void ShellSorty(int[] array){
    int[] gaps={5,3,1};
    for (int i=0;i<gaps.length;i++){
        ShellSorty(array,gaps[i]);
    }
}

//插入排序2

public static void IncertOrder2(int[] array){
    for (int i=1;i<array.length;i++) {
        if (array[i] < array[i - 1]) {
            int temp=array[i];
            for (int j = i-1; j >= 0; j--) {
                if (array[j]>temp) {
                    array[j + 1] = array[j];
                    array[j]=temp;
                }
            }
        }
    }
}

//插入排序3

public static void IncertOrder3(int[] array){
    for (int i=1;i<array.length;i++){
        int temp=array[i];
        int j=i-1;
        while (j>=0 && array[j]>temp){
            array[j+1]=array[j];
            array[j]=temp;
            j--;
        }
    }
    show(array);
}

//希尔排序

public static void ShellOrder(int[] array){
    int[] gap={5,3,1};
    for (int i=0;i<array.length;i++){
        ShellOrder(array,gap[i]);
    }
}
public static void ShellOrder(int[] array,int gap){
    for (int i=gap;i<array.length;i++){
        int temp=array[i];
        int j=i-gap;
        while (j>=0 && array[j] >temp){
            array[j+gap]=array[j];
            array[j]=temp;
            j-=gap;
        }
    }
}

}