排序（冒泡、选择、插入、快速、归并）

排序

今天把之前写的排序整理了一下，之前写的有点乱，现在把这些整合在一起，后续在接触到别的排序算法会继续在这篇博文上添加。

排序算法一：冒泡排序

public static void bubbleSort() {//冒泡
		int []array ={1,8,4,6,2,3};
		for(int i=0;i<array.length;i++){
			for(int j = 0;j<array.length-i-1;j++){
				if(array[j]>array[j+1]){
					int temp =array[j];
					array[j] =array[j+1];
					array[j+1] =temp;	
				}
			}
		}
		for(int tem :array){
			System.out.println(tem);
		}
	}

排序算法二：选择排序

public static void selectSort() {
		int []array ={1,8,4,6,2,3};
		for(int i=0;i<array.length-1;i++){
			int min = i;//定义当前数的索引为最小值的索引
			for(int j=i+1;j<array.length;j++){
				if(array[min]>array[j]){
					min = j;//经过一轮的比较，找到当前最小值的索引
				}
			}
			if(i!=min){//如果最小值的索引不是当前数的索引，就让这两个索引处的值进行交换，找到最小值。
				int temp =array[min];
				array[min] = array[i];
				array[i]=temp;
			}
		}
		for(int tem :array){
			System.out.println(tem);
		}
	}

排序算法三：插入排序

public static void insertSort() {
		int []array ={1,8,4,6,2,3};
		for(int i =0;i<array.length-1;i++){//一共进行n-1趟
			for(int j=i+1;j>0;j--){
				if(array[j]<array[j-1]){
					int temp =array[j];
					array[j] =array[j-1];
					array[j-1]=temp;
				}else{
					break;//如果当前索引处数据比它前一个数据大，就不用了和再和它之前的数比了。
				}
			}
		}
		for(int tem :array){
			System.out.println(tem);
		}
	}

排序算法四：快速排序

 public static void main(String[] args) {
    	int []array ={1,8,4,6,2,3};
        quicksort(array,0,array.length-1);
        for(int s:array){
            System.out.print(s + " ");
        }
    }
    public static void quicksort( int[] array,int left,int right) {
        int i = left;
        int j = right;
        if(i>j){
            return;
        }
        int temp = array[left];//基准数
        int t;//进行交换的中介
            while (i < j) {
                //先找右边
                while (j > i && array[j] >= temp) {//如果右边的数大于基准数，就跳过，直到找到一个比基准数小的数
                    j--;
                }
                //再找左边
                while (j > i && array[i] <= temp) {//如果左边的数小于基准数，就跳过，直到找到一个比基准数大的数
                    i++;
                }
                if (j > i) {  //在左边找到一个大于基准数的数，在右边找到一个小于基准数的数，然后将这两个数进行交换
                    t = array[j];
                    array[j] = array[i];
                    array[i] = t;
                }
            }
            //把当前的下标值（i和j相等）和基准值交换完成一轮交换
            array[left] = array[i];
            array[i] = temp;
            quicksort(array, left, j - 1);//递归调用，遍历左边那一部分,执行上面的操作，直到左边顺序排好
            quicksort(array, j + 1, right);//递归调用，遍历右边那一部分，执行上面的操作，排好右边
        }

排序算法五：归并排序

public static void main(String[] args) {
		int[] array =new int[]{1,8,4,6,2,3}; 
		sort(array,0,array.length-1);
		for(int tem : array){
			System.out.println(tem);
		}
	}
	public static void sort(int[] array,int low,int high){
		if(low<high){
			int mid = (low+high)/2;
			sort(array,low,mid);//对左边部分进行排序
			sort(array,mid+1,high);//对右边部分进行排序
			mgSort(array,low,mid,high);
		}
	}
	public static void mgSort(int[] array,int low,int mid,int high){
		int i =low;
		int j =mid+1;
		int k =low;
		int[] num = new int[array.length];
		while(i<=mid&&j<=high){
			if(array[i]<array[j]){
				num[k++] = array[i++];
			}
			if(array[i]>array[j]){
				num[k++] = array[j++];
			}
		}
		while(i<=mid){
			num[k++]=array[i++];
		}
		while(j<=high){
			num[k++]=array[j++];
		}
		for(int s=low;s<=high;s++){
			array[s]=num[s];
		}
	}