一个简单的冒泡排序和快速排序算法java实现

 一共三个类。

package com.sw.SortTool;
/**
 * 通过一次分割，将无序序列分成两部分，其中前一部分的元
 *素值均不大于后一部分的元素值。然后对每一部分利用同样的方法进行分割，这
 *个过程一直做到每一个子序列的长度小于某个值m为止。
 *对序列p的分割过程： 首先，在序列的第一个、中间一个及最后一个元素中
 *选取中项，得p(k),然后设置两个指针i和j分别指向序列的起始和最后的位置.
 * @author sw
 *
 */
public class QuickSort {
 public QuickSort(){
 }
 public static void QuickSort(int[] arm){
  int left = 0;
  int right = arm.length - 1;
  QuickSortSubArray(arm,left,right);

 }
 public static void QuickSortSubArray(int[] arm,int left,int right){
  int tmp ;
   int i = left ;
  int j = right ;
  if ( right - left +1 < 3 ){
   tmp = arm[right];
   arm[right]=arm[left];
   arm[left]=tmp ;
   return ;
  }
  int privot = arm[(left+right)/2];
  do{
   while(arm[i]<privot && i<right) i++ ;
   while(arm[j]>privot && j>left)  j-- ;
   if(i<=j){
    tmp = arm[i];
    arm[i]=arm[j];
    arm[j]=tmp ;
   }
  }while(i<j);
  System.out.print("迭代:");
  for(int k = 0;k<arm.length;k++){
   System.out.print(arm[k]+"  ");
  }
  System.out.println("");
  if(left < j) QuickSortSubArray(arm,left,j-1);
  if(i < right) QuickSortSubArray(arm,i+1,right);
 }
}
/**
快速排序算法：
原始数据： 10  34  56  23  8  91  43  19 
迭代:10  19  8  23  56  91  43  34 
迭代:10  8  19  23  56  91  43  34 
迭代:8  10  19  23  56  34  43  91 
迭代:8  10  19  23  34  56  43  91 
快速排序后结果：8  10  19  23  34  43  56  91 
*/

 

package com.sw.SortTool;

import java.sql.Array;

public class PopSort {
 public PopSort(){
  
 }
/**
 * 冒泡排序算法。共遍历length*(length-1)次。
 * 每次都从整个数组中下沉一个最大的数。
 * @param armArray
 * @author sw
 * @return
 */
 public static int[] PopSort(int[] armArray){
  int tmp ;
  if(armArray.length < 2){
   return armArray ;
  }
   for(int i=0;i<armArray.length;i++){
    for(int j=0;j<armArray.length -i-1;j++){
     if(armArray[j] > armArray[j+1]){
      tmp = armArray[j] ;
      armArray[j] = armArray[j+1]  ;
      armArray[j+1]=tmp ;
     }
    }
    System.out.print("第"+i+"次迭代： ");
    for(int k=0;k<armArray.length;k++){
     System.out.print(armArray[k]+"  ");
    }
    System.out.println("");
   }
  return armArray ;
 }
}
/**
例子输出结果：
原始数据：  10  34  56  23  8  91  43  19 
第0次迭代： 10  34  23  8  56  43  19  91 
第1次迭代： 10  23  8  34  43  19  56  91 
第2次迭代： 10  8  23  34  19  43  56  91 
第3次迭代： 8  10  23  19  34  43  56  91 
第4次迭代： 8  10  19  23  34  43  56  91 
第5次迭代： 8  10  19  23  34  43  56  91 
第6次迭代： 8  10  19  23  34  43  56  91 
第7次迭代： 8  10  19  23  34  43  56  91 
*/

 

package com.sw.SortTool;
/**
 * 测试用例
 * @author sw
 *
 */
public class domain {
 public static void main(String[] args){
  int[] arm = {10,34,56,23,8,91,43,19};
  //冒泡排序算法调试用例：
  System.out.println("冒泡排序算法：");
  System.out.print("原始数据： ");
  for(int i = 0;i<arm.length;i++){
   System.out.print(arm[i]+"  ");
  }
  System.out.println("");
  arm = PopSort.PopSort(arm);
  //快速排序算法调试用例：
  System.out.println("快速排序算法：");
  System.out.print("原始数据： ");
  for(int i = 0;i<arm.length;i++){
   System.out.print(arm[i]+"  ");
  }
  System.out.println("");
  QuickSort.QuickSort(arm);
  System.out.print("快速排序后结果：");
  for(int i = 0;i<arm.length;i++){
   System.out.print(arm[i]+"  ");
  }
 }
}