闲来无聊手撸（冒泡排序，选择排序，插入排序，快速排序，归并排序）JAVA语言-CSDN博客

本文链接：https://blog.csdn.net/qq_36268452/article/details/113110727

背景

临近过年，公司各种工作已经是不太忙碌，就闲来无事，手有点痒痒。于是没事儿找事，就随便撸撸各种排序算法，也算排解一下寂寞。

一，冒泡排序

冒泡排序可以说是最简单的排序方式了，其过程就如同它的名字一样，挨个比较，慢慢移动，把大的或者小的给移动到一端。其动态图如下：

在这里插入图片描述
冒泡排序的java代码实现也很简单，如下：

/**
* 冒泡排序
 */
public static void maoPao(int[] args){
    int temp;
    for(int i =0;i<args.length;i++){
        for(int j = 0;j<args.length-i-1;j++){
            if(args[j] >args[j+1]){
                temp = args[j+1];
                args[j+1] = args[j];
                args[j] = temp;
            }
        }
    }
}

二，选择排序

选择排序跟冒泡排序有点像，冒泡排序是挨个比较，大的或小的移动到一端。选择排序则是一端跟其他元素比较，把大的或小的给交互过来。其动态图如下：

在这里插入图片描述
java代码也比较简单，如下：

/**
 * 简单选择排序
  */
 public static void select(int[] args){
     int temp;
     for(int i = 0;i<args.length;i++){
         for(int j = i;j<args.length;j++){
             if(args[i] > args[j]){
                 temp = args[j];
                 args[j] = args[i];
                 args[i] = temp;
             }
         }
     }
 }

三，插入排序

插入排序，其过程也如其名字。就是在有序一段插入其他无序的元素，直到整个数组有序。
其动态图如下：

在这里插入图片描述
其java代码也不算麻烦，如下：

/**
 * 插入排序
  */
 public static void insert(int[] args){
     int temp;
     for(int i =1;i < args.length;i++){
         temp = args[i];
         for(int j = i-1;j >=0 ;j--){
             if(temp >= args[j]){
                 break;
             }
             if(temp < args[j]){
                 args[j+1] = args[j];
             }
             args[j] = temp;
         }
     }
 }

四，快速排序

我的思路是这样的，每次都最左边为基准，然后从右向左找比基准小的，从左向右找比基准大的，然后两个交换，直到两个相遇则与基准交换。然后递归基准左边的和右边的（这个图其实跟我的代码不太匹配，大致的思路一致，都是减少比较次数）ps：实在搜不到合适的动图了
在这里插入图片描述
java代码如下：

/**
 * 快速排序
  */
 public static void quick(int[] arrays){
     quick(arrays,0,arrays.length-1);
 }

public static void quick(int[] args,int left,int right){
     int i, j, t, temp;
     if(left > right){
         return;
     }
     temp = args[left];
     i = left;
     j = right;
     while(i != j) {
         while(args[j] >= temp && i < j){
             j--;
         }
         while(args[i] <= temp && i < j){
             i++;
         }
         if(i < j)
         {
             t = args[i];
             args[i] = args[j];
             args[j] = t;
         }
     }
     args[left] = args[i];
     args[i] = temp;
     quick(args,left, i-1);
     quick(args,i+1, right);
 }

五，归并排序

归并排序就是分而治之的思想。递归到单个元素然后两两排序，一直向上反推过去，达到全部有序。也不是太难，最主要需要理解它的思想。一种分而治之的思想。

在这里插入图片描述
java代码如下：

/**
  * 归并排序
   */
  public static int[] merge_sort(int[] ins){
      if(ins.length <=1){
          return ins;
      }
      int num = ins.length/2;
      int[] left = merge_sort(Arrays.copyOfRange(ins, 0, num));
      int[] right = merge_sort(Arrays.copyOfRange(ins, num, ins.length));
      return sortArraysMerge(left,right);
  }

  /**
   * 两个有序的数据 合并成一个有序的数据
   */
  public static int[] sortArraysMerge(int[] aa, int[] bb){
      int[] cc = new int[aa.length+bb.length];
      int i = 0;
      int j = 0;
      int k = 0;
      while(true){
          if(i <= aa.length-1 && j <= bb.length-1){
              if(aa[i]<bb[j]){
                  cc[k] = aa[i];
                  i++;
              }else{
                  cc[k] = bb[j];
                  j++;
              }
          }else{
              if(i == aa.length && j == bb.length){
                  break;
              }
              if(i < aa.length){
                  cc[k] = aa[i];
                  i++;
              }
              if(j < bb.length){
                  cc[k] = bb[j];
                  j++;
              }
          }
          k++;
      }
      return cc;
  }