java 排序

/**
* <h4>冒泡排序O(N*N) </h4>
* <p>说明：将待排序的元素看做是竖着排列的“气泡”，较小的元素比较轻，从而要上浮，较大的元素比较重，要下沉。<br/>
*    公式：1+2+3+4+...+N=N(N+1)/2</p>
*/
public static int[] bubbleSort(int[] array){
int a = 0;
for(int i=0; i<array.length; i++){
for(int j=i+1; j<array.length; j++){
if(array[i] > array[j]){
int temp = array[j];
array[j] = array[i];
array[i] = temp;
}
System.out.print(++a + " ");
}
}
return array;
}

/**
* <h4>插入排序O(N*N) </h4>
* <p>说明：逐一取出元素，在已经排序的元素序列中从后向前扫描，放到适当的位置。<br/>
*    备注：起初，已经排序的序列为空。<br/>
*    公式：1+2+3+4+...+N=N(N+1)/2</p>
*/
public static int[] insertionSort(int[] array){
int i,j,key;
for(i=1; i<array.length; i++){
key = array[i];

for(j=i-1; j>=0 && array[j] > key ; j--){
array[j+1] = array[j];
}
array[j+1] = key;

}
//Arrays.sort(array);

return array;
}

/**
* <h4>shell排序O(N*N) </h4>
* <p>说明：shell排序是对插入排序的一个改装，它每次排序把序列的元素按照某个增量分成
*        几个子序列，对这几个子序列进行插入排序，然后不断缩小增量扩大每个子序列的
*         元素数量，直到增量为一的时候子序列就和原先的待排列序列一样了，此时只需要
*         做少量的比较和移动就可以完成对序列的排序了。</p>
*/
public static int[] shellSort(int[] array){
int i,j,key,increment;
for(increment=array.length/2; increment>0 ; increment/=2)
for(i=increment; i<array.length; i++){
key = array[i];
for(j=i; j>=increment; j-=increment){
if(key < array[j-increment]){
array[j]=array[j-increment];
}else{
break;
}
}
array[j]=key;
}

return array;
}

/**
* <h4>快速排序</h4>
* <p>说明：在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、
* 右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有
* 记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记
* 录的关键字均大于等于pivot.key，* 而基准记录pivot则位于正确的位置(pivotpos)上，它无
* 须参加后续的排序。</p>
* <p>注意：因为快速排序的记录移动次数不大于比较的次数，所以快速排序的最坏时间复杂度应为0(N*N)，
* 最好时间复杂度为O(nlgn)。</p>
*/
public static int[] quickSort(int[] array, int low, int high){
    int pivotpos;
   
    if(low<high){
    pivotpos = parition(array , low , high);
    quickSort(array, low, pivotpos-1);
        quickSort(array, pivotpos+1, high);
    }

        return array;  
    }  

public static int[] swap(int[] array, int left , int right){
int temp = array[left];
array[left] = array[right];
array[right] = temp;

return array;
}

public static int parition(int[] array, int i , int j){
int pivot = array[i];

while(i<j){
while(i<j && array[j]>pivot)
j--;
swap(array, i , j);
while(i<j && array[i]<pivot)
i++;
swap(array, i , j);
}

return i;

}

/**
* <h4>直接选择排序O(N*N)</h4>
* <p>说明：每一趟从待排序的记录中选出关键字最小的记录，顺序放在已排好序的子文件的最后，直到全部记录排序完毕</p>
*/
public static int[] selectSort(int[] array){
int min,i,j;
for(i=0; i<array.length-1; i++){
min = i;
for(j=i+1; j<array.length; j++){
if(array[j]<array[min]){
min = j;
}
}
if(min != i){
int temp = array[min];
array[min]=array[i];
array[i]=temp;
}

}
Object a ;
return array;
}