1 冒泡排序

相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

		int k[] = {3,4,5,1,0,2};	
		for(int i=0;i<k.length-1;i++)
		{
			for(int j=i+1;j<k.length;j++)
			{
				if(k[i]>k[j])
				{
					int temp = k[i];
					k[i]=k[j];
					k[j]=temp;
				}
			}
		}
		for(int i=0;i<k.length;i++)
		{
			System.out.println(k[i]);
		}

2 选择排序

第一个数依次与后面的数比较，第一次比较完之后最小的数在最前面 。如果前面的数大于后面的数，就进行位置的交换。

        //数组排序之选择排序
        int [] arr={2,1,6,9,5,4};
        int minIndex=0;   //定义一个最小元素的索引
        int temp=0;
        for (int i = 0; i < arr.length; i++) {
            minIndex=i;   //从0索引开始，将索引赋给minIndex
            for (int j = i+1; j < arr.length; j++) {
                if (arr[j]<arr[minIndex]){
                    minIndex=j;//找到最小值的索引
                }
            }
            //将最小元素放到本次循环的前端
            temp=arr[i];
            arr[i]=arr[minIndex];
            arr[minIndex]=temp;
        }    //然后寻找下次循环中最小元素放于下次循环的最前端
        System.out.println(Arrays.toString(arr));

3插入排序

第k次将前面k个数按从小到大排序，每一次将后面的数插入到前面的合适位置

		int k[] = {3,4,5,3,2,1,0,2};		
        for(int i=1;i<k.length;i++)
        {   
            for(int j=i;j>0;j--)
            {   
			    if (k[j]<k[j-1])
			    {   
					int temp=k[j-1];  
					k[j-1]=k[j];  
					k[j]=temp;          
			    }
			    else break;   
            }  
        }
		for(int i=0;i<k.length;i++)
		{
			System.out.println(k[i]);
		}  //插入排序

4 快速排序

冒泡排序的一种优化，挖坑填数。

public class QuickSortUtils {
    /**
     * @param arr   要排序的数组
     * @param start 要排序的起始位
     * @param end   要排序的结束位置 数组长度-1
     */
    public static void quickSort(int[] arr, int start, int end) {
        if (start < end) {
            //找出中间索引
            int index = getIndex(arr, start, end);
            //分成左右两半,对左右凉拌进行递归调用
            quickSort(arr, start, index - 1);//递归排序左半部分
            //递归排序右半部分
            quickSort(arr, index + 1, end);
        }
    }

    /**
     * @param arr   要排序的数组
     * @param start 开始位置
     * @param end   结束位置
     * @return 返回的是分区的中间索引
     */
    //挖坑填数
    private static int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //定义基准数
        int x = arr[i];
        while (i < j) {
            //1.先从后往前找
            while (i < j && arr[j] > x) {//
                j--;
            }
            //挖坑填数
            if (i < j) {
                arr[i] = arr[j];//填坑
                i++;//顺遍让i 递增一下
            }
            //2.从前往后找
            while (i < j && arr[i] <= x) {
                i++;
            }
            //挖坑填数
            if (i < j) {
                arr[j] = arr[i];//填坑
                j--;//顺遍让j 递减一下
            }
        }
        arr[i] = x;//把基准数填到最后一个坑里
        return i;
    }
}