常见的排序

1、冒泡排序

原理: 每相邻的二个数两两进行比较，每一轮产生一个极值。

public static void bubbleSort(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;

      }

    } 

   }

  }

2、选择排序

原理：是通过反复地求最大值的方式实现排序的

public static void bubbleSort(int[] arr) {

     int [] arr= {3，4，10，-2};

       int t;

     for(int i=0;i<4;i++) {

     for(int j=i+1;j<4;j++) {

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

     t=arr[i];

    arr[i]=arr[j];

    arr[j]=t;

     }

   }

  }

System.out.println(Arrays.toString(arr));

}

3、快速排序

原理：

选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的

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

      public static void main(String[] args) {
         int[] arr= {23,-1,10,-40};
          int i,j;
         for( i=1;i<arr.length;i++) {
         int temp=arr[i];
         for(j=i-1;j>=0;j--){
       //如果后面的数比前面的数大，直接退出循环
         if(arr[j]<=temp){
            break;
         }
       //如果后面的数比前面的数小，交换
           if(arr[j]>temp) {
           arr[j+1]=arr[j];
           arr[j]=temp;
         }
        }
 

4、桶排序

原理：

桶排序 (Bucket Sort) 的原理很简单，它是将数组分到有限数量的桶子里。

假设待排序的数组 a 中共有 N 个整数，并且已知数组 a 中数据的范围 [0, MAX) 。在桶排序时，创建容量为

MAX 的桶数组 r ，并将桶数组元素都初始化为 0 ；将容量为 MAX 的桶数组中的每一个单元都看作一

个 " 桶 " 。

在排序时，逐个遍历数组 a ，将数组 a 的值，作为 " 桶数组 r" 的下标。当 a 中数据被读取时，就将桶的值加 1。例如，读取到数组 a[3]=5 ，则将 r[5] 的值 +1 。

    int[] arr = { 1，1，4，5，5，7，9 };
      int max = getMax(arr);
   // 创建一个容量为max的buckets，并且给buckets的元素的值进行初始化0
      int[] buckets = new int[max+1];
       //1.计数
       for(int i=0;i<arr.length;i++) {
         buckets[arr[i]]++;
                }
           //2.排序
           for(int i=0,j=0;i<max;i++) {
          while((buckets[i])-->0) {
                arr[j++]=i;
          }
       }
   buckets=null;
   System.out.println(Arrays.toString(arr));
    }
public static int getMax(int[] arr) {
          int max = 0;
         for (int element : arr) {
       if (max < element) {
        max = element;
       }
    }
  return max;
  }

5、二分查找法

原理 :

1. 前提是数组中元素必须按照升序排序

2. 给定的值和数组中间的位置上元素进行比较，如果相等，则查找成功

3. 如果给定的值比数组中间位置上元素的值要小，在数组的前半部分进行查找

4. 如果给定的值比数组中间位置上元素的值要大，在数组的后半部分进行查找

5. 以此类推重复 2,3,4 步骤

public static int binarySearch(int[] arr,int number) {

          int low=0;

         int high=arr.length-1;

       while(low<=high) {

     int middle=(low+high)/2;

    if(arr[middle]==number) {

       return middle;

       }

     if(arr[middle]<number) {

     low=middle+1;

    }

    if(arr[middle]>number) {

        high=middle-1;

          }

        }

          return -1;

}