排序算法整理

1 快速排序算法

public void quickSort(int[] nums,int start,int end){  
        if (start >= end) return;  
        //conquer  
        int left = start,right = end-1;  
        //选择数组最后一个数字作为主元，把小于主元的数字移到主元的前面，把大于主元的数字移到主元的后面
        int mid = nums[end];  
        while(left < right){  
            while(left < right && nums[left] <= mid)  
                left ++;  
            while(left < right && mid <= nums[right])  
                right --;  
            swap(nums,left,right);  
        }  
        if(nums[left] > mid) swap(nums,left,end);  
        else {  
            left++;  
            swap(nums,left,end);  
        }  
        //divide  
        quickSort(nums,start,left-1);  
        quickSort(nums,left+1,end);  
    }  

2 归并排序

public void reOrderArray(int [] array) {
        if(array == null || array.length <= 1)
            return;
        MergeSort(array,0,array.length-1);
    }

    public void MergeSort(int[] array,int start,int end){
        if(start < end){
            int mid = (start + end)/2;
            //将左半部分排好序
            MergeSort(array,start,mid);
            //将右半部分排好序
            MergeSort(array,mid+1,end);
            //合并左半部分和右半部分
            Merge(array,start,mid,end);
        }
    }
    public void Merge(int[] array,int start,int mid,int end){
        int[] temp = new int[array.length];
        int i = start,j = mid+1,k = start;
        while (i <= mid && j <= end)  
        {  
        if (a[i] <= a[j])  
            temp[k++] = array[i++];  
        else  
            temp[k++] = array[j++];  
        }  
        while(i <= mid){
            temp[k++] = array[i++];
        }
        while(j <= end){
            temp[k++] = array[j++];
        }

        for(k = start; k <= end; k++){
            array[k] = temp[k];
        }
    }

3 冒泡排序

public class BubbleSort
{
    public void sort(int[] a)
    {
        int temp = 0;
        for (int i = a.length - 1; i > 0; --i)
        {
            for (int j = 0; j < i; ++j)
            {
                if (a[j + 1] < a[j])
                {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }
}

4 插入排序

private static int[] insertSort(int[]arr){
if(arr == null || arr.length < 2){
    return arr;
}
for(inti=1;i<arr.length;i++){
    for(intj=i;j>0;j--){
        if(arr[j]<arr[j-1]){
        //TODO:
        int temp=arr[j];
        arr[j]=arr[j-1];
        arr[j-1]=temp;
        }else{
        //接下来是无用功
        break;
        }
    }
}
return arr;
}

5 选择排序

public static void selectSort(int[]a)
{
    int minIndex=0;
    int temp=0;
    if((a==null)||(a.length==0))
        return;
    for(int i=0;i<a.length-1;i++)
    {
        minIndex=i;//无序区的最小数据数组下标
        for(intj=i+1;j<a.length;j++)
        {
            //在无序区中找到最小数据并保存其数组下标
            if(a[j]<a[minIndex])
            {
                minIndex=j;
            }
        }
        //将最小元素放到本次循环的前端
        temp=a[i];
        a[i]=a[minIndex];
        a[minIndex]=temp;
    }
}