public static void quickSort(int[] array) {
quick(array, 0, array.length - 1);
}
public static int partition(int[] array, int left, int right){
int prev = left;
int cur = left + 1;
while (cur <= right){
if(array[cur] < array[left] && array[++prev] != array[cur]){
swap(array,prev,cur);
}
cur++;
}
swap(array,left,prev);
return prev;
}
private static void quick(int[] array,int start,int end) {
if(start >= end){
return;
}
if(end - start + 1 <= 15){
insertSort(array,start,end);
return;
}
int index = middleNume(array,start,end);
swap(array,start,index);
int pivot = partition(array,start,end);
quick(array,start,pivot-1);
quick(array,pivot+1,end);
}
优化
java复制代码
public static void quickSort(int[] array){
quick(array,0, array.length-1);
}
private static void quick(int[] array,int start,int end) {
if(start >= end){
return;
}
if(end - start + 1 <= 15){
insertSort(array,start,end);
return;
}
int index = middleNume(array,start,end);
swap(array,start,index);
int pivot = partitionHoare(array,start,end);
quick(array,start,pivot-1);
quick(array,pivot+1,end);
}
private static int middleNume(int[] array, int left, int right) {
int mid = (left + right)/2;
if(array[left] < array[right] ){
if(array[mid] < array[left]){
return left;
}else if(array[mid] > array[right]){
return right;
}else {
return mid;
}
}else {
if(array[mid] < array[right]){
return right;
}else if(array[mid] > array[left]){
return left;
}else {
return mid;
}
}
}
public static void insertSort(int[] array,int left,int right){
for (int i = left+1; i <= right; i++) {
int tmp = array[i];
int j = i - 1;
for (; j >= left ; j--) {
if(array[j] > tmp){
array[j + 1] = array[j];
}else {
break;
}
}
array[j+1] = tmp;
}
}
非递归的方法
java复制代码
public static void quickSortNor(int[] array){
int start = 0;
int end = array.length -1;
Stack<Integer> stack =new Stack<>();
int pivot = partitionHoare(array,start,end);
if(pivot - 1 > start){
stack.push(start);
stack.push(pivot-1);
}
if(pivot+1 < end){
stack.push(pivot+1);
stack.push(end);
}
while(!stack.empty()){
end =stack.pop();
start = stack.pop();
pivot = partitionHoare(array,start,end);
if(pivot - 1 > start){
stack.push(start);
stack.push(pivot-1);
}
if(pivot+1 < end){
stack.push(pivot+1);
stack.push(end);
}
}
}
private static int partitionHoare(int[] array, int left, int right) {
int tmp = array[left];
int i = left;
while(left < right){
while(left < right && array[right] >= tmp){
right--;
}
while (left < right && array[left] <= tmp){
left++;
}
swap(array,left,right);
}
swap(array,i,left);
return left;
}
4. 归并排序
时间复杂度:0(N*logN)
空间复杂度:0(logN)
稳定性:稳定的
排序目前为止3个稳定的排序:直接插入排序、冒泡排序、归并排序
java复制代码
public static void mergeSort(int[] array){
mergeSortFun(array,0,array.length-1);
}
public static void mergeSortFun(int[] array,int start,int end){
if(start >= end){
return;
}
int mid = (start + end)/2;
mergeSortFun(array,start,mid);
mergeSortFun(array,mid+1,end);
//左右两边数组合并
merge(array,start,mid,end);
}
public static void merge(int[] array,int left,int mid, int right){
int s1 = left;
int e1 = mid;
int s2 = mid+1;
int e2 = right;
//两边的数组合并数组的长度
int[] tmpArray = new int[right - left +1];
int k = 0;
while (s1 <= e1 && s2 <= e2){
if(array[s1] < array[s2]){
tmpArray[k++] = array[s1++];
}else {
tmpArray[k++] = array[s2++];
}
}
while (s1 <= e1){
tmpArray[k++] = array[s1++];
}
while (s2 <= e2){
tmpArray[k++] = array[s2++];
}
for (int i = 0; i < tmpArray.length; i++) {
array[left+i] = tmpArray[i];
}
}
非递归
java复制代码
public static void merge(int[] array,int left,int mid, int right){
int s1 = left;
int e1 = mid;
int s2 = mid+1;
int e2 = right;
//两边的数组合并数组的长度
int[] tmpArray = new int[right - left +1];
int k = 0;
while (s1 <= e1 && s2 <= e2){
if(array[s1] < array[s2]){
tmpArray[k++] = array[s1++];
}else {
tmpArray[k++] = array[s2++];
}
}
while (s1 <= e1){
tmpArray[k++] = array[s1++];
}
while (s2 <= e2){
tmpArray[k++] = array[s2++];
}
for (int i = 0; i < tmpArray.length; i++) {
array[left+i] = tmpArray[i];
}
}
public static void mergeSortNor(int[] array) {
//每组几个数据
int gap = 1;
while(gap < array.length){
for (int i = 0; i < array.length; i = i + gap*2) {
int left = i;
int mid = left + gap -1;
int right = mid + gap;
if(mid >= array.length){
mid = array.length - 1;
}
if(right >= array.length){
right = array.length - 1;
}
merge(array,left,mid,right);
}
gap = gap*2;
}
}
5.非比较排序
使用场景是给定一个指定的待排序的序列
java复制代码
public static void countSort(int[] array){
int minVal = array[0];
int maxVal = array[0];
for (int i = 0; i < array.length; i++){
if(array[i] > maxVal){
maxVal = array[i];
}
if(array[i] < minVal){
minVal = array[i];
}
}
int len = maxVal - minVal + 1;
int[] count = new int[len];
for (int i = 0; i < array.length; i++) {
count[array[i]-minVal]++;
}
int index = 0;
for (int i = 0; i < array.length; i++) {
while(count[0] > 0){
array[index] = i + minVal;
index++;
count[i]--;
}
}
}
重点是最后还是会把整体作一组来直接插入排序
使用场景是给定一个指定的待排序的序列