数据结构中常见的冒泡排序和快速排序

冒泡排序的思想

1. 第一轮排序：索引从0开始到最后，前一个元素和后一个元素进行比较，如果符合条件就进行换位处理 ，那么最大值就会被排到数组的最后。
2. 第二轮排序：最后一个元素没有必要比较了，索引从0开始，到arr.leng-1.如果符合条件就进行换位处理，那么，最大值被排到倒数第二位。
3. 第arr.length-1轮，最大值放到第二位。

冒泡排序的实现

1. 确定外循环的次数，经过演示发现，外循环的次数等于数组长度-1；

2. 确定内循环，比较索引从0开始，到arr.length-外循环轮数

   public static int[] sortWaterBall(int[] arr){
   //从前往后排
   for(int i=0;i<arr.length-1;i++){
   for(int j=0;j<arr.length-1-i;j++){
   if(arr[j]>arr[j+1]){
   int temp=arr[j];
   arr[j]=arr[j+1];
   arr[j+1]=temp;
   }
   }
   }
   return arr;
   }

改进的冒泡排序

引入标志位，默认为true。如果前后数据进行了交换，则为true否则为false。如果没有数据交换，则排序完成。

        public static int[] bubbleSort(int[] arr){  
         boolean flag = true;  
	         int n = arr.length;  
	         while(flag){  
	           flag = false;  
	            for(int j=0;j<n-1;j++){  
                if(arr[j] >arr[j+1]){  
	                     //数据交换  
	                     int temp = arr[j];  
	                     arr[j] = arr[j+1];  
	                     arr[j+1] = temp;  
	                     //设置标志位  
	                    flag = true;  
	                 }  
	             }  
	             n--;  
	        }  
	         return arr;  
	    }  

快速排序

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然*后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

void quickSort(int[] a, int low, int high) { 
        p = get(a, low, high); 
        quickSort(a, low, p-1); 
        quickSort(a, p+1, high); 
} 

int get(int[] a, int low, int high){ 
     compare = a[low]; 

     while(low < high){ //无论如何置换, 被置换的都包含compare的值
         while(low<high && a[high]>=compare)    
              high--; 

         //在 low<high 的情况下找到a[high]<compare并置换 
         temp = a[low];
         a[low] = a[high];
         a[high] = temp;

         while(low<high && a[low]<=compare) 
              low++; 

         //在 low<high 的情况下找到a[low]>compare并置换 
          temp = a[low]; 
          a[low] = a[high]; 
          a[high] = temp; 
     } 
     return low; //while(low==hight)停止循环, 并返回枢轴位置 
}