数据机构——排序（java实现）

1.冒泡排序

 public static int[] bubblesort(int[]arr){
        for(int i=0;i<arr.length;i++){
            for(int j=arr.length-1;j>i;j--){
                if(arr[j-1]>arr[j]){
                   int temp=arr[j];
                   arr[j]=arr[j-1];
                   arr[j-1]=temp;
                }
            }
            System.out.println("第"+i+"次排序"+Arrays.toString(arr));

        }
        return arr;
}

2.直接插入排序：
思想：将无序序列中的数插入到有序序列中，此代码我们默认数组的第一个数（即下标为0的数）看作是有序的，其它看成 无序的

public static int []directSort(int[]arr){
        for(int i=1;i<arr.length;i++){
            int temp=arr[i];
            for(int j=i;i>0&&arr[j-1]>temp;j--){
                arr[j]=arr[j-1];
                arr[j-1]=temp;
            }
        }
        return arr;
}

3.快速排序
思路：选择一个基准值，将大于此基准值的数放在右边，小于此基准值的数放在左边

public static void quickSort(int[]arr,int low,int high){
        if(low>=high){
            return ;
        }
        int i=low;
        int j=high;
        int key=arr[i];
        while(i<j){
            while(arr[j]>=key&&i<j){
                j--;
            }
            int t=arr[j];
            arr[j]=arr[i];
            arr[i]=t;
            while(arr[i]<=key&&i<j){
                i++;
            }
            t=arr[i];
            arr[i]=arr[j];
            arr[j]=t;
            //对左侧的集合重复操作
            quickSort(arr,low,i-1);
            //对右侧集合进行重复操作
            quickSort(arr,i+1,high);
        }
    System.out.println(Arrays.toString(arr));

}

4.选择排序：
思路：假设第0个数最小，然后依次与剩下的数进行比较，然后交换数组下标，找到了最小值的下标，再与第一个进行值的交换（一轮下来只交一次）

public static int[]chooseSort(int []arr){
        for(int j=0;j<arr.length-1;j++){
            int minIndex=j;
            for(int i=j+1;i<arr.length;i++){
                if(arr[i]<arr[minIndex]){
                    minIndex=i;
                }

            }
            if(minIndex!=j){
                //交换
                int t;
                t=arr[j];
                arr[j]=arr[minIndex];
                arr[minIndex]=t;
            }
        }
        return arr;
    }

5.希尔排序
基本思想:先将整个待排记录序列分割成若干子序列，分别进行直接插入排序，待整个序列中的记录“基本有序时”，在对全体记录进行一次直接插入排序

public static int[] xiShell(int[]arr,int N){
        for(int D=N/2;D>0;D/=2){
            for(int p=D;p<N;p++){
                int tmp=arr[p];
                for(int i=p;i>=D&&arr[i-D]>tmp;i-=D){
                    arr[i]=arr[i-D];
                    arr[i-D]=tmp;
                }
            }
        }
       return arr;
    }

}