数据结构之常见排序算法（java实现）

import java.util.Scanner;

public class Sorttest {
    public Sorttest() {
    }
    public static void main(String[] args){

        Scanner sc = new Scanner(System.in);
        int[] arr = {1,3,4,7,2,3,8,9,6,5};
//        for(int i=0; i<10; i++){
//            arr[i] = sc.nextInt();
//        }

        sort3(arr);

        for(int j=0; j<10; j++){
            System.out.print(arr[j]+" ");
        }
    }
/*
* 快速排序：O（nlogn）
*通过一趟排序将要排序的数据分割成独立的两部分，
* 其中一部分的所有数据都比另外一部分的所有数据都要小，
* 然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行
* low high
* */
//基于荷兰国旗的快速排序
public static void quickSort(int[] arr,int start,int end){
    if(arr==null||arr.length<=0){
        return;
    }
    if(start>=end){
        return;
    }
    int left=start;
    int less=start-1;
    int more=end+1;
    int index= (int) (Math.random()*(end-start+1)+start);
    int temp=arr[index];
    while (left<more){
        if(arr[left]<temp){
            swap(arr,left++,++less);
        }else if(arr[left]>temp){
            swap(arr,left,--more);
        }else {
            left++;
        }
    }
    quickSort(arr,start,less);
    quickSort(arr,more,end);
}

    //交换数组中两个元素
    private static void swap(int[] arr, int left, int right) {
        int temp;
        temp=arr[left];
        arr[left]=arr[right];
        arr[right]=temp;
    }


/*
* 直接插入排序:O(n^2)
* 每一步将一个待排序的元素，按其排序码的大小，插入到前面已经排好序的一组元素的适当位置上去，直到元素全部插入为止。
* */

    //插入排序
    public static void sort3(int[] arr){
        //判断输入参数合法性
        if(arr==null||arr.length<=0){
            return;
        }
        int  temp,index;
        for (int i=0; i<arr.length; i++){
            index=i;
            temp=arr[i];
            for(int j=i;j<arr.length;j++){
                //当比哨兵元素小
                if(arr[j]<temp){
                    //保存当前哨兵值
                    index = j;
                    temp = arr[j];
                }
            }
            // 交换哨兵位置
            if(index != i){
                temp=arr[i];
                arr[i]=arr[index];
                arr[index]=temp;
            }
        }
    }


/*
* 简单选择排序：O(n^2)
*选出最小（或者最大）的一个数与第1个位置的数交换；
* 然后在剩下的数中再找最小（或者最大）的与第2个位置的数交换，
* 以此类推，知道第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止
* */
//选择排序
public static void sort2(int[] arr){
    if(arr==null||arr.length<=0){
        return;
    }
    int temp;
    for(int i=0;i<arr.length-1;i++){//控制哨兵位置
        for(int j=i+1;j<arr.length;j++){//控制比较索引
            if(arr[j]<arr[i]){
                temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
}

/*
* 冒泡排序：O(n^2)
* 每一次都选出最大（最小）的数放到后面，
* 这样后面的数就为最大（最小）的数，
* 然后是第二大（第二小）的数，
* 将所有的数都放好，这样就完成了整个的排序
* */

    public static void sort1(int[] arr){
        if(arr==null||arr.length<=0){
            return;
        }
        int flag = 0,temp;
        for(int i=0;i<arr.length-1;i++){//控制比较轮数
            for(int j=0;j<arr.length-1-i;j++){//控制比较索引
                if(arr[j]>arr[j+1]){
                    flag=1;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            if(flag == 0)break;
        }
    }



}