7种基于比较的排序算法
从小到大排序
package sort;
import java.util.Stack;
import java.util.concurrent.ForkJoinPool;
public class SortDemo {
private void swap(int[] array, int x, int y) {
int temp = array[x];
array[x] = array[y];
array[y] = temp;
}
/**
* 直接插入排序 时间复杂度：最坏O(n^2) 最好O(n) 越有序越快
* 空间复杂度：O(1)
* 稳定性：稳定
* @param array
*/
public void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int temp = array[i];
int j;
for (j = i - 1; j >= 0; j--) {
if (array[j] > temp) {
array[j + 1] = array[j];
} else {
break;
}
}
array[j + 1] = temp;
}
}
/**
* 希尔排序
* 时间复杂度：1.3-1.5
* 空间复杂度：O(1)
* 稳定性：不稳定
* @param array
*/
public void shellSort(int[] array) {
int[] gap = {5, 3, 1};
for (int i = 0; i < gap.length; i++) {
shell(array, gap[i]);
}
}
private void shell(int[] array, int gap) {
for (int i = gap; i < array.length; i++) {
int temp = array[i];
int j;
for (j = i - gap; j >= 0; j -= gap) {
if (array[j] > temp) {
array[j + gap] = array[j];
} else {
break;
}
}
array[j + gap] = temp;
}
}
/**
* 选择排序 时间复杂度：O(n^2)
* 空间复杂度：O(1)
* 稳定性：不稳定
* @param array
*/
public void selectSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i] > array[j]) {
swap(array,i,j);
}
}
}
}
/**
* 堆排序 时间复杂度：O(nlog(n)) 不管有序无序
* 空间复杂度：O(1)
* 稳定性：不稳定
*/
public void heapSort(int[] array) {
createHeap(array);
int len = array.length - 1;
while (len > 0) {
int temp = array[len];
array[len] = array[0];
array[0] = temp;
adjustDown(array, 0, len);
len--;
}
}
private void createHeap(int[] array) {
for (int i = (array.length - 1 - 1) / 2; i >= 0; i--) {
adjustDown(array, i, array.length);
}
}
private void adjustDown(int[] array, int root, int len) {
int parent = root;
int child = 2 * parent + 1;
while (child < len) {
if (child + 1 < len && array[child + 1] > array[child]) {
child = child + 1;
}
if (array[child] > array[parent]) {
int temp = array[child];
array[child] = array[parent];
array[parent] = temp;
parent = child;
child = 2 * parent + 1;
} else {
break;
}
}
}
/**
* 冒泡排序 时间复杂度：O(n^2) 优化后 最好：O(n)
* 空间复杂度：O(1）
* 稳定性：稳定
*/
public void bubbleSort(int[] array) {
boolean flag = false;
for (int i = 0; i < array.length - 1; i++) {
flag = false;
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
flag = true;
swap(array,j,j+1);
}
}
if (!flag) {
break;
}
}
}
/**
* 快速排序 时间复杂度:O(nlog(n)) 最坏:O(n^2)
* 空间复杂度:O(log(n)) 最坏：O(n)
* 稳定性：不稳定
*/
public void quickSort(int[] array) {
quick(array, 0, array.length - 1);
}
private void quick(int[] array, int left, int right) {
if (left >= right) {
return;
}
//优化一：当待排序区间<=100时，使用直接插入排序
if (right - left + 1 <= 100) {
insert_Sort(array, left, right);
}
//优化二：三数取中法
three_num_mid(array, left, right);
int par = partition(array, left, right);
quick(array, left, par - 1);
quick(array, par + 1, right);
}
private int partition(int[] array, int low, int high) {
int temp = array[low];
while (low < high) {
while (low < high && array[high] >= temp) {
high--;
}
array[low] = array[high];
while (low < high && array[low] <= temp) {
low++;
}
array[high] = array[low];
}
array[low] = temp;
return low;
}
private void insert_Sort(int[] array, int start, int end) {
for (int i = start + 1; i <= end; i++) {
int temp = array[i];
int j;
for (j = i - 1; j >= start; j--) {
if (array[j] > temp) {
array[j + 1] = array[j];
} else {
break;
}
}
array[j + 1] = temp;
}
}
private void three_num_mid(int[] array, int left, int right) {
//array[mid]<=array[left]<=array[right]
int mid = (left + right) / 2;
if (array[left] > array[right]) {
swap(array, left, right);
}
if (array[mid] > array[left]) {
swap(array, mid, left);
}
if (array[mid] > array[right]) {
swap(array, mid, right);
}
}
//非递归的快排
public void quickSort1(int[] array) {
quick1(array, 0, array.length - 1);
}
private void quick1(int[] array, int left, int right) {
Stack<Integer> stack = new Stack<>();
int par = partition(array, left, right);
if (par > left + 1) {
stack.push(left);
stack.push(par - 1);
}
if (par < right - 1) {
stack.push(par + 1);
stack.push(right);
}
while (!stack.empty()) {
right = stack.pop();
left = stack.pop();
par = partition(array, left, right);
if (par > left + 1) {
stack.push(left);
stack.push(par - 1);
}
if (par < right - 1) {
stack.push(par + 1);
stack.push(right);
}
}
}
/**
* 归并排序 时间复杂度：O(nlog(n))
* 空间复杂度：O(n)
* 稳定性： 稳定
* @param array
*/
public void mergeSort(int[] array){
mergeSortInternal(array,0,array.length-1);
}
private void mergeSortInternal(int[] array,int low,int high){
if(low>=high){
return;
}
int mid=(low+high)>>>1;
mergeSortInternal(array,low,mid);
mergeSortInternal(array,mid+1,high);
merge(array,low,mid,high);
}
private void merge(int[] array,int low,int mid,int high){
int s1=low;
int s2=mid+1;
int len=high-low+1;
int[] ret=new int[len];
int i=0;
while(s1<=mid&&s2<=high){
if(array[s1]<=array[s2]){
ret[i++]=array[s1++];
}else{
ret[i++]=array[s2++];
}
}
while(s1<=mid){
ret[i++]=array[s1++];
}
while(s2<=high){
ret[i++]=array[s2++];
}
for (int j = 0; j < ret.length; j++) {
array[j+low]=ret[j];
}
}
//非递归的归并排序
public void mergeSort1(int[] array) {
for (int i = 1; i < array.length; i *= 2) {
mergeNor(array, i);
}
}
private void mergeNor(int[] array,int gap){
int[] ret=new int[array.length];
int k=0;
int s1=0;
int e1=s1+gap-1;
int s2=e1+1;
int e2=s2+gap-1<array.length?s2+gap-1:array.length-1;
while(s2<array.length){
while(s1<=e1&&s2<=e2){
if(array[s1]<array[s2]){
ret[k++]=array[s1++];
}else{
ret[k++]=array[s2++];
}
}
while(s1<=e1){
ret[k++]=array[s1++];
}
while(s2<=e2){
ret[k++]=array[s2++];
}
s1=e2+1;
e1=s1+gap-1;
s2=e1+1;
e2=s2+gap-1<array.length?s2+gap-1:array.length-1;
}
while(s1<=array.length-1){
ret[k++]=array[s1++];
}
for(int i=0;i<ret.length;i++){
array[i]=ret[i];
}
}
}