经典的排序算法

1、冒泡

void BubbleSort(int[]nums,int n){
    for(int i=0;i<a.length;i++){
        flag=0;
        for(int j=0;j<a.length-1-i;j++){
            if(a[j]<a[j+1]){
                int tmp=a[j];
                a[j]=a[j+1];
                a[j+1]=tmp;
                flag=1;
            }
         }
         if(flag==0)
             break;
    }
}
//双向冒泡
void BubbleSort(int[]nums,int n){
    int left=0,shift=1,right=b.length-1;
    while(left<right){
        for(int i=left;i<right;i++){
            if(b[i]>b[i+1]){
                int tmp=b[i];
                b[i]=b[i+1];
                b[i+1]=tmp;
                 shift=i;
            }
        }
        right=shift;
        for(int j=right-1;j>=0;j--){
            if(b[j]>b[j+1]){
                int tmp=b[j];
                b[j]=b[j+1];
                b[j+1]=tmp;
                shift=j;
             }
        }
        left=shift;
    }
} 

2、选择排序

void SelectSort(int[] nums,int n) {
        for(int i=0;i<n;i++) {
            int min = i;
            for(int j=i+1;j<n;j++) {
                if(nums[j]<nums[min]) min = j;
               
            }
            if(min!=i){
                swap(nums[i],nums[min]);
            }
        }
    }          

3、快速排序

public int[] sortArray(int[] nums) {
        int low=0,high=nums.length-1;
        quicksort(nums,low,high);
        return nums;
    }
    public void quicksort(int[] nums,int low,int high){
        if(low<high){
            int index=getIndex(nums,low,high);
            quicksort(nums,low,index-1);
            quicksort(nums,index+1,high);
        }
    }
    public int getIndex(int[] nums,int low,int high){
        int temp=nums[low];
        while(low<high){
            while(low<high&&nums[high]>=temp){
                high--;
            }
            nums[low]=nums[high];
            while(low<high&&nums[low]<=temp){
                low++;
            }
            nums[high]=nums[low];
        }
        nums[low]=temp;
        return low;
    }

//快速排序的三位取中法
void swap(int *arr,int left,int right)
{
    int temp;
    temp=arr[left];
    arr[left]=arr[right];
    arr[right]=temp;    
}
//***************************************************************************
int partition(int *arr,int left,int right)
{
    
    //***************************
    //e.g：9,1,5,8,3,7,4,6,2
    int m=left+(right-left)/2;//找到中间的数字的下标
    if(arr[left]>arr[right])//最左大于最右的时候，交换左右
    {
        swap(arr,left,right);
    }
    if(arr[m]>arr[right])//如果中间的>right ,交换
    {
        swap(arr,m,right);
    }
    if(arr[m]>arr[left])//如果中间的>left，交换
    {
        swap(arr,m,right);
    }
    //经过交换之后low变为3
    //****************************
    int temp=arr[left];//基准
    while(left<right)//知道left和right重合的时候，才找到合适的位置
    {     //从后向前找到比小的数字
        while(left<right  &&  arr[right]>=temp)//当right的值大于temp的值的时候才执行
        {
            right--;
        }
        arr[left]=arr[right];//当right的值小于temp的值的时候执行
         while(left<right  && arr[left] <= temp)//从前往后找到比基准大的数字
        {
            left++;
        }
        arr[right]=arr[left];//当left的值大于temp的时候执行
    }
    arr[left]=temp;//此时的left和right在同一个位置，此时为合适的位置，把temp的值给left
    return left;//此时返回的值是temp合适的位置，即小于它的在它的左边，大于它的在它的右边
}

4、堆排序

import java.util.Arrays;

public class heapSort {
    public static void main(String[] args) {
        int[] nums =new int[]{2,6,9,0,1,5,7};
        Hsort(nums);
        System.out.println(Arrays.toString(nums));
    }
    public static void Hsort(int []nums){
        for(int i=nums.length/2-1;i>=0;i--){
            adjust(nums,i,nums.length);
        }
        for(int i=nums.length-1;i>=0;i--){
            int temp=nums[0];
            nums[0]=nums[i];
            nums[i]=temp;
            adjust(nums,0,i);
        }
    }
    public static void adjust(int nums[],int index,int len){
        int left=index*2+1;
        int right=left+1;
        int maxIndex=index;
        if(left<len&&nums[left]>nums[maxIndex]){
            maxIndex=left;
        }
        if(right<len&&nums[right]>nums[maxIndex]){
            maxIndex=right;
        }
        if(maxIndex!=index){
            int temp=nums[index];
            nums[index]=nums[maxIndex];
            nums[maxIndex]=temp;
            adjust(nums,maxIndex,len);
        }
    }
}