Java实现快速排序、归并排序、堆排序和希尔排序

快速排序

算法思想

1.将数组的第一个元素取为target,定义两个指针i 和 j；

2.指针i ，从左向右找到第一个比target大的元素，指针j从右向左找到第一个比target小的元素，若i小于j,则交换i, j 指针指向的元素的值；

3.指针i继续从左向右搜索，指针j继续从右向左搜索，重复步骤2直到某一次停下来以后i>j，此时交换target与j指向元素的位置，这样即可保证target左边的元素都小于它，target右边的元素都大于它；

4.递归target左右两部分，直到只剩下1个元素。

平均、最好时间复杂度：O(nlgn) 最差时间复杂度：O(n^2)

空间复杂度：O(1) (也可以说需要的空间是O(n)，因为在递归调用时有栈的开销，最坏是O(n),平均是O(logn))

代码实现

public class QuickSort {
public static void quickSort(int[] R, int low, int high){
if(low >= high)
return;
int i = low+1;
int j = high;
while(i<j){
while(R[i]<=R[low] && i<high)
i++;
while(R[j]>R[low] && j>low)
j--;

if(i<j){
int temp = R[i];
R[i] = R[j];
R[j] = temp;
}

}
int temp = R[j];
R[j] = R[low];
R[low] = temp;

quickSort(R, low, j - 1);
quickSort(R , j+1, high);
}

public static void main(String[] args) {

int[] arr = new int[10000];
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
arr[i] = Math.abs(r.nextInt(1000));
}

quickSort(arr, 0, arr.length - 1);
if (check(arr)) System.out.println("right");
else System.out.println("wrong");

}
public static boolean check(int[] arr) {
for (int i = 1; i < arr.length; i++) {
if (arr[i] < arr[i - 1]) {
System.out.println(arr[i - 1] + "   " + arr[i]);
System.out.println("position is " + i);
return false;
}
}
return true;
}
}

归并排序

算法思想

1.将原数组不断二分，直到叶节点只剩一个元素

2.将同属一个父节点的两个儿子合并成有序的数组，该父节点即变为有序数组

3.递归的划分并合并，即可得到最终有序的数组

平均、最好、最差时间复杂度：O(nlgn) 空间复杂度：O(n)

public class mergeSort {
public static void merge(int[] R, int low1, int high1, int low2, int high2){
int i = low1;
int j = low2;
int[] temp = new int[high1-low1+1+high2-low2+1];
int index = 0;
while(i<=high1 && j<=high2){
if(R[i]<=R[j]){
temp[index] = R[i];
i ++;
}
else{
temp[index] = R[j];
j ++;
}
index ++;
}

if(i>high1){
while(j<=high2){
temp[index] = R[j];
j ++;
index ++;
}
}

if(j>high2){
while(i<=high1){
temp[index] = R[i];
i ++;
index ++;
}
}

int m = low1;
for(int k=0;k<temp.length;k++,m++)
R[m] = temp[k];
}

public static void MergeSort(int[] R, int low, int high){
if(low >= high)
return;
int mid = (low+high)/2;
MergeSort(R, low, mid);
MergeSort(R, mid+1, high);
merge(R, low, mid, mid+1, high);
}

public static void main(String[] args){
int[] R = {5,7,3,19,4,9,17,15,12,31,23,30,5,8,1,17
c2f6
,16,5,3};
MergeSort(R, 0, R.length-1);
for(int i=0;i<R.length;i++)
System.out.printf("%d ",R[i]);
}
}

堆排序

public class HeapSort {

public static void rebuildHeap(int[] A, int start, int end){
int i = start;
while(i<=end/2 -1) {
if(A[i]>A[2*i+1] && 2*i+2<end && A[i]>A[2*i+2]|| A[i]>A[2*i+1] && 2*i+2>end )
break;
else{
if(2*i+2<end) {
if (A[2*i + 1] >= A[2*i + 2]) {
swap(A, i, 2 * i + 1);
i = 2*i + 1;
}
else {
swap(A,i,2*i +2);
i = 2*i + 2;
}
}
else{
swap(A, i, 2 * i + 1);
i = 2*i + 1;
}
}
}
}

public static void HeapSort(int[] A){
int n = A.length;
int start = n/2 - 1;
for(int i=start;i>=0;i-- ){
rebuildHeap(A, i, n-1);
}
for(int j=n-1;j>0;j--){
swap(A, 0, j);
rebuildHeap(A,0,j-1);
}
}
public static void swap(int[] A,int a,int b){
int temp = A[a];
A[a] = A[b];
A[b] = temp;
}
public static void main(String[] args){
int[] A = new int[]{6,12,3,7,8,2,9,11,35,12,8,22};
HeapSort(A);
for(int i:A){
System.out.println(i);
}
}
}

希尔排序

public class ShellSort {
public static void shellSort(int[] A){
for(int gap = A.length/2; gap > 0; gap/=2)
for(int i=gap;i<A.length;i++){
for(int j=i;j>=gap;j-=gap){
if(A[j]<A[j-gap]){
int temp = A[j];
A[j] = A[j-gap];
A[j-gap] = temp;
}
else break;
}
}
}
public static void main(String[] args){
int[] A = new int[]{6,2,12,3,5,14,22,24,7};
shellSort(A);
for(int x:A)
System.out.println(x);
}
}