（JAVA自学笔记五）排序算法

1. 冒泡排序：

2. 依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。

   第一趟比较完成后，最后一个数一定是数组中最大的一个数，所以第二趟比较的时候最后一个数不参与比较；

public static void main(String args[])//冒泡排序法，升序
    {
        int a[]={2,1,3,7,5,6,4};//原始无序数组
        int b;
        for(int i=0;i<a.length-1;i++)//外层控制比多少轮
        {
            for(int j=0;j<a.length-i-1;j++)//内层控制每轮比几次，排过的数后面不用再排
            {
                if(a[j]>a[j+1])
                {
                    b=a[j];
                    a[j]=a[j+1];
                    a[j+1]=b;
                }
            }
        }
        for(int i=0;i<a.length;i++)
        {
            System.out.print(a[i]);
        }
    }
//冒泡排序总的平均时间复杂度为：O(n2) 。

2.快速排序：

基于分治的思想，是冒泡排序的改进型。首先在数组中选择一个基准点（该基准点的选取可能影响快速排序的效率，后面讲解选取的方法），然后分别从数组的两端扫描数组，设两个指示标志（lo指向起始位置，hi指向末尾)，首先从后半部分开始，如果发现有元素比该基准点的值小，就交换lo和hi位置的值，然后从前半部分开始扫秒，发现有元素大于基准点的值，就交换lo和hi位置的值，如此往复循环，直到lo>=hi,然后把基准点的值放到hi这个位置。一次排序就完成了。以后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。

    public static void main(String[] args) {
        int a[]={6,1,2,7,9,3,4,5,10,8};
        quickSort(a,0,a.length-1);
    }
    public static void quickSort(int a[], int left,int right)
    {
        int i,j,t,temp;
        if(left>=right)//等于时说明区间只有一个数，也不用比了，可以少进一层
            return;

        temp=a[left]; //temp中存的就是基准数
        i=left;
        j=right;
        while(i!=j)//每轮终止条件
        {
            //顺序很重要，要先从右边开始找
            while(a[j]>=temp && i<j)//基准数本身不比，不然有两个6会死循环
                j--;
            //再找左边的
            while(a[i]<=temp && i<j)
                i++;
            //交换两个数在数组中的位置
            if(i<j)
            {
                t=a[i];
                a[i]=a[j];
                a[j]=t;
            }
            System.out.println("-每步"+Arrays.toString(a));
        }
        //出来后i==j
        //因为先从右边开始找，最终i和j会移动到边界线左边的一个数，将基准数归位
        a[left]=a[i];
        a[i]=temp;
        System.out.println("每层"+Arrays.toString(a));
        quickSort(a, left,i-1);//继续处理左边的，这里是一个递归的过程
        quickSort(a, i+1,right);//继续处理右边的 ，这里是一个递归的过程
    }
//快速排序的平均时间复杂度是O（nlogn）

-每步[6, 1, 2, 5, 9, 3, 4, 7, 10, 8]
-每步[6, 1, 2, 5, 4, 3, 9, 7, 10, 8]
-每步[6, 1, 2, 5, 4, 3, 9, 7, 10, 8]
每层[3, 1, 2, 5, 4, 6, 9, 7, 10, 8]
-每步[3, 1, 2, 5, 4, 6, 9, 7, 10, 8]
每层[2, 1, 3, 5, 4, 6, 9, 7, 10, 8]
-每步[2, 1, 3, 5, 4, 6, 9, 7, 10, 8]
每层[1, 2, 3, 5, 4, 6, 9, 7, 10, 8]
-每步[1, 2, 3, 5, 4, 6, 9, 7, 10, 8]
每层[1, 2, 3, 4, 5, 6, 9, 7, 10, 8]
-每步[1, 2, 3, 4, 5, 6, 9, 7, 8, 10]
-每步[1, 2, 3, 4, 5, 6, 9, 7, 8, 10]
每层[1, 2, 3, 4, 5, 6, 8, 7, 9, 10]
-每步[1, 2, 3, 4, 5, 6, 8, 7, 9, 10]
每层[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]