2020软件工程作业04

软件需求分析与系统设计课程	https://edu.cnblogs.com/campus/zswxy/2018SE/
作业要求	https://edu.cnblogs.com/campus/zswxy/2018SE/homework/11406
作业目标	<寻找数组中第K大是数以及二叉树的先、中、后 序遍历与层级遍历>
其他参考文献	<CSDN网站学习参考>
学号	<20189658>

第一题：寻找数组中第k大的数

解题思路
1.第一步先利用数组将数据录入。
2.再创建一个一维个数组 录入我们要寻找的第几大数字 k 。创建一个二维数组 ，然后循环。
3.调用方法Arrays.sort（）进行排序，是从小到大排序的
4.最后，输出结果，完成了这道题

`

  import java.util.Scanner;

  import java.util.Arrays;

    class Main{

     public static void main(String [] args){
     Scanner sc = new Scanner(System.in);
     int n = sc.nextInt();
     int arr[] = new int [n];
     for (int i = 0 ; i < arr.length; i ++){
        arr[i] = sc.nextInt();
     }
    int m = sc.nextInt();

    int arrk[] = new int [m];
    int arr1[][] = new int[m][1000];
    for(int i = 0; i < m; i ++){
        int l = sc.nextInt();
        int r = sc.nextInt();
        int k = sc.nextInt();
        int temp = 0;
        for(int j = l-1; j < r; j++){
            arr1[i][temp++] = arr[j];
        }
        arrk[i]= k;
    }
    for(int i = 0; i < m ; i ++){
        for(int j = 0; j < arr1[i].length; j++){
            arr1[i][j] = arr1[i][j];
        }
    }
    int te = 0;
    for(int i = 0 ; i < m ; i ++){
        Arrays.sort(arr1[i]);
    }

    for(int i = 0;i < m ; i ++){
        int z = arrk[i] ;
        int y = 1000 -z;
        System.out.println(arr1[i][y]);
    }

  }
}

`

运行截图

第二题：二叉树的先、中、后序遍历与层级遍历

解题思路
1.将根结点入队
2.当队列不空的时候进行循环
3出队列 返回从列表中移除的元素
4访问该结点5如果它有左子树，则将左子树根节点入队
5如果它有左子树，则将左子树根节点入队
`

import java.util.LinkedList;
/**
* @author hello
*/

public class hxy{
    public static void main(String[] args) {
    /*
        作业要求：叉树的先、中、后 序遍历与层级遍历
        自己实现四个方法，main方法中调用，将结果打印到控制台
     */
    /*  二叉树的结构
                 A
                / \
               T   6
              /
             D
           /   \
          N     5
         / \    /
        B   4  1
             \
              9
     */
    Node root = into();
        // 先序遍历
         System.out.println("\n"+"先序遍历");
        printNode (root);
        // 中序遍历
        System.out.println("\n"+"中序遍历");
         theFirstTraversal(root);
          // 后续遍历
          System.out.println("\n"+"后续遍历");
         theInOrderTraversal(root);
        // 层级遍历
         System.out.println("\n"+"层级遍历");
         theLeverTraversal(root);

      }

     private static void A(Node root) {
     }

     private static void printNode(Node node) {
     // TODO 先序遍历
     System.out.print(node.data + "\t");
     if(node.l != null){
         printNode(node.l);
     }
     if(node.r != null){
         printNode(node.r);
     }

  }
 private static void theFirstTraversal(Node node) {
     // TODO 中序遍历
      if(node.l != null){
          theFirstTraversal(node.l);
     }
    System.out.print(node.data + "\t");
    if(node.r != null){
        theFirstTraversal(node.r);
    }
}
private static void theInOrderTraversal(Node node) {
    // TODO 后续遍历
    if(node.l != null){
        theInOrderTraversal(node.l);
    }
    if(node.r != null){
        theInOrderTraversal(node.r);
    }
    System.out.print(node.data + "\t");
}

private static void theLeverTraversal(Node node) {
    // TODO 层级遍历
    if(node == null) {
        return ;
    }
    LinkedList<Node> queue = new LinkedList<>();
    Node current = null;
    queue.offer(node);
    while(!queue.isEmpty()) {
        current = queue.poll();
        System.out.print(current.data+ "\t");
        if(current.l != null) { 
            queue.offer(current.l);
        }
        if(current.r != null) {
            queue.offer(current.r);
        }
    }
}


private static Node into(){
    Node root = new Node("A");
    Node node1 = new Node("T");
    Node node2 = new Node("D");
    Node node3 = new Node("N");
    Node node4 = new Node("B");
    Node node5 = new Node("6");
    Node node6 = new Node("5");
    Node node7 = new Node("4");
    Node node8 = new Node("9");
    Node node9 = new Node("1");
    root.l = node1;
    node1.l = node2;
    node2.l = node3;
    node2.r = node6;
    node3.r = node7;
    node7.r = node8;
    node6.l = node9;
    node3.l = node4;
    root.r = node5;
    return root;
}

// 节点
static class Node{
    // 数据
    Object data;
    // 左孩子
    Node l;
    // 右孩子
    Node r;

    public Node(){}

    public Node(Object data) {
        this.data = data;
        this.l = null;
        this.r = null;
    }

     public Node(Object data, Node l, Node r) {
        this.data = data;
        this.l = l;
        this.r = r;
     }
  }
}

`

第二题代码截图