排序算法比较

冒泡：

static int[] bubbleSort(int[] data) {
    System.out.println(Arrays.toString(data));
    for (int i = data.length - 1; i >= 0; i--) {
        for (int j = 0; j < i; j++) {
            if (data[j] > data[j + 1]) {
                int temp = data[j];
                data[j] = data[j + 1];
                data[j + 1] = temp;
            }
        }
        System.out.println(Arrays.toString(data));
    }
    return data;
}

选择：

static int[] selectionSort(int[] data) {
    System.out.println(Arrays.toString(data));
    for (int i = 0; i < data.length; i++) {
        int min = data[i];
        int index = i;
        for (int j = i + 1; j < data.length; j++) {
            if (data[j] < min) {
                min = data[j];
                index = j;
            }
        }
        if (index != i) {
            int temp = data[i];
            data[i] = data[index];
            data[index] = temp;
        }
        System.out.println(Arrays.toString(data));
    }
    return data;
}

插入：

static int[] insertSort(int[] arr, int len) {
    System.out.println(Arrays.toString(arr));
    int i;
    int j;
    int temp;
    for (i = 1; i < len; i++) {
        for (j = 0; j < i; j++) {
            if (arr[j] > arr[i]) {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    return arr;
}

归并（递归）：

static void mergeSort(int[] arr, int left, int right) {
    if (left < right) {
        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid);
        mergeSort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}
static void merge(int[] arr, int left, int mid, int right) {
    int low = left;
    int high = mid + 1;
    int[] temp = new int[right - left + 1];
    int tempIndex = 0;
    while (low <= mid && high <= right) {
        if (arr[low] < arr[high]) {
            temp[tempIndex++] = arr[low++];
        } else {
            temp[tempIndex++] = arr[high++];
        }
    }
    while (low <= mid) {
        temp[tempIndex++] = arr[low++];
    }
    while (high <= right) {
        temp[tempIndex++] = arr[high++];
    }
    System.arraycopy(temp, 0, arr, left, temp.length);
}

归并非递归：

static void mergeSort1(int[] data) {
    if (data == null)
        return;
    int space = 2;
    while (space < data.length) {
        merge(data, space);
        space = space << 1;
    }
    // 还需要一次归并
    merge(data, space);
    System.out.println(Arrays.toString(data));
}
static void merge(int[] data, int space) {
    // 这一步是，传入的space是需要对里面进行归并的大小
    // 除于2，temp值就是已经排好序的数组块的长度
    int temp = space >> 1;
    // 会改变的index
    int leftStart = 0;
    int rightStart = temp;
    // 数组块归并时候的边界
    int left = 0;
    int right = space;
    do {
        int[] tempData = new int[space];
        int tempIndex = 0;
        // 条件的变动，可能最后一块归并的长度不够space，但是rightStart还是存在且小于数组的边界
        while (leftStart < (left + temp) && rightStart < right && rightStart < data.length) {
            if (data[leftStart] < data[rightStart]) {
                tempData[tempIndex++] = data[leftStart++];
            } else {
                tempData[tempIndex++] = data[rightStart++];
            }
        }
        while (leftStart < (left + temp)) {
            tempData[tempIndex++] = data[leftStart++];
        }
        while (rightStart < right && rightStart < data.length) {
            tempData[tempIndex++] = data[rightStart++];
        }
        // leftStart是关键，需要改变，copy时候的长度，到这一步rightStart已经遍历完规定的数组块
        System.arraycopy(tempData, 0, data, left, rightStart - left);
        // 重新分配归并的边界，和 2个指针的位置
        leftStart = right;
        rightStart = leftStart + temp;
        left = leftStart;
        right = leftStart + space;
    } while (rightStart < data.length);
}

快排（递归）：

static void quickSort(int[] data, int start, int end) {
    if (start >= end) return;
    int temp = data[start];
    int left = start + 1;
    int right = end;
    while (left < right) {
        while (data[right] > temp && left < right) {
            right--;
        }
        while (data[left] < temp && left < right) {
            left++;
        }
        if (left < right) {
            int temp1 = data[left];
            data[left] = data[right];
            data[right] = temp1;
        }
    }
    if (left != (start + 1) || data[left]<data[start]) {
        data[start] = data[left];
        data[left] = temp;
    }
    quickSort(data, start, left - 1);
    quickSort(data, left + 1, end);
}

快排（非递归）：

static void quickSort3(int[] data, int start, int end) {
    if (start > end || data == null)
        return;
    Stack<Integer> stack = new Stack<>();
    stack.push(start);
    stack.push(end);
    while (!stack.isEmpty()) {
        Integer right = stack.pop();
        Integer left = stack.pop();
        if (left<right) {
            int partition = partition(data, left, right);
            stack.push(left);
            stack.push(partition-1);
            stack.push(partition+1);
            stack.push(right);
        }
    }
}

static int partition(int[] data, int start, int end) {
    int temp = data[start];
    int left = start + 1;
    int right = end;
    while (left < right) {
        while (data[right] > temp && left < right) {
            right--;
        }
        while (data[left] < temp && left < right) {
            left++;
        }
        if (left < right) {
            int temp1 = data[left];
            data[left] = data[right];
            data[right] = temp1;
        }
    }
    if (left != (start + 1) || data[left] < temp) {
        data[start] = data[left];
        data[left] = temp;
    }
    return left;
}