西安交通大学915考研--编程题Java代码踩坑（2017年真题）_boolean flag=true 踩坑

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

2017.2–折半查找的实现（递归）

思路：

1. 初始low指针在0，high指针在最后
2. mid=(low+high)/2，判断mid处的值大小
3. 若大于目标值，说明应该在左边找，让high=mid-1；
4. 若小于目标值，说明应该在右边找，让low=mid+1；
5. 递归的出口，对于每层，mid处的值等于目标值，返回mid下标；递归的最后一层不满足low<=high,说明查找失败，目标值不存在

代码实现：

package com.xjtu;

/**
 * @Author: cc雪影
 * @Description： 折半查找
 */
public class A2016_03 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 5, 6, 8, 9, 12, 45, 78, 99, 123};
        System.out.println(Binsearch(arr, 0, arr.length - 1, 6));
    }

    public static int Binsearch(int[] arr, int low, int high, int k) {
        /**
         * @description： 递归实现折半查找
         * @param arr 存数据的【有序数组】
         * @param low 低位指针（数组下标）
         * @param high 高位指针（数组下标）
         * @param k  所要查找的目标值
         * @return: int
         */
        if (low <= high) {//low 要小于等于 high
            int mid = (low + high) / 2;
            if (arr[mid] == k) {
                return mid;//查找成功的递归出口
            } else if (arr[mid] < k) {//查找序列右一半
                return Binsearch(arr, mid + 1, high, k);
            } else {//查找序列左一半
                return Binsearch(arr, low, mid, k);
            }
        } else {//low>high,查找失败
            return -1;
        }
    }
}

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

输入输出：

4
1

2017.3–顺序栈的实现

思路：
共享栈的实现是基本知识，详细也可以见下边代码注释。

代码实现：

package com.xjtu;

/**
 * @Author: cc雪影
 * @Description： 两个顺序栈共用一个数组，即共享栈的实现
 * top1:栈1的栈顶指针，指向栈顶元素，栈空时值为-1
 * top2：栈2的栈顶指针，指向栈顶元素。栈空时值为100
 */
public class A2017_03 {
    public static int[] arr = new int[100];//申请长度为100的数组
    public static int top1, top2;//设置两个指针

    public static void S1_push(int num) {//栈1的压栈操作
        //首先判断共享栈是不是已经满了
        if (top2 - top1 == 1) {
            System.out.println("栈满！S1 无法压栈");
        } else {
            arr[++top1] = num;//先让指针加一，再把数据放进栈中
        }
    }

    public static int S1_pop() {//栈1的出栈操作
        if (top1 == -1) {
            System.out.println("栈空！S1 无法弹栈");
            return -1;
        } else {
            return arr[top1--];//先返回栈顶元素，后将指针减一
        }
    }

    public static void S2_push(int num) {//栈2的压栈操作
        if (top2 - top1 == 1) {
            System.out.println("栈满！S2 无法压栈");
        } else {
            arr[--top2] = num;//先让指针减一，再把数据放进栈中
        }
    }

    public static int S2_pop() {//栈2的出栈操作
        if (top2 == arr.length) {
            System.out.println("栈空！S2 无法弹栈");
            return -1;
        } else {
            return arr[top2++];//先返回栈顶元素，后将指针加一
        }
    }

}

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

2017.4–作业调度问题

问题描述：
n个作业，m个机器，机器每次只能执行一个文件，现在采取小作业优先（同等规模采取先来先服务）原则，问如何安排每一台机器的作业分配。

思路：
考察的实质就是一个排序过程，要求排序是稳定的

1. 接受作业数量n，机器数量m，接受每一个作业的工作时长（申请一个数组 no[ ] 存储作业的编号，这里用数组下标+1代表作业名称）
2. 对工作进行稳定排序，同时对no [ ] 进行同步操作，以便记录作业的编号
3. 对于机器 i ，将执行编号为 i，i+m，i+2m …（解释，这里已经按照工作时长从小到大的顺序排好了，第一台机器第一个工作是作业1，第二个是1+m，第三个是i+2m，之所以是i+2m是因为前面i+2m-1个作业已经完成或者正在其他机器上晚上，因为第一台机器总是最先完成本轮工作）

代码实现：

package com.xjtu;

import java.util.Scanner;

/**
 * @Author: cc雪影
 * @Description：
 */
public class A2017_04 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("请输入作业数 n：");
        int workNum = in.nextInt();
        System.out.println("请输入机器数 m：");
        int mechanNum = in.nextInt();
        int workTime[] = new int[workNum];
        int no[] = new int[workNum];
        int temp;
        System.out.println("请依次输入每个工作所需要的工作时间：");
        for (int i = 0; i < workNum; i++) {
            workTime[i] = in.nextInt();
            no[i] = i + 1;
        }
        //冒泡排序，对作业按照时间递增排序
        for (int i = workTime.length - 1; i >= 1; i--) {
            boolean flag = true;
            for (int j = 1; j <= i; j++) {
                if (workTime[j - 1] > workTime[j]) {
                    //交换 workTime 数组
                    temp = workTime[j - 1];
                    workTime[j - 1] = workTime[j];
                    workTime[j] = temp;
                    //交换对应的 no 数组
                    temp = no[j - 1];
                    no[j - 1] = no[j];
                    no[j] = temp;
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
        System.out.print("机器 1: ");
        for (int i = 0; i < workTime.length; i = i + 3) {
            System.out.print("作业" + no[i] + " ");
        }
        System.out.println();
        System.out.print("机器 2: ");
        for (int i = 1; i < workTime.length; i = i + 3) {
            System.out.print("作业" + no[i] + " ");
        }
        System.out.println();
        System.out.print("机器 3: ");
        for (int i = 2; i < workTime.length; i = i + 3) {
            System.out.print("作业" + no[i] + " ");
        }
    }
}

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

输入输出：

请输入作业数 n：
10
请输入机器数 m：
3
请依次输入每个工作所需要的工作时间：
3 5 1 9 4 2 7 7 1 8 
机器 1: 作业3 作业1 作业7 作业4 
机器 2: 作业9 作业5 作业8 
机器 3: 作业6 作业2 作业10 
1
2
3
4
5
6
7
8
9

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