Java编程题——重排序列（整型数组的排序（升降）、反转、截取、合并）

题目描述

给定一个长度为N的序列A[1]到A[N],现在要要对序列进行M次操作，每次操作对序列的前若干个项进行升序或者是降序，求经过M次操作后得到的序列

输入描述

第一行包含两个整数N和M，1<=N,M<=10^5.
第二行包含N个空格隔开的整数A[1]到A[N]，1<=A[i]<=10^9
接下来M行每行包含两个整数t和x，0<=t<=1,1<=x<=N,若t=0则表示对A[1]到A[x]进行升序排列，若t=1则表示对A[1]到A[x]进行降序排列

输出描述

输出对N个空格隔开的整数，即经过M次操作后得到的序列

样例输入

4 2
1 2 4 3
1 3
0 2

样例输出

2 4 1 3 

代码

import java.util.Arrays;
import java.util.Scanner;

/**
 * @Author ：JieFighting
 * @Date ：2022/4/24 15:11
 * @Description：
 */
public class Main {
    /**
     * @params i 升序/降序 newArray 被操作数组 x 数组中前几个数参与操作
     * @return 整数数组
     * @author fuzhijie
     * 数组操作主函数
     */
    static int[] sortNum(int i, int[] newArray, int x) {
        int n = x;
        int[] oldArray = Arrays.copyOfRange(newArray, 0, n);
        //升序
        if (i == 0) {
            Arrays.sort(oldArray);
        } else if (i == 1) {//降序
            Arrays.sort(oldArray);
            oldArray = reverse(oldArray,oldArray.length);
        } else {
            return null;
        }
        return concat(oldArray,Arrays.copyOfRange(newArray,n++,newArray.length));

    }
    //合并数组
    static int[] concat(int[] a, int[] b) {
        int[] c= new int[a.length+b.length];
        System.arraycopy(a, 0, c, 0, a.length);
        System.arraycopy(b, 0, c, a.length, b.length);
        return c;
    }

    /* 反转数组*/
    static int[] reverse(int a[], int n) {
        int[] b = new int[n];
        int flag = (n-1);
        for(int i = 0; i < n; i++){
            b[i] = a[flag];
            flag--;
        }
        return b;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] ints = new int[2];  //输入长度 操作次数
//        System.out.println("请先输入数组大小以及要操作的次数：");
        for (int i = 0; i < ints.length; i++) {
            ints[i] = sc.nextInt();
        }
//        System.out.println("请输入被操作的数组：");
        int[] ints2 = new int[ints[0]];   //被操作的数组
        for (int i = 0; i < ints2.length; i++) {
            ints2[i] = sc.nextInt();
        }
//        System.out.println("请输入对该数组进行的操作：");
        int[][] ints3 = new int[ints[1]][2];
        for (int i = 0; i < ints3.length; i++) {
            for (int y = 0; y < 2; y++) {
                ints3[i][y] = sc.nextInt();
            }
            //根据操作数组该操作序列 0 升序 1 降序 前1到x个整数
        }
        //操作函数
        int[] finalArray = new int[ints[0]];
        for (int i = 0; i < ints3.length; i++) {
            ints2 = sortNum(ints3[i][0], ints2, ints3[i][1]);
        }
//        System.out.println("操作后得到的数组为：");
        for (int i : ints2) {
            System.out.print(i + " ");
        }

    }

}

注：这个编程题涉及到对数组的排序、反转、截取、合并等操作，涉及到的点较多；如果有错误，欢迎指正

一些用于操作整型数组的自定义函数

两个数组合并

  static int[] concat(int[] a, int[] b) {
        int[] c = new int[a.length + b.length];
        System.arraycopy(a, 0, c, 0, a.length);
        System.arraycopy(b, 0, c, a.length, b.length);
        return c;
    }

数组反转

static int[] reverse(int a[], int n) {
        int[] b = new int[n];
        int flag = (n - 1);
        for (int i = 0; i < n; i++) {
            b[i] = a[flag];
            flag--;
        }
        return b;
    }

数组排序

Arrays.sort(newArray); //默认使用升序方式
//降序 = 升序->反转
int[] oldArray = reverse(newArray,newArray.length);
//反转
static int[] reverse(int a[], int n) {
        int[] b = new int[n];
        int flag = (n - 1);
        for (int i = 0; i < n; i++) {
            b[i] = a[flag];
            flag--;
        }
        return b;
    }

注：这里自己对于数组降序为了图省事就直接采用了：数组排序（默认升序）->数组反转，还有许多更简单的方法，希望大家补充