快排，冒泡排，选择排序，希尔排序

Posted 2020-08-03 折腾青春

package cn.hncu.dataStruct;

public class SortMethods {

/*
算法好坏的评价指标(一般只在n值非常大的时候才会考虑，如n取10万)：
* 1、时间复杂度: 通俗点，就是指程序运行的快慢(时间)---通常用计算机的运算(算术，赋值)次数来代替
* 2、空间复杂度: 占用内存空间的大小---通常用程序中使用了多少变量(栈内存、堆内存)，这些变量总共占了多少内存
*/

public static void main(String[] args) {
int a[] = {1,7,0,10,8,23,-3,34,102, 21,25,49,25,16,8};
//int a[] = {21,25,49,25,16,8,-1,45,230,22};
//1 冒泡排序
//1.1普通冒泡
//bubbleSort(a);
//1.2带优化的冒泡
//bubbleSort2(a);

//2 选择排序
//2.1类似思想但性能不好--排手机
//selectSort0(a);

//2.2真正的选择排序
//selectSort(a);

//3 插入排序
//3.1 简单插入排序
//insertSort(a);

//3.2 加入二分查找的插入排序 //※※※注意：二分的前提是有序
//binaryInserSort(a);

//4 希尔排序
//shellSort(a); //

//5.1 普通快速排序
//quickSort(a,0,a.length-1);//把数组a中 0~a.length-1范围内的元素 进行排序

//5.1 优化后的快速排序
//quickSort2(a,0,a.length-1);//把数组a中 0~a.length-1范围内的元素 进行排序

//6 归并排序
mergeSort(a,0,a.length-1);


print(a);
}

//归并排普通序列
private static void mergeSort(int[] a, int left, int right) {
if (left<right) {//至少有2个元素，才会分解----如果没有这句，会出现栈溢出错误: StackOverflowError
//先分解
int mid = (left + right) / 2;//二分
mergeSort(a, left, mid);
mergeSort(a, mid + 1, right);
//再归并
int b[] = new int[a.length];
merge(a, b, left, mid, right);//把当前分解层次的两个子序列合并到数组b中的对应位置
copyArray(a, b, left, right);//把辅助序列b中的数据拷回到a中
}
}

private static void copyArray(int[] a, int[] b, int left, int right) {
for(int i=left;i<=right;i++){
a[i] = b[i];
}
}

//归并:把两个有序子序列合并成一个
private static void merge(int[] a, int[] b, int left, int mid, int right) {
//合并a[left:mid]和a[mid+1:right] 到 b[left:right]
int p=left;//遍历子序列a[left:mid]的游标
int r=mid+1;//遍历子序列a[mid+1:right]的游标
int k=left; //合并结果序列 b[left:right]的游标
while(p<=mid && r<=right){
if(a[p]<a[r]){
b[k++]=a[p++];
}else{
b[k++]=a[r++];
}
}
//经过上面的循环，其中一个序列的元素已经排完。那么，另一个子序列中剩下的元素直接照搬到b[]中就ok了
if(p>mid){//左序列排完，，照搬右序列
for(int i=r;i<=right;i++){
b[k++] = a[i];
}
}else{//右序列排完，，照搬左序列
for(int i=p;i<=mid;i++){
b[k++] = a[i];
}
}
}

//5.2 优化后的快速排序
private static void quickSort2(int[] a, int p, int r) {
if(p<r){
//思路：把数组a划分成两个子区间和一个元素：a[p:q-1], a[q], a[q+1:r]
int q = patition2(a,p,r);//经过该划分函数，数组就变成：a[p:q-1], a[q], a[q+1:r]----其中a[q]位置已经排好
quickSort2(a,p,q-1);//继续排左子区间
quickSort2(a,q+1,r);//继续排右子区间
}
}
private static int patition2(int[] a, int p, int r) {
//优化:采用随机选择策略确定枢轴
int rand =p+ (int)( Math.random()*(r-p));
swap(a,p,rand);//把rand位置的元素换到p位置，然后把p位置的元素当作枢轴

int i=p;
int j=r+1;
int x=a[p];//枢轴保存在变量x中
while(true){
while(a[++i]<x && i<r);//这个循环之后，a[i]就是左区中一个大于x的元素
while(a[--j]>x);//这个循环之后，a[j]就是右区中一个小于x的元素
if(i>=j){
break;
}
swap(a,i,j);//把a[i]和a[j]交换一下
}
//把枢轴(目前在第p的位置) 交换到 j 的位置
swap(a,p,j);

return j;
}

//////////////////////////////////////////////////////////
//5.1 普通快速排序
private static void quickSort(int[] a, int p, int r) {
if(p<r){
//思路：把数组a划分成两个子区间和一个元素：a[p:q-1], a[q], a[q+1:r]
int q = patition(a,p,r);//经过该划分函数，数组就变成：a[p:q-1], a[q], a[q+1:r]----其中a[q]位置已经排好
quickSort(a,p,q-1);//继续排左子区间
quickSort(a,q+1,r);//继续排右子区间
}
}
private static int patition(int[] a, int p, int r) {
int i=p;
int j=r+1;
int x=a[p];//枢轴保存在变量x中
while(true){
while(a[++i]<x && i<r);//这个循环之后，a[i]就是左区中一个大于x的元素
while(a[--j]>x);//这个循环之后，a[j]就是右区中一个小于x的元素
if(i>=j){
break;
}
swap(a,i,j);//把a[i]和a[j]交换一下
}
//把枢轴(目前在第p的位置) 交换到 j 的位置
swap(a,p,j);

return j;
}

//4 希尔排序 --为便于大家理解，组内排序算法用冒泡
private static void shellSort(int[] a) {
//分组
for(int gap=(a.length+1)/2; gap>0; ){
//组内排序---冒泡
for(int i=0;i<a.length-gap;i++){
for(int j=i;j<a.length-gap;j+=gap){
if(a[j]>a[j+gap]){
swap(a,j,j+gap);
}
}
}

//循环变量的修正
if(gap>1){
gap = (gap+1)/2;
}else{
break;
}
}
}

//3.2 加入二分查找的插入排序
private static void binaryInserSort(int[] a) {
for(int i=0;i<a.length-1; i++){//趟数,每一趟是插入第"i+1"个数
//待插入的数
int temp = a[i+1];

//用二分来决定待插入的位置
int low=0;
int high=i;
int mid;//中间位置
while(low<=high){
mid = (low+high)/2;
//用中间位置的元素和当前待插入的数(temp)比较
if(a[mid]>temp ){ //落在左半区
high = mid-1;
}else{//落在右半区
low = mid+1;
}
}
//上面这一段只是找到插入位置

//移位，把待插入位置腾出来
for(int j=i; j>high; j--){
a[j+1] = a[j];
}

//让temp坐在第high+1的位置
a[high+1] = temp;//a[low] = temp;
}
}

//3.1 简单插入排序
private static void insertSort(int[] a) {
//依次把每元素拿来插入到有序序列当中(从第2个开始，到最后就行)
for(int i=0;i<a.length-1;i++){//趟数
//待插入的数
int temp = a[i+1];

//下面这一段其实是决定temp坐的位置(j+1) 及 让其它比temp大的数挪动一个位置
int j=i;
while(a[j]>temp){//如果有序序列中"第j位置的数" 比 "待插入的数" 大，则把 a[j]往后挪一个位置
a[j+1] = a[j];//让a[j]挪到j+1的位置
j--;
if(j<0){
break;
}
}

//让temp坐在第j个数的后面即 j+1的位置
a[j+1] = temp;
}

}

//2.1类似思想但性能不好的选择排序 ---排手机
private static void selectSort0(int[] a) {
for(int i=0; i<a.length-1; i++){//趟数
for(int j=i+1; j<a.length; j++){
if(a[i]>a[j]){
swap(a,i,j);
}
}
}
}

//2.2 选择排序
private static void selectSort(int[] a) {
for(int i=0; i<a.length-1; i++){//趟数--n-1
int k = i;//*
for(int j=i+1; j<a.length; j++){
if(a[k]>a[j]){//* a[i]-->a[k]
k=j;//*
}
}

//* 经过上面的循环，第k个元素一定是当前(从第i个开始到最后这些元素中)最小的
if(i!=k){
swap(a,i,k);
}
}
}


//1.2 冒泡排序(优化)---只要发现有一趟走下来没有一次交换，那么就认为已经排好序，后续的趟数不需要走了
public static void bubbleSort2( int[] a){
for(int i=0;i<a.length-1;i++ ){
boolean isOk= true;
for( int j=0;j<a.length-i-1;j++){
if(a[j]>a[j+1]){
swap(a,j,j+1);
isOk = false;
}
}
if(isOk){
break;
}
}
}
//1.1 冒泡排序
public static void bubbleSort( int[] a){
for(int i=0;i<a.length-1;i++ ){//趟数：n-1
for( int j=0;j<a.length-i-1;j++){//让第j个和第j+1个数进行比较，违反需求则交换。j:0～n-i-1
if(a[j]>a[j+1]){
swap(a,j,j+1);
}
}
}
}

public static void print( int[] a){
for(int num: a){
System.out.print(num+"\t");
}
System.out.println();
}
public static void swap(int[]a,int i,int j){
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}

}