一 插入排序
时间复杂度 O（n^2）
空间复杂度O（1）
稳定性：稳定
//插入排序
public static void inSort(int[] arr){
for (int i = 0; i < arr.length; i++) {
int tmp=arr[i];
int j = i+1;
for (; j >=0 ; j--) {
if (arr[j]<tmp){
arr[j+1]=arr[j];
}else {
break;
}
}
arr[j+1]=tmp;
}
}
二 希尔排序
时间复杂度 O（n^1.3 --- n^1.5）
空间复杂度O（1）
稳定性：不稳定
public static void shell(int[]arr,int gap){
for (int i = 0; i < arr.length ; i++) {
int j=i-gap;
int tmp=arr[i];
for (; j >=0 ; j-=gap) {
if (tmp<arr[j]){
arr[j+gap]=arr[j];
}else {
break;
}
}
arr[j+ gap]=tmp;
}
}
public static void shellSort(int[]arr){
int gap= arr.length;
if (gap>1){
shell(arr,gap);
gap/=2;
}
shell(arr,1);
}
三 选择排序（两种方法）
时间复杂度 O（n^2）
空间复杂度O（1）
稳定性：不稳定
//选择排序
public static void choice(int[] arr){
for (int i = 0; i < arr.length ; i++) {
int j =i+1;
for (; j < arr.length; j++) {
if (arr[i]>arr[j]){
int tmp=arr[i];
arr[i]=arr[j];
arr[j]=tmp;
}
}
}
}
public static void choice1(int[] arr){
for (int i = 0; i < arr.length; i++) {
int minindex=0;
for (int j = 0; j < arr.length ; j++) {
if (arr[j]<arr[minindex]){
minindex=j;
}
}
swap(i,minindex,arr); //交换
}
}
四 堆排序
时间复杂度 O（n*logn）
空间复杂度O（1）
稳定性：不稳定
/堆排序
public static void haepSort(int[] arr){
//建堆
createHeap(arr);
int end= arr.length-1;
//交换然后调整
while (end>0){
swap(0,end,arr);
shiftDown(arr,0,end);
end--;
}
}
public static void createHeap(int[] array){
for (int parent = (array.length-1-1)/2; parent >=0 ; parent--) {
shiftDown(array,parent,array.length);
}
}
public static void shiftDown(int[] arr,int parent,int len){
int child=2*parent+1; //左孩子下标
while (child<len){
if (child+1<len && arr[child]<arr[child+1]){
child++; //child下标是左右孩子最大值的下标
}
if (arr[child]>arr[parent]){
swap(child,parent,arr);
parent=child;
child=2*parent+1;
}else {
break;
}
}
}
public static void swap(int i,int j,int[]arr){
int tmp=arr[i];
arr[i]=arr[j];
arr[j]=tmp;
}
五 冒泡排序
时间复杂度 O（n*logn）
空间复杂度O（1）
稳定性：不稳定
public static void bublSort(int[] arr){
for (int i = 0; i < arr.length-1 ; i++) {
boolean tmp =false;
for (int j = 0; j < arr.length-1-i ; j++) {
if (arr[j+1]<arr[j]){
swap(j,j+1,arr);
tmp=true;
}
}
if (tmp=false){
break;
}
}
}
六 快速排序
时间复杂度 最好 O（n*logn） 最坏 O(n^2)
空间复杂度 最好O（logn） 最坏 O(n)
稳定性：不稳定
public static void quickSort(int[] arr){
quick(arr,0, arr.length-1);
}
public static void quick(int[] arr,int left,int right){
if (left>=right){
return;
}
int pivot =partition(arr, left, right);
quick(arr,left,pivot-1);
quick(arr,pivot+1,right);
}
public static int partition(int[] arr,int left,int right){
int tmp=arr[left];
while (left<right){
while (left<right && tmp<=arr[right]){
right--;
}
arr[left]=arr[right];
while ((left<right && tmp>= arr[left])){
left++;
}
arr[right]=arr[left];
}
arr[left]=tmp;
return tmp;
}
标签：arr,int,复杂度,length,static,排序,public From： https://www.cnblogs.com/lbwboke/p/16664581.html