冒泡、快速排序小结

1.冒泡排序

   (1) 比较领近的两个数

　(2) 如果左边的比右边的数字大，则交换位置

　(3) 向右移动一位，继续比较相邻的两个数

  排序示例：

 一轮排序结束后，最大值的位置已经移动最右端，再次如此循环，最终经过n-1次则完成最终排序。

使用java算法表示外部循环，需要经过n-1次。即

  for(int i=0;i<n-1;i++)

内部循环由于外部循环每完成一次就有一个数字完成最终排序，则需要经过n-1-i次比较

  for(int j=0;j<n-1-i;j++)

最终冒泡排序的java算法为：

  int[] a=new int[]{18,19,5,8,3};
        int n=a.length;
        for(int i=0;i<n-1;i++){
            for(int j=0;j<n-1-i;j++){
                if(a[j]>a[j+1]){
                    int temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                }
            }
        }

        for(int k=0;k<n;k++){
            System.out.println("**"+a[k]);

        }

2.快速排序

 思路：基于分治的思想，是冒泡排序的改进版。首先在数组中选择一个基准点，然后从数组的两端开始扫描，设置lo指标指向开始端，hi指向结尾端。

从后半部分开始扫描，如果扫描到有比基准点值小的，则把这个值赋值给基准点位置。然后从前部分扫描，扫描比基准点大的元素，扫描到后把该元素赋值与上一个移动的元素。

如此循环，直到lo，hi指针重合，则结束一轮循环。这次把基准点的值赋值给最后一个变动的元素，这时，基准点前面都是比它小的元素，后面都是比它大的，也就是是确定了基准点的最终位置。

排序过程如下：

原始数据      72   6   57     83     42    34    81     12      29        {72 设置为基准点，lo指向开始，hi指向结尾。从后面扫描，发现29<72 把29赋值为72}

现在数据      29   6   57     83     42    34    81     12   （29）      {从前面扫描，找比72大的，扫描到83，则把83赋值给（29）处}

现在数据      29   6   57  （83）  42    34    81     12       83        {从后面扫描，找比72小的，发现12，将12赋值给(83)}

现在数据      29   6   57     12     42    34    81    (12)     83        { 从前面扫描，找比72大的，发现81，把81赋值给(12)}

现在数据      29   6   57     12     42    34   (81)    81      83         {hi  lo 重合，基准点72赋值给(81)，完成一次循环}

一轮数据      29   6    57    12     42    34     72     81      83        {基准点的最终位置确定}

其过程图如下:

其算法实现找到基准点位置：需要定义lo，hi

   private int partition(int sortArray[],int low,int hight)
    {
        /**
         * key 值为基准点的值  
         */
        int key = sortArray[low];
        
        while(low<hight)
        {
            /**
             * 从后半部分开始扫描，大于key的，hi直接-1，如果小于key，则把该元素赋值给array[lo];
             */
            while(low<hight && sortArray[hight]>=key)
                hight--;
            sortArray[low] = sortArray[hight];

            /**
             * 从前半部分扫描，小于key的，lo直接+1，如果大于key，则把该元素赋值给array[hi];
             */
            while(low<hight && sortArray[low]<=key)
                low++;
            sortArray[hight] = sortArray[low];
        }
        /**
         * 然后lo hi重合时，结束，把key赋值给array[lo]即可
         */
        sortArray[low] = key;
        return low;
    }

到此找到基准点的最终位置，然后以基准点现在位置，分为左右两部分，在循环上面的操作

 public void sort4(int[] data,int low,int hight)
    {
        if(low<hight)
        {
            int result = partition(data,low,hight);
            sort4(data,low,result-1);
            sort4(data,result+1,hight);
        }

    }