quicksort1是传统的取首数字,但是此时仅适用于数组完全随机,如不随机,复杂度为O(n2)
一定要先走最后的指针,从后往前走
quicksort2是另一种取法,取中位数,此方法也省去了最后交换首数字的一部,简单了一点点
注意:i,j在处理和tmp相同的数字时,要进行相同的操作,保持数组两端平衡,否则会skrewed,影响效率
排序的稳定性判断条件:输出的数组是否和输入数组有关联
j接下来是自己想的方法:(我发现我的有问题dbq
public static int[] countingRadixSort3(int[] arr, int num) {
final int BUCKETS = 10;
int[] out = new int[arr.length];
int[] tmp = new int[arr.length];
int[] count = new int[BUCKETS];
for(int m =0,n =1;m<num;m++,n*=10) {
for (int i = 0; i < arr.length; i++) {
count[arr[i]/n % 10]++;
}
for (int i = 1; i < BUCKETS; i++) {
count[i] += count[i - 1];
}
for (int i = arr.length - 1; i >= 0; i--) {
out[--count[arr[i]/n%10]] = arr[i];
}
//arr = out; this is not right cuz arr points to out, insead of copying out
for(int i=0;i<out.length;i++){
arr[i] =out[i];
}
count = new int[BUCKETS];
}
return arr;
}
不过大佬的方法在最下面
package Course2.ch07;
public class quickSort {
public static void quickSort(int[] arr,int low,int high){
int i,j,temp,t;
if(low>high){
return;
}
i=low;
j=high;
//temp就是基准位
temp = arr[low];
while (i<j) {
//先看右边,依次往左递减
while (temp<=arr[j]&&i<j) {
j--;
}
//再看左边,依次往右递增
while (temp>=arr[i]&&i<j) {
i++;
}
//如果满足条件则交换
if (i<j) {
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
//最后将基准为与i和j相等位置的数字交换
arr[low] = arr[i];
arr[i] = temp;
//递归调用左半数组
quickSort(arr, low, j-1);
//递归调用右半数组
quickSort(arr, j+1, high);
}
public static void quickSort2(int[] arr,int low,int high){
int i,j,temp,t;
if(low>high){
return;
}
i=low;
j=high;
//temp就是基准位
temp = arr[(low+high)/2];
while (i<j) {
//先看右边,依次往左递减
while (temp<=arr[j]&&i<j) {
j--;
}
//再看左边,依次往右递增
while (temp>=arr[i]&&i<j) {
i++;
}
//如果满足条件则交换
if (i<j) {
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
//最后将基准为与i和j相等位置的数字交换
// arr[low] = arr[i];
// arr[i] = temp;
//递归调用左半数组
quickSort(arr, low, j-1);
//递归调用右半数组
quickSort(arr, j+1, high);
}
public static void main(String[] args){
int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
quickSort(arr, 0, arr.length-1);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
int[] arr2 = {10,7,2,4,7,62,3,4,2,1,8,9,19};
quickSort2(arr2, 0, arr2.length-1);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr2[i]+" ");
}
}
}
public static <AnyType extends Comparable<? super AnyType>>
void insertionSort(AnyType[] arr) {
int len = arr.length;
int i;
int j;
for (i = 1; i < len; i++) {
AnyType temp = arr[i];
for (j = i; j > 0 && temp.compareTo(arr[j - 1]) < 0; j--) {
arr[j] = arr[j - 1];
}
arr[j] = temp;
}
}
public static <AnyType extends Comparable<? super AnyType>>
void quickSort(AnyType[] arr) {
quickSort(arr, 0, arr.length - 1);
}
private static <AnyType extends Comparable<? super AnyType>>
void quickSort(AnyType[] a, int left, int right) {
if (left == right) {
return;
}
if (left + CUTOFF <= right) {
AnyType pivot = median3(a, left, right);
// Begin partitioning
int i = left, j = right - 1;
for (; ; ) {
while (a[++i].compareTo(pivot) < 0) {
}
while (a[--j].compareTo(pivot) > 0) {
}
if (i < j)
swapReferences(a, i, j);
else
break;
}
swapReferences(a, i, right - 1); // Restore pivot
quickSort(a, left, i - 1); // Sort small elements
quickSort(a, i + 1, right);
} else {
insertionSort(a);
}
}
```