题解 | #输入整型数组和排序标识，对其元素按照升降序排序#

import java.util.Scanner;

public class Main {
    // 交换数组元素
    public static void swap (int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    // 从小到大冒泡排序（沒有用到，只是復習一下）
    public static void bubbleSort (int[] arr, int left, int right) {
        boolean flag = false;
        for (int i = right; i > left; i--) {
            // 重置爲false，记录是否还需要交换
            flag = false;
            for (int j = left; j < right; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                    flag = true;
                }
            }
            // 不需要交换了，说明完全有序，排序完成
            if (!flag) {
                return;
            }
        }
    }

    // 从小到大插入排序
    public static void insertionSort (int[] arr, int left, int right) {
        int tmp = 0;
        int j = 0;
        // 從第二個元素開始插入，直到最後一個
        for (int i = left + 1; i <= right; i++) {
            // 存儲要插入的元素
            tmp = arr[i];
            // 將大於tmp的元素依次後移，直到下一個元素小於等於tmp，或j == left 爲止
            for (j = i; j > left && arr[j - 1] > tmp; j--) {
                arr[j] = arr[j - 1];
            }

            // 此時j的位置就是tmp要插入的位置
            arr[j] = tmp;
        }
    }

    // 如果前者比後者大，交換兩個元素
    public static void swap2 (int[] arr, int i, int j) {
        if (arr[i] > arr[j]) {
            swap(arr, i, j);
        }
    }

    // 快速排序：找主元
    public static int median (int[] arr, int left, int right) {
        int center = (left + right) / 2;
        // 確保左中右三者有序
        swap2(arr, left, center);
        swap2(arr, center, right);
        swap2(arr, left, center);
        int pivot = arr[center];
        // 將主元藏到後面，這樣只需要操作left + 1 到 right - 2
        swap(arr, center, right - 1);

        return pivot;
    }

    // 從小到大快速排序
    public static void quickSort (int[] arr, int left, int right) {
        // 元素太少了，直接用插入排序
        if (right - left <= 50) {
            insertionSort(arr, left, right);
            return;
        }

        int pivot = median(arr, left, right);
        int i = left, j = right - 1;
        while (true) {
            // 如果相等要停下來做交換，確保最後的主元落在比較中間的位置
            while (arr[++i] < pivot);
            while (arr[--j] > pivot);
    
            // 主元位置確定了
            if (i >= j) {
                break;
            }

            // 交換元素
            swap(arr, i, j);
        }

        // 主元放回
        swap(arr, i, right - 1);

        // 遞歸排序左右子數組
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }

    // 按順序/逆序打印數組
    public static void print (int[] arr, int length, int flag) {
        // 順序
        if (flag == 0) {
            for (int i = 0; i < length - 1; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println(arr[length - 1]);
        } else {
            // 逆序
            for (int i = length - 1; i > 0; i--) {
                System.out.print(arr[i] + " ");
            }
            System.out.println(arr[0]);
        }
    }

    public static void main (String[] args) {
        Scanner sc = new Scanner(System.in);
        // 輸入數組元素個數
        int n = sc.nextInt();
        int arr[] = new int[n];
        // 輸入待排序數組
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        // 輸入排序方法
        int flag = sc.nextInt();

        // 從小到大快速排序
        quickSort(arr, 0, n - 1);

        // 升序即順序，降序即逆序
        print(arr, n, flag);

    }


}