Java-排序方法

**

Java-排序方法

**
**

数组的四种排序

**

1.冒泡排序

//冒泡排序
    public static void bubSort(int a[])
    {
        //确定比试的次数
        for(int i=0;i<a.length-1;i++)
        {
            //如果是从小到大的顺序，第一次过后，最大的数会排到最后，第二次过后，第二次小的数会排到倒数第二，依次类推
            //从大到小同理
            //每比试一次过后，可无需在与最后的数再比一次，所以次数可以相对应的减少
            for(int j=0;j<a.length-1-i;j++)
            {
                if(a[j]>a[j+1])
                {
                    int t=a[j];
                    a[j]=a[j+1];
                    a[j+1]=t;
                }
            }
        }
    }

2.选择排序

//选择排序
    public static void selSort(int a[])
    {
        //选择排序，自己与自己后面的数进行比较，所以无需到最后一个
        for(int i=0;i<a.length-1;i++)
        {
            //记住当前数的索引值，方便互换
            int t=i;
            //每次的最小项都是以i为基准
            int min=i;
            for(int j=i+1;j<a.length;j++)
            {
                //比较开始
                if(a[min]>a[j])
                {
                    //最小项的值变化
                    min=j;
                }
            }
            if(t!=min)
            {
                //说明最小项的值发生了变化，当前项要与最小项互换
                int k=a[min];
                a[min]=a[t];
                a[t]=k;
            }

        }
    }

3.插入排序

//插入排序
    public static void insertSort(int a[])
    {
        //前一个数与后面的数相比较
        for(int i=1;i<a.length;i++)
        {
            //如果前面的数比后面的数大，开始
            if(a[i]<a[i-1])
            {
                //将当前值纪录
                int temp=a[i];
                //记住前面一个数的索引
                int j=i-1;
                //查找前面还存不存在比自己大的数，因索引值大于等于0，所以加上先决条件
                for(;j>=0 && a[j]>temp;j--);
                //查找完之后，j的值会自动减一，所以加一使其恢复正常
                j++;
                //将自身到索引值之间的数后调一位
                for(int k=i;k>j;k--)
                {
                    a[k]=a[k-1];
                }
                //将值赋给索引所在的位置
                a[j]=temp;
            }
        }
    }

4.快速排序

//快速排序，以递归，数组的前后，基准值来排序
    public static void quictSort(int arr[],int start,int end)
    {
        //如果开始位置和结束位置重合，实际上就是一个数字，所以开始位置一定要比结束位置小，而且不能相等
        if(start < end){
//设定标准数，也就是快速排序的过程中，和谁进行比较，通常用第一个数字即可
//注意这里用的是arr[start],按说在第一次的时候是0，应该写成arr[start],但是不可以
//因为快速排序是一个递归的操作，第二次进来的时候，就不是arr[0]了
            int temp = arr[start];

//开始找开始位置和结束位置
//我们知道快速排序其实就是有一个开始位置和一个结束位置，当开始位置比选定的标准数字大的时候，就会替换掉
//结束位置的数字，这个时候结束位置的下表开始向前移动，然后如果结束位置的数字比标准数字，则替换开始位置的数字
//在循环的过程中如果开始位置/结束位置的数字 不比标准数字大或者小，这个时候开始位置和结束位置就会向后/向前移动

//开始位置
            int low = start;
//结束位置
            int high = end;

            while (low<high){

//这个时候我们已经找定了开始位置和结束位置

//第一次是要拿高位和低位进行比较,如果高位比标准数字大，则高位则向前移动一位
                while (low < high && arr[high] >= temp){
                    high--;
                }
//当然了并不是所有高位数字都比低位大，如果比低位要小，则这个数字要覆盖低位的数字
                arr[low] = arr[high];

//然后这个时候低位开始移动，如果低位比标准数字小，则低位的下标向后移动一位
                while (low < high && arr[low] <= temp){
                    low++;
                }

//当然了并不是所有时候低位都比标准数字要小，如果比标准数字大的话，这个时候就要替换掉高位的数字
                arr[high] = arr[low];
            }

//经过上面的一番折腾，这个时候就会出现一个情况，低位和高位相同，那么这个位置就用标准数字去替换
//这里low和high实际上是相同的数字，所以写哪个都无所谓
            arr[low] = temp;

//然后第一轮排序完毕，我们就会发现以标准数字为分界线，我们有两个学列了，这个时候，我们就调用递归来
//分别对两个序列进行排序
//先出来低位的递归,最后的位置实际上有可能是高位，有可能是低位，既然上面写的是低位，这里就写低位就好了
            quictSort(arr,start,low);
//然后出来高位的数字
            quictSort(arr,low+1,end);
        }

    }