简单选择排序，最坏最好平均的时间复杂度都是O(n^2)，排序是稳定的
public class SelectiveSort{
public static void sSort(int[] nums){
if(nums==null||nums.length==0){
return;
}
int min;
for(int i=0;i<nums.length;i++){
min = nums[i];
for(int j=i+1;j<nums.length;j++){
if(nums[j]<min){
min = nums[j];
}
}
//交换min和nums[i]
//swap方法，省略
}
}
public static void main(String[] args){
}
}直接插入排序：最坏时间复杂度O(n^2)，最好时间复杂度O(n)，平均时间复杂度O(n^2)
public class InsertSort{
public static void iSort(int[] nums){
if(nums==null||nums.length<=0){
return;
}
for(int i=0;i<nums.length;i++){
for(int j=i;j>=1;j--){
if(nums[j]<nums[j-1]){
//交换nums[j]、nums[j-1]
//通用swap方法
}
}
}
}
public static void main(String[] args){
}
}冒泡排序及其优化：最坏时间复杂度O(n^2)，最好时间复杂度O(n)，平均时间复杂度O(n^2)
//未优化版
public class BubbleSort{
public static void bSort(int[] nums){
if(nums==null||nums.length<=0){
return;
}
for(int i=0;i<nums.length;i++){ //控制循环次数
for(int j=0;j<nums.length-i-1;i++){
if(nums[j]>nums[j+1]){
//交换
}
}
}
}
public static void main(String[] args){
}
}
//优化版
public class BubbleSort{
public static void bSort(int[] nums){
if(nums==null||nums.length<=0){
return;
}
boolean flag = false;
for(int i=0;i<nums.length;i++){ //控制循环次数
for(int j=0;j<nums.length-i-1;i++){
if(nums[j]>nums[j+1]){
flag = true;
//交换
}
}
if(!flag){
break;
}
}
}
public static void main(String[] args){
}
}快排及其优化：快排是无序效率最高，有序如果形成树单支，效率最低
最坏时间复杂度：O(n^2)，最好O(nlogn)，平均(nlogn)，不稳定的排序，因为后面的可能跑到前边去
//未优化版
public class FastSort{
public static int partition(int[] nums,int start,int end){//int用于返回分割点的下标值
int key = nums[start];
int i=start,j=end;
while(i<=j){
while(i<j&&nums[j]>=key){j--;}
nums[i] = nums[j];
while(i<j&&nums[i]<=key){i++;}
nums[j] = nums[i];
}
nums[j] = key;
return j;
}
public static void qSort(int[] nums,int start,int end){
if(start>=end){
return;
}
int key = partion(nums,start,end);
qSort(nums,start,key-1);
qSort(nums,key+1,end);
}
public static void main(String[] args){
int[] nums = {...};
qSort(nums,0,nums.length-1);
}
}
//优化版
public class FastSort{
public static int partition(int[] nums,int start,int end){//int用于返回分割点的下标值
//多加了个调整顺序
int mid = start + (end - start)/2;
if(start<mid){
//交换
}
if(end<mid){
//交换
}
//这样中间最小，然后比较start和end
if(end<start){
//end中间，调整end到start
}
int key = nums[start];
int i=start,j=end;
while(i<=j){
while(i<j&&nums[j]>=key){j--;}
nums[i] = nums[j];
while(i<j&&nums[i]<=key){i++;}
nums[j] = nums[i];
}
nums[j] = key;
return j;
}
public static void qSort(int[] nums,int start,int end){
if(start>=end){
return;
}
int key = partion(nums,start,end);
qSort(nums,start,key-1);
qSort(nums,key+1,end);
}
public static void main(String[] args){
int[] nums = {...};
qSort(nums,0,nums.length-1);
}
}希尔排序：时间复杂度不确定的排序
最坏时间复杂度：O(n^2) 最好时间复杂度O(n^1.3) 平均时间复杂度O(nlogn-n^2) 稳定性：不稳定的
public class ShellSort{
public static void shellSort(int[] nums){
if(nums==null||nums.length<=0){
return 0;
}
int increment = nums.length/3 + 1;
do{
for(int j=increment;j<=nums.length-1;j++){
for(int i=j;i>=increment;i-=increment){
if(nums[i]>nums[i-increment]){
//交换
}
}
}
increment = increment/3 + 1;
}while(increment>1);
}
public static void main(String[] args){
}
}堆排序：先构建堆，然后再调整
最坏时间复杂度：O(nlogn) 最好时间复杂度：O(nlogn) 平均时间复杂度：O(nlogn) 不稳定的
//堆排序以1开始，0索引元素不考虑 构造大根堆
public class HeapSort{
public static void heapSort(int[] nums,int start,int end){
for(int i=start;i*2<=end;i*=2){
int j=i*2;
if(j<end){
j = nums[j+1]>nums[j]?j+1:j;
}
if(nums[i]<nums[j]){
//交换
}
else{
break;
}
}
}
public static void main(String[] args){
int[] nums = {...};
//构建大根堆
for(int i=(nums.length-1)/2;i>=1;i--){
heapSort(nums,i,nums.length-1);
}
//元素排序
for(int i=nums.length-1;i>1;i--){
//swap nums[1] nums[i]
//交换后重新构造大根堆
heapSort(nums,1,i-1);
}
}
}归并排序递归和非递归版
最坏时间复杂度：O(nlogn) 最好时间复杂度：O(nlogn) 平均时间复杂度：O(nlogn) 稳定的
public class MergeSort{
public static void merge(int[] nums,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(nums[i]<=nums[j]){
temp[k++] = nums[i++];
}
else{
temp[k++] = nums[j++];
}
}
while(i<=mid){
temp[k++] = nums[i++];
}
while(j<=end){
temp[k++] = nums[j++];
}
for(int d=start;d<=end;d++){
nums[d] = temp[d-start];
}
}
public static void mergeSort(int[] nums,int start,int end){
if(start>=end){
return;
}
int mid = (start+end) / 2;
mergeSort(nums,0,mid);
mergeSort(nums,mid+1,end);
merger(nums,start,mid,end);
}
public static void main(String[] args){
int[] nums = {...};
mergeSort(nums,0,nums.length-1);
}
}
//非递归版
public class MergeSort{
public static void merge(int[] nums,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(nums[i]<=nums[j]){
temp[k++] = nums[i++];
}
else{
temp[k++] = nums[j++];
}
}
while(i<=mid){
temp[k++] = nums[i++];
}
while(j<=end){
temp[k++] = nums[j++];
}
for(int d=start;d<=end;d++){
nums[d] = temp[d-start];
}
}
public static void mergeSort(int[] nums,int start,int end){
int len = 1;
while(len<nums.length){
for(int i=0;i+len<nums.length;i=i+len*2){
if(i+len*2-1<nums.length){
merge(nums,i,i+len-1,i+len*2-1);
}
else{
merge(nums,i,i+len-1,nums.length-1);
}
}
len = len * 2;
}
}
public static void main(String[] args){
int[] nums = {...};
mergeSort(nums,0,nums.length-1);
}
}