排序

import sys
def solution():
    length = int(sys.stdin.readline().strip())#貌似用不到
    nums = sorted(list(map(int, input().split())))
    order = int(sys.stdin.readline().strip())
    if order == 0:
        print(*nums)
    else:
        print(*nums[::-1])
solution()

#include <iostream>
using namespace std;
int main()
{
	int Array_Number,Array[10000],iSortFlag,temp;
	while(cin>>Array_Number)
	{
		for(int i=0;i<Array_Number;i++)
			cin>>Array[i];
		cin>>iSortFlag;
		if(iSortFlag==1)//降序排序
		{
			for(int j=0;j<Array_Number;j++)
			{
				for(int k=0;k<Array_Number-j-1;k++)
				{
					if(Array[k]<Array[k+1])
					{
						temp=Array[k];
						Array[k]=Array[k+1];
						Array[k+1]=temp;
					}
				}
			}
		}
		else//升序排序
		{
			for(int j=0;j<Array_Number;j++)
			{
				for(int k=0;k<Array_Number-j-1;k++)
				{
					if(Array[k]>Array[k+1])
					{
						temp=Array[k];
						Array[k]=Array[k+1];
						Array[k+1]=temp;
					}
				}
			}
		}
		//输出排序后的数组
		for(int i=0;i<Array_Number-1;i++)
			cout<<Array[i]<<' ';
        cout<<Array[Array_Number-1]<<endl;
	}
}

#include <stdio.h>

int count;

void sortIntegerArray(int *array, int flag)
{
    int temp;
    int i, j;
    for(i = 0; i < count; i++ )
    {
        for(j = i + 1; j <= count -1; j++)
        {
            if(0 == flag)
            {
                if(array[i] > array[j])
                {
                    temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
            }
            else
            {
                if(array[i] < array[j])
                {
                    temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
            }
        }
    }
}

int main(int argc, char *argv[])
{
    int i;
    int flag;
    int array[1024] = {0};
    
    while(scanf("%d", &count) != EOF)
    {
        for(i = 0; i < count; i++)
        {
            scanf("%d", &array[i]);
        }
        scanf("%d", &flag);
        
        sortIntegerArray(array, flag);
        for(i = 0; i < count; i++)
        {
            if(i == count - 1 )
            {
                printf("%d\n", array[i]);
                break;
            }
            printf("%d ", array[i]);
        }
    }
    
    return 0;
}

n = input()
lst = input().split(' ')
lst_num = [int(x) for x in lst]
tag = int(input())
lst_num.sort(reverse=tag)
for num in lst_num:
    print(num, end=' ')

#include <bits/stdc++.h>
using namespace std;
bool cmp(int a,int b)//从大到小排序
{
    return a>b;
}
int main()
{
    int n=0,num;
    cin>>n;//输入数组的个数
    vector<int>result;
    while(n--)//每次输入一个数据就减少一个
    {
        cin>>num;//
        result.push_back(num);
    }
    int a;
    cin>>a;//输入0/1
    if(a==0)//如果是0则升序
    {
        sort(result.begin(),result.end());
        for(auto i:result)
            cout<<i<<" ";
            cout<<endl;
    }
    else//如果是1则降序
    {
        sort(result.begin(),result.end(),cmp);
        for(auto i:result)
            cout<<i<<" ";
            cout<<endl;
    }
  return 0;  
}

#include<stdio.h>
#include<string.h>
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int two[n];
        scanf("%d",&two[0]);
        int thr;
        if(scanf("0",&thr))
        {
            for(int i=1;i<n;i++)
            {
                scanf("%d",&two[i]);
                for (int j=i;j>0;j--)
                {
                    if(two[j]<two[j-1])
                    {
                        int two0=two[j];
                        two[j]=two[j-1];
                        two[j-1]=two0;
                    }
                    else
                    {
                        break;
                    }
                }
                printf("%d",&two[i]);
            }
        }
        else
        {
            for(int i=1;i<n;i++)
            {
                scanf("%d",&two[i]);
                for (int j=i;j>0;j--)
                {
                    if(two[j]>two[j-1])
                    {
                        int two1=two[j];
                        two[j]=two[j-1];
                        two[j-1]=two1;
                    }
                    else
                    {
                        break;
                    }
                }
                printf("%d",&two[i]);
            }
        }
    }
    return 0;
}

import java.util.*;
public class Main{
    public static void main (String[] args){
        Scanner sc = new Scanner(System.in);
        int len = sc.nextInt();
        int[] num = new int[len];
        for (int i = 0; i < len; i++) {
            num[i] = sc.nextInt();
        }
        int mode = sc.nextInt();
        Arrays.sort(num);
        if (mode == 0){
            for (int i = 0; i < len; i++)
                System.out.print(num[i]+" ");
        } else {
         for (int i = len - 1; i >= 0; i--)
            System.out.print(num[i]+" ");
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        String[] split = br.readLine().split(" ");
        int[] arr = new int[split.length];
        for (int i = 0; i < split.length; i++) {
            arr[i] = Integer.parseInt(split[i]);
        }
        String s1 = br.readLine();
        if (s1.equals("0")) {
            quickSortIncrease(arr, 0, arr.length - 1);
            print(arr);
        } else {
            quickSortDecrease(arr, 0, arr.length - 1);
            print(arr);
        }
    }

    private static void quickSortIncrease(int[] arr, int left, int right) {
        if (left >= right) return;
        int i = left - 1, j = right + 1, mid = arr[(left + right) >> 1];
        while (i < j) {
            do i++; while (mid > arr[i]);
            do j--; while (mid < arr[j]);
            if (i < j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        quickSortIncrease(arr, left, j);
        quickSortIncrease(arr, j + 1, right);
    }

    private static void quickSortDecrease(int[] arr, int left, int right) {
        if (left >= right) return;
        int i = left - 1, j = right + 1, mid = arr[(left + right) >> 1];
        while (i < j) {
            do i++; while (mid < arr[i]);
            do j--; while (mid > arr[j]);
            if (i < j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        quickSortDecrease(arr, left, j);
        quickSortDecrease(arr, j + 1, right);
    }

    private static void print(int[] arr) {
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}

# 方法一：
while True:
    try:
        count, arr = input(), map(int, input().strip().split(' '))
        flag = input().strip()
        if flag == '0':
            arr = sorted(arr)
            # print(arr)
        if flag == '1':
            arr = sorted(arr, reverse=True)
            # print(arr)
        print(' '.join(map(str, arr)))

    except:
        break

# 方法二：（reverse=True可以直接写成reverse=1）
while True:
    try:
        count, arr = input(), map(int, input().strip().split(' '))
        flag = int(input().strip())
        arr = sorted(arr, reverse=flag)
        print(' '.join(map(str, arr)))
    except:
        break

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,a[10000],flag,tmp;
        /**********输入**********/
    while(cin>>n)
    {
        for(int i=0;i<n;i++)
        {
            cin>>a[i];
        }
        cin>>flag;
        /**********冒泡排序**********/
        for(int j=0;j<n-1;j++)
            for(int k=j+1;k<n;k++)
            {
                if(a[j]>a[k])
                {
                    tmp=a[j];
                    a[j]=a[k];
                    a[k]=tmp;
                }
            }
        /**********升序输出**********/
        if(flag==0)
        {
            for(int i=0;i<n-1;i++)
            {
                cout<<a[i]<<" ";
            }
            cout<<a[n-1];
        }
        /**********降序输出**********/
        if(flag==1)
        {
            for(int i=n-1;i>0;i--)
            {
                cout<<a[i]<<" ";
            }
            cout<<a[0];
        }
        cout<<endl;
    }
    return 0;
}

while 1:
    try:
        num,l,flag=input(),list(map(int, input().split())),int(input())
        print(' '.join(map(str,sorted(l,reverse=flag))))
    except:
        break

while True:
    try:
        def quick_sort(arr, left, right):
            """快速排序"""
            if left >= right:
                return arr
            key = arr[left]
            low = left
            high = right
            while left < right:
                while left < right and arr[right] >= key:
                    right -= 1
                arr[left] = arr[right]
                while left < right and arr[left] <= key:
                    left += 1
                arr[right] = arr[left]
            arr[right] = key
            quick_sort(arr, low, left - 1)
            quick_sort(arr, left + 1, high)
            return arr


        total_num = int(input())
        input_list = list(map(int, input().strip().split()))
        descending = int(input())

        if len(input_list) == 1:
            print(input_list[0])
        if descending == 0:
            print(" ".join(list(map(str, quick_sort(input_list, 0, len(input_list) - 1)))))
        else:
            print(" ".join(list(map(str, quick_sort(input_list, 0, len(input_list) - 1)[::-1]))))

    except:
        break

快速排序实现基本功能，通过列表索引实现逆序

#include <iostream>
#include <vector>
using namespace std;
void quick_sort(vector&v,int start,int end,int& sort_flag)
{
    if(start >= end)
        return;
    int low = start,high = end;
    int pivot = v[start];
    while(low < high)
    {
        if(sort_flag == 0)
            while(low =pivot) high--;
        else
            while(low < high && v[high]<=pivot) high--;
        v[low] = v[high];
        if(sort_flag == 0)
            while(low < high && v[low]<=pivot) low++;
        else
            while(low =pivot) low++;
        v[high] = v[low];
    }
    v[low] = pivot;
    quick_sort(v,start, low-1, sort_flag);
    quick_sort(v, low+1, end, sort_flag);
}
int main()
{
    int n;
    while(cin >> n)
    {
        vector v(n,0);
        for(int i=0;i<n;++i)
            cin >> v[i];
        int sort_flag;
        cin >> sort_flag;
        quick_sort(v, 0, n-1, sort_flag);
        for(int i=0;i<n;++i)
            cout << v[i] << " ";
        cout << endl;
    }
    return 0;
}