java 排序算法

package com.test;

/**冒泡排序**/

publicclassBubbleSelect {

   publicstaticvoid main(String[]args) {

      int a[]={-1,1,5,3,5,2,6,4};

      BubbleSelectb1=new BubbleSelect();

      b1.bublesort(a);

      System.out.println("插入排序法");

      b1.insertSelect(a);

      System.out.println("选择排序法");

      b1.selectSort(a);

   }

   /**冒泡排序*/

   publicvoid bublesort(intarr[]){

      for(inti=0;i<arr.length;i++){

        for(intj=i+1;j<arr.length;j++){

           if(arr[i]>arr[j]){

              inttemp=arr[i];

              arr[i]=arr[j];

              arr[j]=temp;

           }

        }

       

      } 

      for(inti=0;i<arr.length;i++){

        System.out.println(arr[i]);

      }

   }

   /**插入排序*/以后面数据为标准

   publicvoid insertSelect(intarr[]){

      intlen=arr.length;

      for(inti=1;i<len;i++){

        for(intj=0;j<i;j++){

           if(arr[j]>arr[i]){

           inttemp=arr[j];

           arr[j] =arr[i];

           arr[i]=temp;

           }

        }

      }    

      for(inti=0;i<arr.length;i++){

        System.out.println(arr[i]);

      }

   }

  /**选择排序*/（从数组中找出最小的来交换位置） 

   publicvoid selectSort(intarray[]){

      intlen=array.length;

      for(inti=0;i<len;i++){

        intmin=i;

        for(intj=i+1;j<len;j++){

           if(array[j]<array[min]){

            min =j;

           }

        }

        inttemp=array[min];

         array[min]=array[i];

         array[i] =temp;

      }

      for(inti=0;i<array.length;i++){

        System.out.println(array[i]);

      }

   }

}

快速排序

/**
* 快速排序算法
* @param arr
* @param left
* @param right
* @return
*/
private static int partition(int[] arr,int left,int right) {
     int key=arr[left];
     while(left<right) {
        while(left<right && arr[right]>=key) {
           right--;
        }
        arr[left]=arr[right];
        while(left<right && arr[left]<=key) {
           left++;
        }
        arr[right]=arr[left];
     }
     arr[left]=key;
     return left;
  }
/***
* 
* @param arr
* @param left
* @param right
*/
public static void quickSort(int [] arr,int left,int right) {
     int pivot=0;
     if(left<right) {
        pivot=partition(arr,left,right);
        quickSort(arr,left,pivot-1);
        quickSort(arr,pivot+1,right);
     }
    for(int i=0;i<arr.length;i++){
    System.out.println(arr[i]);
    } 

  }

public static void HeapAdjust(int[] array, int parent, int length) {
   int temp = array[parent]; // temp保存当前父节点
   int child = 2 * parent + 1; // 先获得左孩子
   while (child < length) {
       // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
       if (child + 1 < length && array[child] < array[child + 1]) {  
           child++;  
       }
       // 如果父结点的值已经大于孩子结点的值，则直接结束 
       if (temp >= array[child])
           break;
       // 把孩子结点的值赋给父结点
       array[parent] = array[child];
       // 选取孩子结点的左孩子结点,继续向下筛选
       parent = child;
       child = 2 * child + 1;
   }
   array[parent] = temp;
}
public static void heapSort(int[] list) {
   // 循环建立初始堆 
   for (int i = list.length / 2; i >= 0; i--) {
       HeapAdjust(list, i, list.length - 1);
   }  
   // 进行n-1次循环，完成排序
   for (int i = list.length - 1; i > 0; i--) {
       // 最后一个元素和第一元素进行交换
       int temp = list[i];
       list[i] = list[0];
       list[0] = temp;
       // 筛选 R[0] 结点，得到i-1个结点的堆
       HeapAdjust(list, 0, i);
       System.out.format("第 %d 趟: \t", list.length - i);
       //printPart(list, 0, list.length - 1);
   }
 
   for(int i=0;i<list.length;i++){
    System.out.println(list[i]);
   }
}