java 基础排序算法

• 冒泡: 从左往右依次比较相邻的两个数，将小数放在前面，大数放在后面。

   public void bobSort(){
          for(int i=0;i<length-1;i++){//排序轮数
              for(int j=0;j<length-1-i;j++){//比较次数
                  if(array[j]>array[j+1]){
                      int temp = array[j+1];
                      array[j+1] = array[j];
                      array[j] = temp;
                  }
              }
          }
      }

• 选择：每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕

  public void chooseSort(){
          for(int i=0; i<length-1; i++){
              int minIndex = i;
              for(int j=minIndex+1;j<length;j++){
                  if(array[j]<array[minIndex]){
                      minIndex = j;
                  }
              }
              int temp = array[i];
              array[i] = array[minIndex];
              array[minIndex] = temp; 
          }
      }

• 插入：将数据分成已排序未排序，从已排序逐渐向未排序扫描，未排序的数据逐个纳入已排序的数据中(有点像摸牌的过程)public static int[] insertSort(int[] arr) {

•         for (int i = 1; i < arr.length; i++) {
              int j = i;
              int target = arr[i];
              while (j > 0 && target < arr[j - 1]) {
                  arr[j] = arr[j - 1];
                  j--;
              }
              arr[j] = target;
          }
  ​
          return arr;
      }
  ​
   

• 快速：有点像递归，选择一个基准数据，将数据分开大的放右边小的放左边，对基准两侧的数据再同样操作直到无法分割

  public static void sort(int[] a,int low,int high){
          int start = low;
          int end = high;
          int key = a[low];
  ​
  ​
          while(end>start){
              //从后往前比较
              while(end>start&&a[end]>=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
              {
                  end--;
              }
              if(a[end]<=key){
                  int temp = a[end];
                  a[end] = a[start];
                  a[start] = temp;
              }
              //从前往后比较
              while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
              {
                  start++;
              }
              if(a[start]>=key){
                  int temp = a[start];
                  a[start] = a[end];
                  a[end] = temp;
              }
              //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
          }
          //递归
          if(start>low) {
              sort(a, low, start - 1);//左边序列。第一个索引位置到关键值索引-1
          }
          if(end<high) {
              sort(a, end + 1, high);//右边序列。从关键值索引+1到最后一个
          }
      }
  ​