冒泡排序,快速排序

冒泡排序：
算法描述：

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。
  
  如果两个元素相等，不会再交换位置，所以冒泡排序是一种稳定排序算法。

public class T001 {
//    被排序的数组 arr
    public static void asort(int[] arr){
        for(int i =1;i<arr.length;i++){  //第i次排序  
            for(int j=0;j<arr.length-1;j++){//从索引为j的数开始 
                if (arr[j]>arr[j+1]){//相邻元素两两对比
                    int max = arr[j];// 元素交换  
                    arr[j] =arr[j+1];
                    arr[j+1]=max;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = {5,8,-3,15,-6,2,4,12,7};
        System.out.println("原先数组："+Arrays.toString(arr));
        asort(arr);
        System.out.println("冒泡数组："+Arrays.toString(arr));
    }
}

快速排序：
算法描述：
使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
• key值的选取可以有多种形式，例如中间数或者随机数，分别会对算法的复杂度产生不同的影响。

public class T002 {
    public static void main(String[] args) {
        int[] data={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48};

        System.out.println("排序之前：\n"+java.util.Arrays.toString(data));
        quickSort(data,0,data.length-1);
       System.out.println("排序之后：\n"+java.util.Arrays.toString(data));
    }

    private static void quickSort(int[] data, int low, int hight) {
        int i,j,temp,t;
        if(low>hight){
            return;
        }
        i=low;
        j=hight;
        //temp就是基准位 
        temp=data[low];
        System.out.println("基准位："+temp);
        while(i<j){
          //先看右边，依次往左递减  
          while(temp<=data[j]&&i<j){
          j--;
          }
          //再看左边，依次往右递增  
          while(temp>=data[i]&&i<j){
              i++;
          }
          //如果满足条件则交换  
          if(i<j){
          System.out.println("交换："+data[i]+"和"+data[j]);
          t=data[j];
          data[j]=data[i];
         data[i]=t;
         System.out.println(java.util.Arrays.toString(data));

         }
        }
      //最后将基准位与i和j相等位置的数字交换  
     System.out.println("基准位"+temp+"和i、j相遇的位置"+data[i]+"交换");
      data[low]=data[i];
      data[i]=temp;
      System.out.println(java.util.Arrays.toString(data));

      //递归调用左半数组  
      quickSort(data,low,j-1);
      //递归调用右半数组  
      quickSort(data,j+1,hight);
      }
    }