排序(冒泡/快速/归并)

引入

• 排序分类 : 比较类和 非比较类

    [比较类](通过 比较 来决定元素间的 相对次序)  : 快速排序,归并排序,堆排序,冒泡排序等
    [非比较类](通过 确定每个元素之前,应有多少个元素 来排序的) : 计数排序,基数排序,桶排序等
  
    比较类
    	优势 : 适用于各种规模的数据,适用于一切需要排序的情况
    非比较类 
    	优势 : 时间复杂度低O(n) 
    	不足 : 占用空间大,对数据规模和数据分布有一定的要求
  

冒泡排序

• 时间复杂度为 O(n^2)

• 原理

  1. 比较相邻的元素. 如果第一个比第二个大,就交换他们两个.
  2. 依次比较每一对相邻的元素—>结果 : 最后的元素是这组数中最大的
  3. 重复上述步骤 , 除了最后一个[]因为最后一个已经是排好序的了(这组数中最大的那个)]
  4. 持续对越来越少的元素进行如上步骤 , 直到没有任何一对数字需要比较

• 实现结果(以 升序 排列为例)

每次比较两个元素 , 如果这两个元素不是升序的 , 那就交换他们俩
每次冒泡都会将所有剩余元素(无序序列)中最大的那个 , 放到无序序列 最后一个位置上

• 核心代码

public static void bubbleSort(int[] arr) {
		for(int i=0;i<arr.length-1;i++) {
			for(int j=0;j<arr.length-i-1;j++) {	//每次都少排最后一个
				if(arr[j]>arr[j+1]) {	//把大的往后放
					int t = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = t;
				}
			}
		}
	}

选择排序

• 优点 : 不占空间(唯一的好处)—>用选择排序的时候数据规模越小越好

• 原理 : 每次都选择最大(或最小)的 , 然后把这个元素值放到首位或尾端(具体怎么放,看你咋排了)

• 核心代码
  //升序排列

public static int[] selectionSort(int[] arr){
	for(int i=0;i<arr.length-1;i++){
		//标记一个最小data对应的索引
		int minIndex = i;
		//遍历 未排序序列--->最后的minIndex指的就是未排序序列中最小值所对应的那个 索引位置
		for(int j=i+1;j<arr.length;j++){
			if(arr[j] < arr[minIndex]){
				minIndex = j;
			}
		}
		//把i位置的值替换为 未排序序列中最小的data
		if(minIndex != i){
			int temp = arr[i];
			arr[i] = arr[minIndex];
			arr[minIndex] = tmp;
		}
	}
	return arr;
}

插入排序

• 原理 : 打扑克牌时的排序 就是插入排序

快速排序

• 归并排序和快速排序都是基于“分而治之”的算法思想

public static int[] qSort(int arr[],int start,int end){
    int pivot = arr[start];    //一般定义arr数组的首元素为key值
    int i = start;   
    int j = end;
    while(i<j){
        //从左往右找,直到找到一个大于等于key值的
        while(i<j && arr[i]<pivot){
            i++;        
        } 
        //从右往左找，直到找到一个小于等于key值的
        while(i<j && arr[j]>pivot){
            j--;        
        }   
        if(i<j && arr[i]==arr[j]){    //如果两值相等，那么令左侧指针继续向后移
            i++;        
        }else{    //如果两值不同，就交换两值
            int t = arr[i];
            arr[i] = arr[j];
            arr[j] = t;        
        }
    }
    if(i-1>start) arr=qSort(arr,start,i-1);    //递归，将小于key值的那些排序。并将这部分排完序的数组（原数组的一部分）赋值给原数组
    if(j+1<end) arr=qSort(arr,j+1,end);        //递归，将大于key值的那些排序。同上
    return arr;
}

归并排序

• 时间复杂度 ：O(nlogn)
• 速度仅次于快速排序
  归并 就是先将带排序的数组不断拆分，指导拆分到只剩一个元素的时候，这时我们再把他们合并为两个有序的数组，得到长度更长的有序数组。然后，按照这样的思路，一层一层的合并，直到整个数组有序。
• 怎么合并？
  要借助一个和原数组等长的新数组（这也是个典型的 以空间换时间的 做法）
  
  

// import java.util.Arrays;

public class Main{
    public static void main(String[] args){
        int[] arr = {1,4,3,7,14,6,10};
        // System.out.println(Arrays.toString(arr));
        sortArray(arr);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }

//归并排序的入口
    public static int[] sortArray(int[] arr){
        //定义一个辅助数组temp
        int[] temp = new int[arr.length];
        //进行归并排序
        mergeSort(arr,0,arr.length-1,temp);
        //返回排好序的原数组
        return arr;
    }

//归并排序

//实现归并的'分'
    public static void mergeSort(int[] arr,int left,int right,int[] temp){
        //如果只有一个元素，就不需要继续划分（只有一个元素的区间，本来就是有序的）
        // if(left == right) return;
        //当left < right 说明该区间是由一组数组成，需要继续划分
        if(left < right){
            int mid = (left+right)/2;   //这段区间的中值，用来划分左右区域
            mergeSort(arr, left, mid, temp);    //递归划分左半区
            mergeSort(arr, mid+1, right, temp); //递归划分右半区
            //合并已经排序的部分（左半区和右半区）（从只有一个元素的区间开始）
            merge(arr,left,mid,right,temp);
        }
    }
//实现归并的'合'
//arr是原数组；left是左半区的起始位置；mid是左半区的结束位置；right是右半区的结束位置；temp是辅助数组
    public static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;   //左半区的起始位置
        int j = mid+1;  //右半区的起始位置
        int k = left; //辅助数组的位置索引

        //合并
        //在左半区的位置索引范围内，和右半区的位置索引范围内，比较左右半区对应索引位置得的数值的大小，小的先放入temp数组中
        while(i<=mid && j<=right){
            //用三元运算符 更简洁 和下面的if else语句一个意思
            temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];
            /*
            if(arr[i]<arr[j])   //左半区剩余第一个元素更小
                temp[k++] = arr[i++];   //意思是：先让temp[h] = arr[i]；再让k++，i++；
            else                //右半区剩余第一个元素更小
                temp[k++] = arr[j++];
            */
        }

        //合并剩余元素（当其中一个半区的位置索引结束时，另一个半区可能还有剩余有序的元素--》直接合并到temp数组中即可）
        //合并左半区剩余元素
        while(i <= mid)
            temp[k++] = arr[i++];
        while(j <= right)
            temp[k++] = arr[j++];
        
        //temp数组 复制回 arr数组
        // for(int q=0;q<temp.length;q++){
            // arr[q] = temp[q];
        // }
        while(left <= right){
            arr[left] = temp[left];
            left++;
        }
    }
}