package test;
import java.util.ArrayList;
import java.util.Arrays;
public class Test4 {
/**
* 插入排序
* 时间复杂度O(n^2)
* 空间复杂度O(1)
* 稳定排序
* 最好O(n),最坏O(n^2)
*/
static void insertSolve(int[] arr){
for(int i=0;i<arr.length;i++){
int temp = arr[i];
for(int j=i-1;j>=0;j--){//往前找
if(arr[j]>=temp){
arr[j+1] = arr[j];
}else{
arr[j+1] = temp;
break;
}
}
}
}
/**
* 折半插入排序
* 时间复杂度O(n^2)
* 空间复杂度O(1)
* 稳定排序
* 最好O(n),最坏O(n^2)
*/
static void insertSolve2(int[] arr){
for(int i=0;i<arr.length;i++){
int temp = arr[i];
int low = 0;
int high = i-1;
while(low<=high){
int mid = (low+high)/2;
if(temp<arr[mid]){
high = mid-1;
}else{
low = mid+1;
}
}
for(int j=i-1;j>high;j--){
arr[j+1] = arr[j];
}
arr[high+1] = temp;
}
}
/**
* 希尔排序
* @param n 增值
* 时间复杂度O(n^1.3)
* 空间复杂度O(1)
* 不稳定排序
*/
static void shell(int[] arr,int n){
int len = arr.length;
while(n>0){
for(int i=n;i<len;i++){
int temp = arr[i];
int j = i-n;
while(j>=0 && arr[j]>temp){
arr[j+n] = arr[j];
j -= n;
}
arr[j+n] = temp;
}
n = n/2;
System.out.println(n);
}
}
/**
* 选择排序
= * 时间复杂度O(n^2)
* 空间复杂度O(1)
* 不稳定排序
* 最好O(n^2),最坏O(n^2)
*/
static void selectSort(int[] arr){
int len = arr.length;
for(int i=0;i<len-1;i++){
int min = i;
for(int j=i+1;j<len;j++){
if(arr[j]<arr[min]){
min = j;
}
}
if(min!=i){
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}
/**
* 把low到high调节成堆
* @param arr
* @param low
* @param high
*/
static void sift(int[] arr,int low,int high){
int i = low;
int j = 2*i;
int temp = arr[i];
while(j<=high){
if(j<high && arr[j]<arr[j+1]){
j++;
}
if(temp<arr[j]){
arr[i] = arr[j];
i = j;
j = 2*i;
}else{
break;
}
}
arr[i] = temp;
}
/**
* 堆排序
* 时间复杂度O(nlogN)
* 空间复杂度O(1)
* 不稳定排序
* 最好O(nlogN),最坏O(nlogN)
*/
static void headSort(int[] arr){
int len = arr.length;
int i = 0;
for(i=len/2;i>=1;i--){
sift(arr,i,len-1);
}
for(i=len-1;i>=2;i--){
int temp = arr[i];
arr[i] = arr[1];
arr[1] = temp;
sift(arr,1,i-1);
}
}
/**
* 冒泡排序
* 时间复杂度O(n^2)
* 空间复杂度O(1)
* 稳定排序
* 最好O(n),最坏O(n^2)
*/
static void bubbleSort(int[] arr){
for(int i=0;i<arr.length;i++){
boolean flag = false;
for(int j=1;j<arr.length-i;j++){
if(arr[j]<arr[j-1]){
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
flag = true;
}
}
if(flag){
return;
}
}
}
/**
* 把元素按标志位左右分配
* @param arr
* @param low
* @param high
* @return
*/
static int partition(int[] arr,int low,int high){
int flag = arr[low];
while(low<high){
while(low<high && arr[high]>=flag){
high--;
}
arr[low] = arr[high];
while(low<high && arr[low]<=flag){
low++;
}
arr[high] = arr[low];
}
arr[low] = flag;
return low;
}
/**
* 快速排序
* 时间复杂度O(nlogN)
* 空间复杂度O(1)
* 不稳定排序
* 最好O(nlogN),最坏O(n^2)
*/
static void quickSort(int[] arr,int low,int high){
if(low<high){
int mid = partition(arr, low, high);
quickSort(arr, low, mid-1);
quickSort(arr, mid+1, high);
}
}
/**
* 快速排序(非递归解法)
* 时间复杂度O(nlogN)
* 空间复杂度O(logN)
* 不稳定排序
* 最好O(nlogN),最坏O(n^2)
*/
static void quickSort2(int[] arr){
int n = arr.length-1;
int max = 100;
int flag = 0;
int[] start = new int[max];
int[] end = new int[max];
int top = 0;
start[top] = 0;
end[top] = n;
while(top>-1){
int i = start[top];
int j = end[top];
int low = start[top];
int high = end[top];
top--;
if(low<high){
flag = arr[low];
while(low<high){
while(low<high && arr[high]>=flag){
high--;
}
arr[low] = arr[high];
while(low<high && arr[low]<=flag){
low++;
}
arr[high] = arr[low];
}
arr[low] = flag;
top++;
start[top] = i;end[top] = low-1;
top++;
start[top] = low+1;end[top] = j;
}
}
}
/**
* 归并排序
* 时间复杂度O(nlogN)
* 空间复杂度O(n)
* 稳定排序
* 最好O(nlogN),最坏O(nlogN)
*/
static void MergeSort(int[] arr,int start,int end){
if(end==start) return;//如果要排序的只有一个数,直接返回
int mid = (end+start)/2;//把数组分成两部分,这里不一定是平均分,但没有影响
MergeSort(arr,start,mid);//左部分排序
MergeSort(arr,mid+1,end);//右部分排序
int len = end-start+1;//数组长度
int[] arr2 = new int[len];//申请一个相同大小的数组,作为暂存
int num = 0,i=start,j=mid+1;
for(;i<=mid && j<=end;){//直到某个数组完全分配好
if(arr[i] < arr[j]){//比较大小,按大小存入暂存数组
arr2[num] = arr[i];
i++;
}else{
arr2[num] = arr[j];
j++;
}
num++;
}
//分配剩余数组,直接按顺序复制就可以了
for(;i<=mid;i++){
arr2[num++] = arr[i];
}
for(;j<=end;j++){
arr2[num++] = arr[j];
}
for(int i1=start;i1<end+1;i1++){
arr[i1] = arr2[i1-start];
}
arr2 = null;//清空方便回收
}
/**
* 获得某数的某一位
* @param num
* @param pos
* @return
*/
static int GetNumInPos(int num,int pos) {
int temp = 1;
for (int i = 0; i < pos - 1; i++)
temp *= 10;
return (num / temp) % 10;
}
/**
* 基数排序
* 时间复杂度O(n+r)
* 空间复杂度O(n+r)
* 稳定排序
* 最好O(n+r),最坏O(n+r)
*/
static void radixSort(int[] arr){
int len = arr.length;
ArrayList<ArrayList<Integer>> radixArrays = new ArrayList<ArrayList<Integer>>();
for(int i=0;i<10;i++){
radixArrays.add(new ArrayList<Integer>());
}
int max = 31;//最大位数
for(int i=0;i<=31;i++){
for(int j=0;j<len;j++){//分配
radixArrays.get(GetNumInPos(arr[j], i+1)).add(arr[j]);
}
int index = 0;
for(int j=0;j<10;j++){//收集
for(Integer integer:radixArrays.get(j)){
arr[index] = integer;
index++;
}
radixArrays.get(j).clear();
}
}
}
public static void main(String[] args) {
int[] arr = new int[]{1,3,5,2,7,4,76,34,12};
radixSort(arr);
System.out.println(Arrays.toString(arr));
}
}
常见排序java实现
最新推荐文章于 2024-04-30 23:29:02 发布