private int tobeSort[] = {2, 3, 6, 1, 8, 5, 4, 9, 7, 10};
private int length = tobeSort.length;

private void bubbleSort() {
    for (int i = 0; i < length - 1; i++) {
        for (int j = 0; j < length - 1 - i; j++) {
            if (tobeSort[j] > tobeSort[j + 1]) {
                int temp = tobeSort[j];
                tobeSort[j] = tobeSort[j + 1];
                tobeSort[j + 1] = temp;
            }
        }
    }
}

private void sort_1() {
   //N个数组元素，就需要循环N-1轮
    for (int i = 0; i < length - 1; i++) {
        //最小数的索引，该索引每次都根据外层循环的计数器来觉得初始值。
        int minIndex = i;
        for (int j = i + 1; j < length; j++) {
            //根据最小数的索引，判断当前这个数是否小于最小数。
            //如果小于，则把当前数的索引作为最小数的索引。否则不处理。
            if (tobeSort[minIndex] > tobeSort[j]) {
                minIndex = j;
            }
            //直到循环完成的时候，minIndex肯定就是当前这轮循环中，最小的那个。
        }
       //得到最小数的索引后，把该索引对应的值放到最左边，并且把最左边的值放到索引所在的位置.
        //最左边的值
        int temp = tobeSort[i];
        //把最小数索引对应的值放到最左边
        tobeSort[i] = tobeSort[minIndex];
        //把原来最左边对应的值放到最小数索引所在的位置
        tobeSort[minIndex] = temp;
    }
}

private void insertSort() {
    for (int i = 0; i < length - 2; i++) {
        if (tobeSort[i] > tobeSort[i + 1]) {
            int temp = tobeSort[i + 1];
            int j = i;
            tobeSort[i + 1] = tobeSort[i];
            while (j > 0 && tobeSort[j - 1] > temp) {
                tobeSort[j] = tobeSort[j - 1];
                j--;
            }
            tobeSort[j] = temp;
        }
    }
}

private void quickSort(int left, int right) {
    int i = left;
    int j = right;
    int standard = tobeSort[left];//基准数
    while (left != right) {
        //从右边找比基准数小的数字
        while (tobeSort[right] >= standard && left < right) {
            right--;
        }
        //从左边找比基准数大的数字
        while (tobeSort[left] <= standard && left < right) {
            left++;
        }
        if (left < right) {
            int temp = tobeSort[right];
            tobeSort[right] = tobeSort[left];
            tobeSort[left] = temp;
        }
    }
    //基准数归位
    tobeSort[i] = tobeSort[left];
    tobeSort[left] = standard;
    //递归
    if (i < (left - 1))
        quickSort(i, left - 1);//左边排序
    if ((left + 1) <= j)
        quickSort(left + 1, j);//右边排序
}

private void heapSort() {
    for (int i = 0; i < length; i++) {
        createMaxHeap(tobeSort, length - 1 - i);
        if (0 != length - 1 - i) {
            tobeSort[0] = tobeSort[0] + tobeSort[length - 1 - i];
            tobeSort[length - 1 - i] = tobeSort[0] - tobeSort[length - 1 - i];
            tobeSort[0] = tobeSort[0] - tobeSort[length - 1 - i];
        }
    }
}
private void createMaxHeap(int[] array, int lastIndex) {
    for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
        //保存当前正在判断的节点
        int k = i;
        //若当前节点的子节点存在
        while (2 * k + 1 <= lastIndex) {
           //biggerIndex总是记录较大的节点的值，先赋值为当前判断节点的左子节点
           int biggerIndex = 2 * k + 1;
           if (biggerIndex < lastIndex) {
                // 若右子节点存在，否则此时biggerIndex应该等于 lastIndex
                if (array[biggerIndex] < array[biggerIndex + 1]) {
                   // 若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的值
                   biggerIndex++;
                }
            }
            if (array[k] < array[biggerIndex]) {
                // 若当前节点值比子节点最大值小，则交换2者得值，交换后将biggerIndex值赋值给k
                if (0 != length - 1 - i) {
                    array[k] = array[k] + array[biggerIndex];
                    array[biggerIndex] = array[k] - array[biggerIndex];
                    array[k] = array[k] - array[biggerIndex];
                }
                k = biggerIndex;
            } else {
                break;
            }
        }
    }
}

private void shellSort() {
    int d = length / 2;
    while (d >= 1) {
        for (int i = 0; i < d; i++) {
            //插入排序
            for (int j = i + d; j < length - 2; j += d) {
                if (tobeSort[j] > tobeSort[j + 1]) {
                    int temp = tobeSort[j + 1];
                    int k = j;
                    tobeSort[j + 1] = tobeSort[j];
                    while (k > 0 && tobeSort[k - 1] > temp) {
                        tobeSort[k] = tobeSort[k - 1];
                        k--;
                    }
                    tobeSort[k] = temp;
                }
            }
        }
        d /= 2;
    }
}

/**
 * 将有二个有序数列a[first...mid]和a[mid...last]合并。
 */
void mergearray(int a[], int first, int mid, int last, int temp[]) {
    int i = first, j = mid + 1;
    int m = mid, n = last;
    int k = 0;
    while (i <= m && j <= n) {
        if (a[i] <= a[j])
            temp[k++] = a[i++];
        else
            temp[k++] = a[j++];
    }
    while (i <= m)
        temp[k++] = a[i++];
    while (j <= n)
        temp[k++] = a[j++];
    for (i = 0; i < k; i++)
        a[first + i] = temp[i];
}
void mergesort(int a[], int first, int last, int temp[]) {
    if (first < last) {
        int mid = (first + last) / 2;
        mergesort(a, first, mid, temp);    //左边有序
        mergesort(a, mid + 1, last, temp); //右边有序
        mergearray(a, first, mid, last, temp); //再将二个有序数列合并
    }
}
boolean MergeSort(int a[], int n) {
    int[] tmp = new int[n];
    mergesort(a, 0, n - 1, tmp);
    return true;
}