冒泡排序：

    1. package com.example.interview.leecode.codel;
    3. import java.util.Arrays;
    5. public class CodeL003 {
    6.     //冒泡排序
    7.     public static void main(String[] args) {
    9.         int[] tests = {12, 434, 234, 32324, 3};
    10.         System.out.println(Arrays.toString(new CodeL003().array(tests)));
    12.     }
    13.     //若逻辑就是第一层和第二层对比，然后就是找出一个最大的
    14.     public int[] array(int[] arr) {
    15.         //这是找出一个最大值
    16.         for (int i = 0; i < arr.length - 1; i++) {
    17.             //这是对比所有的数据
    18.             for (int i1 = 0; i1 < arr.length - 1 - i; i1++) {
    20.                 if (arr[i1] > arr[i1 + 1]) {
    21.                     int i2 = arr[i1];
    22.                     arr[i1] = arr[i1 + 1];
    23.                     arr[i1 + 1] = i2;
    24.                 }
    25.             }
    26.         }
    27.         return arr;
    28.     }
    29. }

    简单排序：

    1. public static void sort(int[] a) {
    2.     for (int i = 0; i < a.length; i++) {
    3.         int min = i;
    4.         //选出之后待排序中值最小的位置
    5.         for (int j = i + 1; j < a.length; j++) {
    6.             if (a[j] < a[min]) {
    7.                 min = j;
    8.             }
    9.         }
    10.         //最小值不等于当前值时进行交换
    11.         if (min != i) {
    12.             int temp = a[i];
    13.             a[i] = a[min];
    14.             a[min] = temp;
    15.         }
    16.     }
    17. }

    使用递归的快速排序：

    1. public static void sort(int[] a, int low, int high) {
    2.     //已经排完
    3.     if (low >= high) {
    4.         return;
    5.     }
    6.     int left = low;
    7.     int right = high;
    9.     //保存基准值
    10.     int pivot = a[left];
    11.     while (left < right) {
    12.         //从后向前找到比基准小的元素
    13.         while (left < right && a[right] >= pivot)
    14.             right--;
    15.         a[left] = a[right];
    16.         //从前往后找到比基准大的元素
    17.         while (left < right && a[left] <= pivot)
    18.             left++;
    19.         a[right] = a[left];
    20.     }
    21.     // 放置基准值，准备分治递归快排
    22.     a[left] = pivot;
    23.     sort(a, low, left - 1);
    24.     sort(a, left + 1, high);
    25. }