Java实现各种排序

package com.sbw.testredis;

import java.util.Arrays;

public class Sort{

//冒泡排序 稳定 o(n^2)
public void bubbleSort(int[] data){
boolean isSort = true;
for(int i = 0; i < data.length - 1 && isSort; i++){
isSort = false;
for(int j = data.length - 1; j > i; j--){
if(data[j-1] > data[j]){
int temp = data[j-1];
data[j-1] = data[j];
data[j] =temp;
isSort = true;
}
}
}

}

//选择排序 不稳定 o(n^2)
public void chooseSort(int[] data){
int min = 0;
for(int i = 0; i < data.length - 1; i++){
min = i;
for(int j = i + 1; j < data.length; j++){
if(data[j] < data[min]){
min = j;
}
}

if(min != i){
int temp = data[i];
data[i] = data[min];
data[min] = temp;
}
}
}

//插入排序 o(n^2) 稳定
public void insertSort(int[] data){
int i,j;
for(i = 1; i < data.length; i++){
if(data[i] < data[i-1]){
int temp = data[i];
for(j = i - 1; j >=0 && data[j] > temp; j--){
data[j+1] = data[j];
}

data[j+1] = temp;
}
}
}

//堆排序 从最后一个非叶子节点开始 不稳定 o(nlogn)
public void heapSort(int[] data){
int length = data.length;
for(int i = length/2 - 1; i >= 0; i--)
buildMaxHeap(i, length, data);
for(int i = length - 1; i > 0; i--){
int temp = data[i];
data[i] = data[0];
data[0] = temp;

buildMaxHeap(0, i, data);

}
}

private void buildMaxHeap(int nodeIndex, int length, int[] data){
int temp = data[nodeIndex];
for(int i = 2 * nodeIndex + 1; i < length; i = 2 * i + 1){
if(i < length - 1 && data[i] < data[i+1])
i++;
if(temp >= data[i])
break;
data[nodeIndex] = data[i];
nodeIndex = i;
}

data[nodeIndex] = temp;

}

//快速排序 o(nlogn) o(logn) 不稳定
public void quickSort(int[] data){
_quickSort(data, 0, data.length - 1);
}

private void _quickSort(int[] data, int left, int right){
if(left < right){
int middle = getMiddle(data, left, right);
_quickSort(data, left, middle - 1);
_quickSort(data, middle + 1, right);
}
}
private int getMiddle(int[] data, int left, int right){
int pivot = data[left];
while(left < right){
while(left < right && data[right] >= pivot)
right--;
if (left < right)
data[left++] = data[right];
while (left < right && data[left] <= pivot)
left++;
if (left < right)
data[right--] = data[left];
}
data[left] = pivot;
return left;
}

//归并排序  o(nlogn) o(n) 稳定
public void mergeSort(int[] arr){
int[] temp =new int[arr.length];
internalMergeSort(arr, temp, 0, arr.length-1);
}
private void internalMergeSort(int[] a, int[] b, int left, int right){
if (left<right){
int middle = (left+right)/2;
internalMergeSort(a, b, left, middle);
internalMergeSort(a, b, middle+1, right);
mergeSortedArray(a, b, left, middle, right);
}
}
private void mergeSortedArray(int arr[], int temp[], int left, int middle, int right){
int i=left;
int j=middle+1;
int k=0;
while (i <= middle && j <= right){
if (arr[i] <= arr[j]){
temp[k++] = arr[i++];
}
else{
temp[k++] = arr[j++];
}
}
while (i <= middle){
temp[k++] = arr[i++];
}
while (j <= right){
temp[k++] = arr[j++];
}
//把数据复制回原数组
for (i = 0; i < k; i++){
arr[left+i] = temp[i];
}
}
public static void main(String[] args){
int[] data = {3,34,123,4,45,67,564,789,5,675};
Sort test = new Sort();
//test.bubbleSort(data);
//test.chooseSort(data);
//test.insertSort(data);
//test.heapSort(data);
//test.quickSort(data);
test.mergeSort(data);
System.out.println(Arrays.toString(data));
}
}