java实现多种分类_java 实现多种排序

public class Sort {

//交换两个数

private void swap(int[] arr, int i,int j){

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

//普通版冒泡排序,时间复杂度为O(n^2),稳定的排序算法

public void bubbleSort(int[] arr){

for(int i=0;i

for(int j=arr.length-2;j>=i;j--){

if(arr[j] > arr[j+1])

swap(arr, j, j+1);

}

}

}

//改进版的冒泡排序

public void bubble2Sort(int[] arr){

boolean flag = true;

for(int i=0;i

flag = false;

for(int j=arr.length-2;j>=i;j--){

if(arr[j] > arr[j+1]){

swap(arr, j, j+1);

flag = true;

}

}

}

}

//简单选择排序,时间复杂度为O(n^2),稳定的排序算法，性能上优于冒泡，移动次数少，最多移动n-1次

public void selectSort(int[] arr){

int min;

for(int i=0;i

min = i;

for(int j=i+1;j

if(arr[min] > arr[j])

min = j;

}

if(min != i)

swap(arr,i,min);

}

}

//直接插入排序，稳定的排序算法，比较、移动的时间复杂度为O(n^2)

public void insertSort(int[] arr){

for(int i=1;i

int temp = arr[i];

int j;

for(j=i-1;j>=0&&arr[j]>temp;j--)

arr[j+1] = arr[j];

arr[j+1] = temp;

}

}

//双点直接插入排序，稳定的排序算法,不是从开始进行的排序

public void insertSort2(int[] arr,int left, int right){

for(int i=left;++left<=right;i=++left){

int a1 = arr[i];

int a2 = arr[left];

if(a1

a2 = a1;

a1 = arr[left];

}

while(a1 < arr[--i]){

arr[i+2] = arr[i];

}

arr[++i + 1] = a1;

while(a2 < arr[--i]){

arr[i+1] = arr[i];

}

arr[i+1] = a2;

}

int last = arr[right];

while(last < arr[--right])

arr[right+1] = arr[right];

arr[right+1] = last;

}

//希尔排序，不是稳定的排序算法，是对插入排序的升级版，最好可以达到O(n^(3/2)),不好可以是O(n^2)

public void shellSort(int[] arr){

for(int gap=arr.length/2;gap>0;gap /= 2){

for(int i=0;i

for(int j=i+gap;j

if(arr[j]

int temp = arr[j];

int k = j - gap;

while(k>=0 && arr[k]>temp){

arr[k+gap] = arr[k];

k -= gap;

}

arr[k+gap] = temp;

}

}

}

}

}

//堆排序，时间复杂度为O(nlogn)，不适合待排列个数较少的情况

public void heapSortAsc(int[] arr){

for(int i=arr.length/2-1;i>=0;i--){

heapAdjust(arr,i,arr.length-1);

}

for(int i=arr.length-1;i>0;i--){

int temp = arr[0];

arr[0] = arr[i];

arr[i] = temp;

heapAdjust(arr,0,i-1);

}

}

//建堆与调整堆的过程

private void heapAdjust(int[] arr, int start, int end){

int c = start;

int lChild = 2 * c + 1;

int temp = arr[c];

for(; lChild <= end; c = lChild, lChild = 2 * lChild + 1){

if(lChild < end && arr[lChild] < arr[lChild + 1])

lChild++;

if(arr[lChild] < temp){

break;

}

else{

arr[c] = arr[lChild];

arr[lChild] = temp;

}

}

}

//归并排序，稳定的排序方法，比较占内存，时间复杂度为O(nlogn)

//归并排序分为两个部分，分解与合并，从上往下的排序

public void mergeSortUp2Down(int[] arr, int start, int end){

if(arr == null || start >= end)

return;

int mid = (start + end) / 2;

mergeSortUp2Down(arr,start,mid);

mergeSortUp2Down(arr, mid+1, end);

merge(arr,start,mid,end);

}

//归并排序的合并部分

public void merge(int[] arr, int start, int mid, int end){

int i = start;

int j = mid + 1;

int k = 0;

int[] temp = new int[end-start+1];

while(i<=mid && j <= end){

if(arr[i] <= arr[j])

temp[k++] = arr[i++];

else

temp[k++] = arr[j++];

}

while(i <= mid)

temp[k++] = arr[i++];

while(j <= end)

temp[k++] = arr[j++];

for(i=0;i

arr[start+i] = temp[i];

}

}

//从下往上的排序，

public void mergeSortDown2Up(int[] arr){

if(arr == null)

return;

for(int i=1;i

mergeGroups(arr, arr.length,i);

}

//对数组进行若干次排序

public void mergeGroups(int[] arr, int len, int gap){

int i;

for(i=0;i+2*gap-1

merge(arr,i,i+gap-1,i+2*gap-1);

}

if(i+gap-1

merge(arr,i,i+gap-1,len-1);

}

//快速排序，不稳定的排序算法，时间复杂度为O(nlogn)

public void quickSort(int[] arr, int low, int high){

int pivot;

if(low < high){

pivot = partition(arr,low,high);

quickSort(arr,low,pivot-1);

quickSort(arr,pivot+1,high);

}

}

//快速排序，进行位置交换

private int partition(int[] arr, int low, int high){

int pivot = arr[low];

while(low < high){

while(low < high && arr[high] >= pivot)

high--;

swap(arr,low,high);

while(low < high && arr[low] <= pivot)

low++;

swap(arr,low,high);

}

return low;

}

//双基准的快速排序算法

private void quickSort2(int[] arr, int lowIndex, int highIndex) {

if(lowIndex >= highIndex) return;

int pivot1 = arr[lowIndex];

int pivot2 = arr[highIndex];

if(pivot1 > pivot2){

arr[lowIndex] = pivot2;

arr[highIndex] = pivot1;

pivot1 = arr[lowIndex];

pivot2 = arr[highIndex];

}else if(pivot1 == pivot2){

while(pivot1 == pivot2 && lowIndex <= highIndex){

pivot1 = arr[++lowIndex];

}

}

int i = lowIndex + 1;

int lt = lowIndex + 1;

int gt = highIndex - 1;

while(i<=gt){

if(pivot1 > arr[i]){

swap(arr,lt++,i++);

}else if(pivot2 < arr[i]){

swap(arr,i,gt--);

}else{

i++;

}

}

swap(arr,lowIndex,--lt);

swap(arr,highIndex,++gt);

quickSort2(arr,lowIndex,lt-1);

quickSort2(arr,lt+1,gt-1);

quickSort2(arr,gt+1,highIndex);

}

//桶排序

public void bucketSort(int[] arr, int max){

if(arr == null || max < 1) return ;

int[] buckets = new int[max];

for(int i=0;i

buckets[arr[i]]++;

for(int i=0, j=0;i

while((buckets[i]--)>0)

arr[j++] = i;

}

//计数排序，稳定的排序算法，桶排序另一种，时间复杂度为O(n)

public void countSort(int[] arr, int max){

int[] result = new int[arr.length];

int[] temp = new int[max];

for(int i=0;i

temp[arr[i]]++;

}

for(int i=1;i

temp[i] += temp[i-1];

}

for(int i=0;i

temp[i] -= 1;

for(int i=arr.length-1;i>=0;i--){

result[temp[arr[i]]--] = arr[i];

}

System.arraycopy(result, 0, arr, 0, arr.length);

}

//基数排序，桶排序的升级版，利用计数排序来做

public void radixSort(int[] arr, int max){

for(int exp=1;max/exp>0;exp *= 10){

countSort1(arr,exp);

}

}

//基数排序调用计数排序

public void countSort1(int[] arr, int exp){

int[] temp = new int[10];

int[] result = new int[arr.length];

for(int i=0;i

temp[arr[i]]++;

for(int i=1;i<10;i++)

temp[i] += temp[i-1];

for(int i=0;i<10;i++)

temp[i]--;

for(int i=arr.length-1;i>=0;i--)

result[temp[arr[i]]--] = arr[i];

System.arraycopy(result, 0, arr, 0, arr.length);

}

public static void main(String[] args) {

Sort sort = new Sort();

int[] arr = {1,6,3,5,3,2,4,5,1,6};

sort.radixSort(arr,7);

for(int i=0;i

System.out.print(arr[i] + " ");

}

}

}