排序算法Java版

选择排序：
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;
            }
        }
        if(minIndex!=i)
        {
            //如果不是无序区的最小值位置不是默认的第一个数据，则交换之。
            temp=a[i];
            a[i]=a[minIndex];
            a[minIndex]=temp;
        }
    }
}

    
插入排序：
//依次元素加入元素插入到已排好的序列中
    private static int[] insertSort(int []arr) {
        if (arr==null||arr.length<2) {
            return arr;
        }
        for (int i = 0; i < arr.length-1; i++) {
            for (int j =i+1; j >0; j--) {
                if (arr [j]>=arr[j-1]) {
                     break;
                }
                else {
                    int temp =arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;
                }
                
            }
            
        }
        return arr;
    }

快速排序：
private void swap(int x,int y) {
        int temp=array[x];
        array[x]=array[y];
        array[y]=temp;
    }
    private  void quick_sort_recursive(int start,int end) {
        if (start>=end) 
            return;
        int mid=array[end];
        int left=start;
        int right=end-1;
        while (left < right) {
            while (array[left] < mid && left < right)
                left++;
            while (array[right] >= mid && left < right)
                right--;
            swap(left, right);   //交换两个数在数组中的位置 
        }
         //最终将基准数归位 
        if (array[left] >= array[end])
            swap(left, end);
        else
            left++;
        quick_sort_recursive(start, left - 1);//继续处理左边的，这里是一个递归的过程
        quick_sort_recursive(left + 1, end);//继续处理右边的 ，这里是一个递归的过程 
    
    }
该算法不太好理解，详细分析可以参考：http://www.cnblogs.com/morewindows/archive/2011/08/13/2137415.html