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

西安交通大学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);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

输入输出：

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

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;

    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

输入输出：

12gh76y67hg21
true
true

12gh7y67hg21
false
false
1
2
3
4
5
6
7

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
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

输入输出：

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

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