数据结构和算法：冒泡、选择、插入、归并及快排的Java实现

package Sort;

import java.util.ArrayList;
import java.util.Arrays;

public class Sort {
    //交换元素
    public static void swap(int [] arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    public static void main(String[] args) {
        int [] arr={2,1,6,4,4,8,9,4,3};
        int [] ints = quickSort(arr, 0, arr.length-1);
        for (int i : ints){
            System.out.print(i+"    ");
        }

    }

    //冒泡排序
    //最好是O(n)，最差是O(n^2)，平均是O(n^2)
   public static int [] bubbleSort(int [] arr){
       if (arr.length == 0) return arr;
       for (int i = 0; i < arr.length; i++){
           for (int j = 0; j < arr.length - i - 1; j++){
               if(arr[j] > arr[j+1]){
                   int temp = arr[j];
                   arr[j] = arr[j+1];
                   arr[j+1] = temp;
               }
           }
       }
       return arr;
   }

    //选择排序
    //复杂度是O(n^2)
   public static int [] selectionSort(int [] arr){
       if(arr.length == 0) return arr;
       for (int i = 0; i < arr.length; i++){
           int minIndex = i;
           for (int j = i ; j < arr.length; j++){
               //在未排序的数组找出最小的数
               if(arr[j] < arr[minIndex])
                   minIndex = j;
           }
           //和前面的数交换
           int temp = arr[minIndex];
           arr[minIndex] = arr[i];
           arr[i] = temp;
       }
       return arr;
   }

    //插入排序
   public static int [] insertSort(int [] arr){
       if(arr.length == 0) return arr;
       int current;
       for (int i = 0; i < arr.length - 1; i++){
           //未排序的第一个元素：current
           current = arr[i+1];
           //已经排好序的最后一个元素：preIndex
           int preIndex = i;
           while ((preIndex >= 0 && current < arr[preIndex])){
               arr[preIndex + 1] = arr[preIndex];
               preIndex--;
           }
           arr[preIndex+1] = current;
       }
       return arr;
   }

    //归并排序（Merge Sort）
    //复杂度：O(NlogN)
    //思想：先分区，再排序
   public static int [] MergeSort(int [] arr, int start, int end) {
       if(start == end)
           return new int[]{arr[end]};
       int mid = start + ((end - start) >> 1);
       //先分开
       int [] left = MergeSort(arr, start, mid);
       int [] right = MergeSort(arr, mid + 1, end);
       int p1 = 0, p2 = 0, index = 0;
       int [] copy = new int[left.length + right.length];
       //再合并
       while (p1 < left.length && p2 < right.length){
           if(left[p1] <= right[p2])
               copy[index++] = left[p1++];
           else
               copy[index++] = right[p2++];
       }
       while (p1 < left.length)
           copy[index++] = left[p1++];
       while (p2 < right.length)
           copy[index++] = right[p2++];

       return copy;
   }

    //快速排序
    //先排序，再分区
    //每次小于pivot的在左边，大于基准值pivot的在右边
   public static int [] QuickSort(int [] arr, int start, int end){
       if(arr.length == 0 || start < 0 || end > arr.length || start > end)
           throw new RuntimeException("error");
       int smallIndex = partition(arr, start, end);
       if(smallIndex > start)
           QuickSort(arr, start, smallIndex - 1);
       if (smallIndex <end)
           QuickSort(arr, smallIndex + 1, end);
       return arr;
   }
   //分区函数:返回pivot基准值
   public static int partition(int [] arr, int start, int end){
       int pivot =(int)( start + (Math.random() * (end - start + 1)));
       swap(arr, pivot, end);
       int smallIndex = start - 1;
       for(int i = start; i <= end; i++){
           if(arr[i] <= arr[end]){
               smallIndex ++;
               if(smallIndex < i)
                   swap(arr, i, smallIndex);
           }
       }
       return smallIndex;
   }
   public static void swap(int [] arr, int i, int j){
       int tmp = arr[i];
       arr[i] = arr[j];
       arr[j] = tmp;
   }

}