西安交通大学915考研--编程题Java代码踩坑（2019年真题）

西安交通大学915考研–编程题Java代码踩坑（2019年真题）

2019.1–寻找包含所有点坐标的最小的矩形

问题描述：
接收若干形如(2,3)的点的坐标，输出包含所有点坐标的最小的矩形的左下和右上顶点坐标，特别的若只接收单个点的坐标，则输出这个点。
注：接收点的坐标以(0,0)作为结束。

思路：

1. 考虑用数组存储每一个点，点集使用ArrayList<int[]> arrayList 来存储
2. 接收点坐标完毕后，再遍历点集，找到minX,maxX,minY,maxY
3. 最后，判断输出，如果输入的是单个点，则输出单个点，否则，输出左下和右上点的坐标

代码实现：

package Ayan;

import java.util.ArrayList;
import java.util.Scanner;

/**
 * @Author: cc雪影
 * @Description：
 * @Date： Create in 14:05  2022/1/16
 */
public class A2019_01 {
    public static int minX;
    public static int minY;
    public static int maxX;
    public static int maxY;
    public static ArrayList<int[]> arrayList = new ArrayList();

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (true) {
            //接收点的坐标
            String string = in.nextLine();
            if (string.equals("(0,0)")) {
                break;
            }
            int a[] = new int[2];
            String s[];
            string = change(string);
            s = string.split(",");
            //将点的坐标存进数组里
            a[0] = Integer.parseInt(String.valueOf(s[0]));
            a[1] = Integer.parseInt(String.valueOf(s[1]));
            arrayList.add(a);//将数组再放进arrayList，好处是可以添加任意多个节点，比较灵活
        }
        in.close();
        judgeAndOut();//判断并输出结果
    }

    public static String change(String s) {
        /**
         * @description： 将接收的字符串坐标，去除左括号和右括号
         * @param s
         * @createDate: 2022/1/16 14:07
         * @return: java.lang.String
         */
        StringBuffer stringBuffer = new StringBuffer();
        for (char a : s.toCharArray()) {
            if (a - '(' == 0 || a - ')' == 0) {
                continue;
            } else {
                stringBuffer.append(a);
            }
        }
        return stringBuffer.toString();
    }

    public static int getMax(int a, int b) {
        /**
         * @description： 返回两者中的较大者
         * @param a
         * @param b
         * @createDate: 2022/1/16 14:08
         * @return: int
         */
        if (a >= b) {
            return a;
        } else {
            return b;
        }
    }

    public static int getMin(int a, int b) {
        /**
         * @description：返回两者中的较小者
         * @param a
         * @param b
         * @createDate: 2022/1/16 14:09
         * @return: int
         */
        if (a <= b) {
            return a;
        } else {
            return b;
        }
    }

    public static void judgeAndOut() {
        /**
         * @description： 做输出的判断并输出结果
         * 如果输入的是单个点，则输出单个点，否则，输出左下和右上点的坐标
         * @createDate: 2022/1/16 14:09
         * @return: void
         */
        if (arrayList.size() == 1) {
            System.out.println("(" + arrayList.get(0)[0] + "," + arrayList.get(0)[1] + ")");
        } else {
            fun();
            System.out.print("(" + minX + "," + minY + ")" + "   ");
            System.out.print("(" + maxX + "," + maxY + ")");
        }
    }

    public static void fun() {

        /**
         * @description： 遍历arrayList，找到 minX,maxX,minY,maxY,即左下和右上点的坐标
         * @createDate: 2022/1/16 14:21
         * @return: void
         */
        minX = arrayList.get(0)[0];
        maxX = arrayList.get(0)[0];
        minY = arrayList.get(0)[1];
        maxY = arrayList.get(0)[1];
        for (int i = 1; i < arrayList.size(); i++) {
            minX = getMin(arrayList.get(i)[0], minX);
            minY = getMin(arrayList.get(i)[1], minY);
            maxX = getMax(arrayList.get(i)[0], maxX);
            maxY = getMax(arrayList.get(i)[1], maxY);
        }
    }
}

输入输出：

(2,7)
(4,1)
(3,0)
(9,8)
(8,10)
(0,0)
(2,0)   (9,10)

2019.2–回文串的检测（递归与非递归实现）

问题描述：
接收一个字符串，使用递归与非递归的方法分别判断其是否为回文。所谓回文字符串，是指从左到右读和从右到左读完全相同的字符串。主要涉及知识点：字符数组的输入输出，及相应的处理。

解题思路

1. 非递归实现：可以从字符串的两头开始比较，即第1个字符和倒数第1个字符比较，第2个字符和倒数第2个字符比较，以此类推…如果出现字符不相等的情况，说明不是回文，如果全部相等，说明是回文。
2. 递归实现：依次判断前后字符是否相等，相等则返回子问题（++low，–high），否则直接返回false

代码实现：

package Ayan;

import java.util.Scanner;

/**
 * @Description：
 * @Author: cc雪影
 * @Date：16:10 2022/1/17
 */
public class A2019_02 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String string = in.nextLine();
//        boolean s=isH("abba",0,3);
        System.out.println(isH(string, 0, string.length() - 1));
        System.out.println(isHui(string));
    }

    public static boolean isH(String string, int low, int high) {
        /**
         * @description： 递归依次判断前后字符是否相等，相等则返回子问题（++low，--high）
         * @param string
         * @param low
         * @param high
         * @createDate: 2022/1/17 16:09
         * @return: boolean
         */
        if (low >= high) {//如果low已经不再小于high，说明前面判断一直是成功的，因此是回文串
            return true;
        }
        if (string.charAt(low) - string.charAt(high) == 0) {//如果相等，就继续返回子问题
            return isH(string, ++low, --high);//先修改值，再传参
        } else {
            return false;//只要有一个字符前后不相等，就直接返回false退出递归
        }
    }

    public static boolean isHui(String string) {
        /**
         * @description： 回文串检测的非递归实现
         * low high 指针依次比较是否相等，不相等就返回false
         * 否则循环结束，返回true
         * @param string
         * @createDate: 2022/1/17 16:17
         * @return: boolean
         */
        for (int low = 0, high = string.length() - 1; low < high; low++, high--) {
            if (string.charAt(low) - string.charAt(high) != 0) {
                return false;
            }
        }
        return true;

    }

}

输入输出：

12gh76y67hg21
true
true

12gh7y67hg21
false
false

2019.3–求整数序列的逆序数

思路：

1. 将整数序列进行归并操作，并计算交换次数
2. 当发生交换时，逆序数增加，相当于后边的数往前拿，变成有序，逆序数增加mid-j+1
   代码实现：

package Ayan;

/**
 * @Description：
 * @Author: cc雪影
 * @Date：16:20 2022/1/17
 */
public class A2019_03 {
    public static int arr1[] = {3, 1, 4, 5, 2, 8, 7, 6};
    public static int array[] = new int[arr1.length + 1];//申请辅助数组
    public static int count = 0;//逆序数

    public static void main(String[] args) {
        System.out.print("原数组：");
        for (int a : arr1) {
            System.out.print(a + " ");
        }
        mergeSort(arr1, 0, arr1.length - 1);
        System.out.println();
        System.out.print("合并排序后：");
        for (int a : arr1) {
            System.out.print(a + " ");
        }
        System.out.println();
        System.out.println("原数组中的逆序对数是：" + count);
    }

    public static void merge(int arr[], int low, int mid, int high) {
        /**
         * @description：合并操作
         * @param arr  arr数组的两段A[low...mid]，A[mid...high]是各自有序的
         * @param low
         * @param mid
         * @param high
         * @createDate: 2022/1/17 16:20
         * @return: void
         */
        for (int m = low; m <= high; m++) {//数组中的元素复制到辅助数组中
            array[m] = arr[m];
        }
        int i, j, k;
        for (j = low, i = low, k = mid + 1; j <= mid && k <= high; i++) {//不断选择最小值，如果条件不满足，循环结束
            if (array[j] <= array[k]) {
                arr[i] = array[j++];
            } else {
                arr[i] = array[k++];
                count = count + mid - j + 1;//当发生交换时，逆序数增加，相当于后边的数往前拿，变成有序，逆序数增加mid-j+1
            }
        }
        //循环结束，需要把未检测完的表复制到arr
        while (j <= mid) {
            arr[i++] = array[j++];
        }
        while (k <= high) {
            arr[i++] = array[k++];
        }
    }

    public static void mergeSort(int arr[], int low, int high) {
        /**
         * @description：归并排序
         * 递归形式的2路归并排序算法是基于分治的
         * @param arr
         * @param low
         * @param high
         * @createDate: 2022/1/17 16:21
         * @return: void
         */
        if (low < high) {
            int mid = (low + high) / 2;//从中间划分两个子序列
            mergeSort(arr, low, mid);//对左侧子序列进行递归排序
            mergeSort(arr, mid + 1, high);//对右侧子序列进行递归排序
            merge(arr, low, mid, high);//合并两个已排序的字表得到排序结果
        }//if
    }

}

输入输出：

原数组：3 1 4 5 2 8 7 6 
合并排序后：1 2 3 4 5 6 7 8 
原数组中的逆序对数是：7

2019年题目结束，这里是传送门：
西安交通大学915考研–编程题Java代码踩坑（2015年真题）
西安交通大学915考研–编程题Java代码踩坑（2016年真题）
西安交通大学915考研–编程题Java代码踩坑（2017年真题）
西安交通大学915考研–编程题Java代码踩坑（2018年真题）