java和scala版本的冒泡排序、快速排序、归并排序、选择排序、插入排序

1.冒泡排序

  ① java版本的冒泡排序

import java.util.Arrays;
//冒泡排序
public class BubbleSort {
    /**
     * 冒泡排序
     * @param arr 要排序的数组
     */
    public static void bubbleSort(int[] arr) {
       int tmp;//中间交换变量
       for(int i=0;i<arr.length-1;i++) {
           for(int j=i+1;j<arr.length;j++) {
               if(arr[i]>arr[j]) {//升序
                  tmp = arr[i];
                  arr[i] = arr[j];
                  arr[j] = tmp;
               }
           }
       }
    }
}

 ② scala版本的冒泡排序

//定义一个方法，传入的参数是要进行排序的List集合，输出的是排序后的List集合
  def bubbleSort(list: List[Int]): List[Int] = list match {
    case List() => List()
    case head :: tail => compute(head, bubbleSort(tail))
  }
  def compute(data: Int, dataSet: List[Int]): List[Int] = dataSet match {
    case List() => List(data)
    case head :: tail => if (data <= head) data :: dataSet else head :: compute(data, tail)
  }

2.快速排序

  ① java版本的快速排序

//快速排序
public class QuickSort {  
    /**
     * 快速排序--
     * 选择一个基准数作为比较标准，然后左右两个哨兵依次从最左右两边开始搜索，
     * 如果是升序排序，则左边的哨兵发现比基准数大的数停止搜索，右边的哨兵发现比基准数小的数后停止前进，然后进行交换，
     * 然后再继续搜索依次交换，直到两个哨兵相遇，下标相同后停止，然后将两个哨兵相遇位置的数跟第一个基准数进行位置互换，
     * 互换后，哨兵相遇位置的左边都比基准数小，右边的数都比基准数大，然后再以基准数的位置，将数组分为左右两部分，然后依次利用此原理进行递归。
     * @param arr 要进行排序的数组
     * @param startIndex 左边哨兵的起始位置0
     * @param endIndex 右边哨兵的起始位置arr.length-1
     */
    public static void quickSort(int[] arr,int startIndex,int endIndex) {
       //创建两个哨兵i,j
       int i=startIndex,j=endIndex;
       //递归出口,当j大于i时退出递归
       if(i>j) {
           return;
       }
       //声明中间交换量，避免在循环中多次创建该变量
       int tmp;
       //默认选择起始索引位置为基准点
       int standardPoint = arr[startIndex];
       //当两个哨兵没有相遇时一直循环，直到相遇时，退出循环
       while(j>i) {
           //必须先让右边的哨兵开始搜索,否则有些情况下会报错
           while(arr[j]>=standardPoint && j>i) {
               j--;
           }
           //右边的哨兵搜索停止，然后让左边的哨兵开始搜索
           while(arr[i]<=standardPoint && j>i) {
               i++;
           }
       //这儿必须加判断,有可能上面while循环后i和j已经相等,例如:即i没动,j直接遍历到i的起始位置
           if(j>i) {
               //两个哨兵找到对应不满足条件的位置会停下，交换两个位置的数
               tmp = arr[i];
               arr[i] = arr[j];
               arr[j] = tmp;
           }
       }
    //退出上面while循环,肯定是i和j两个哨兵相遇了,当两个哨兵相遇时,将相遇位置的数和基准数进行位置交换
       arr[startIndex] = arr[i];
       arr[i] = standardPoint;
       //然后将该数组从基准位置处分为左右两部分进行以上逻辑递归处理
       quickSort(arr, startIndex, i-1);//递归调用右边部分
       quickSort(arr, i+1, endIndex);//递归处理右边部分
    }
}

  ② scala版本的快速排序

def quickSort(list:List[Int]):List[Int] ={
    list match {
      case Nil => Nil
      case List() => List()
      case head::tail =>{
        val (first,second) = tail.partition(_ < head)
        quickSort(first) ++ (head :: quickSort(second))
      }
    }
  }

3.归并排序

public class MergeSort {
    public static void sort(int[] arr){
       //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        int[] temp = new int[arr.length];
        spilt(arr,0,arr.length-1,temp);
    }
    private static void spilt(int[] arr,int left,int right,int[] temp){
        if(left<right){
            int mid = (left+right)/2;
            //左边归并拆分
            spilt(arr,left,mid,temp);
            //右边归并拆分
            spilt(arr,mid+1,right,temp);
            //将左右两两数组进行合并
            merge(arr,left,mid,right,temp);
        }
    }
    private static void merge(int[] arr,int left,int mid,int right,int[] temp){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

4.选择排序

//选择排序--升序：从第一个数开始跟后面的数依次比较交换，交换后还是以第一个位置比较，直到第一个位置跟后面所有的都比较完成后再从第二个开始跟第二个以后的数比较，所有比较完再依次向后移动位置比较，最后一个不用比较
    public void selectionSort(int[] arr) {
        for(int i=0;i<arr.length-1;i++) {//最后一个位置循环结束时不用再比较，肯定是最大的循环n-1次
            int changeValue = arr[i];//中间交换量
            for(int j=i+1;j<arr.length;j++) {
                if(arr[i]>arr[j]) {
                    arr[i] = arr[j];
                    arr[j] = changeValue;
                }
            }
        }
        System.out.println("选择排序:");
        for (int option : arr) {
            System.out.print(option+" ");
        }
    }

5.插入排序

    /*插入排序----升序:
     * 从第二个位置开始，拿这个值跟前面的依次比较，如果第二个位置的数小于第一个位置数，
     * 就将数组中下标为0的数向后移动覆盖第二个位置的数，然后将第二个位置的数插入到第一个位置，
     * 然后再从第三个位置开始，依次向下移动覆盖然后插入
     */
    public void insertSort(int[] arr) {
        for(int i=1;i<arr.length;i++) {
            int changeValue = arr[i];
            for(int j=0;j<i;j++) {
                if(arr[i]<arr[j]) {
                    for(int k=i;k>j;k--) {
                        arr[k] = arr[k-1];
                    }
                    arr[j] = changeValue;
                    break;
                }
            }
        }
        System.out.println("插入排序:");
        for (int option : arr) {
            System.out.print(option+" ");
        }
    }