常见的排序（java）

1.冒泡排序

说明：相邻元素之间进行比较，坐标小的数比坐标大的数大时，进行交换，每轮都会使这一轮范围内的最大的数放到底部（坐标大的位置）（此算法数据交换频繁）。
示例：

排序前: 6 9 1 4 5 8 7 0 2 3
第 1 趟: 6 1 4 5 8 7 0 2 3 9
第 2 趟: 1 4 5 6 7 0 2 3 8 9
第 3 趟: 1 4 5 6 0 2 3 7 8 9
第 4 趟: 1 4 5 0 2 3 6 7 8 9
第 5 趟: 1 4 0 2 3 5 6 7 8 9
第 6 趟: 1 0 2 3 4 5 6 7 8 9
第 7 趟: 0 1 2 3 4 5 6 7 8 9
排序后: 0 1 2 3 4 5 6 7 8 9

代码：

public static void bubbleSort(int[] numbers) {   
    
    int size=numbers.length;
	for(int i=0;i<size;i++){
		for(int j=0;j<size-i-1;j++){
			if(numbers[j]>numbers[j+1]){
				int temp=0;
				temp=numbers[j];
				numbers[j]=numbers[j+1];
				numbers[j+1]=temp;
				}
			}
		}
	for(int i:numbers){
		System.out.println(i);
		}  
}  

2.选择排序

说明：每一轮从无序高索引中选出最小的一个，让其与之前的元素进行比较（但是不进行交换），等到确定最大数字的索引后，将其与无序高索引进行交换。

public static void selectSort(int[] numbers) {   
    int size = numbers.length, temp;   
    for (int i = 0; i < size; i++) {   
        int k = i;   
        for (int j = size - 1; j >i; j--)  {   
            if ( numbers[k]>numbers[j] )  k = j;   
        }   
        temp = numbers[i];   
        numbers[i] = numbers[k];   
        numbers[k] = temp;   
    }   
}  

3.快速排序

说明：从数组中选择一个数作为基准，数组中比这个数小的放在左边，比这个数大的放在右边，使用递归进行分而治之。

代码：

public static void quickSort(int[] numbers, int start, int end) {   
    if (start < end) {   
        int base = numbers[start]; // 选定的基准值（第一个数值作为基准值）   
        
        int i = start, j = end;   
        do {   
            while ((numbers[i] < base) && (i < end))   
                i++;   
            while ((numbers[j] > base) && (j > start))   
                j--;   
            if (i <= j) {   
            	int temp; // 记录临时中间值   
                temp = numbers[i];   
                numbers[i] = numbers[j];   
                numbers[j] = temp;   
                i++;   
                j--;   
            }   
        } while (i <= j);   
        if (start < j)   
            quickSort(numbers, start, j);   
        if (end > i)   
            quickSort(numbers, i, end);   
    }   
}  

4.插入排序

说明：我们可以认为起初第一个元素是有序的，取出下一个元素，在已经排序的元素中从后向前比较，如果新元素小于等于已排序元素，则可以将其插在其后一位。如此循环往复。
例如：54321
第一次：45321
第二次：43521
第三次：34521

第四次：34251
第五次：32451
第六次：23451

第七次：23415
第八次：23145
…12345

public static void insertSort(int[] numbers) {   
    int size = numbers.length, temp, j;   
    for(int i=1; i<size; i++) {   
        temp = numbers[i];//记录待插数据   
        for(j = i; j > 0 && temp < numbers[j-1]; j--)   
            numbers[j] = numbers[j-1];   
        numbers[j] = temp;   
    }   
}  

5.归并排序

说明：首先申请一个大小为两个已经排序序列之和的空间，该空间用来存储合并后的序列。
其次，设置两个指针分别指向两个排好序的数组的起始位置，选择相对小的元素放入到合并空间，并移动指针到下一位置。
使用分治法

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int []data  = new int[8];
        for(int i= 0;i<data.length ;i++){
            data[i] = sc.nextInt();
        }
        //归并排序
        mergeSort(data ,0 ,data.length-1);

        for(int i = 0;i<data.length ;i++){
            System.out.print(data[i]+" ");
        }
    }
    //归并排序
    public static int[] mergeSort(int[] data,int low,int high){
        int mid = (low+high)/2;
        if(low<high){
            mergeSort(data,low,mid);
            mergeSort(data,mid+1,high);
            //左右归并
            merge(data,low,mid,high);
        }
        return data;
    }

    //归并排序的辅助方法
    public static void merge(int[] data, int low, int mid, int high) {
        int[] temp = new int[high-low+1];
        int i = low;
        int j = mid+1;
        int k = 0;
        // 把较小的数先移到新数组中
        while(i<=mid && j<=high){
            if(data[i]<data[j]){
                temp[k++] = data[i++];
                //说明：temp[k++] = temp[k] ,只是在temp[k++]之后k的值加1
                //说明：temp[++k] = temp[k+1],temp[++k]之后k的值加1
            }else{
                temp[k++] = data[j++];
            }
        }
        // 把左边剩余的数移入数组
        while(i<=mid){
            temp[k++] = data[i++];
        }
        // 把右边边剩余的数移入数组
        while(j<=high){
            temp[k++] = data[j++];
        }