2020软件工程作业04

这个作业属于哪个课程	2018级软件工程4班
这个作业要求在哪里	第八周作业
这个作业的目标	1.用排序算法找数组中第K大的数 2.用搜索算法实现二叉树的先、中、后序遍历与层级遍历，将结果打印到控制台
其他参考文献	CSDN二叉树的遍历算法

第一题

1.题目名称：用排序算法找数组中第K大的数
2.解题思路：定义一个原始数组并初始化，写一个循环，用来处理多组数据。再定义一个临时数组，然后根据Arrays对象的sort方法将l到r的数据升序存入。
3.解题代码：

package test;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
	  public static void main(String[] args) {
          Scanner scan = new Scanner(System.in);
          //定义一个原始数组并初始化
          //输入序列的长度
          int n = scan.nextInt();
          int[] a = new int[n];
        //输入序列内的数字
          for (int i = 0; i < a.length; i++) {
                  a[i] = scan.nextInt();
          }
          //输入询问的个数
          int nn = scan.nextInt();
          int[] b = new int[nn];
          int l = 0;
          int r = 0;
          int k = 0;
          //分别输入每行的l、r、k
          for (int i = 0; i < nn; i++) {
                  l = scan.nextInt();
                  r = scan.nextInt();
                  k = scan.nextInt();
                  int nnn = r-l+1;
                  int[] c = new int[nnn];
                  for (int j = l,w = 0; j <= r; j++,w++) {
                          c[w] = a[j-1];
                  }
                  //根据sort方法进行升序传入
                  Arrays.sort(c);
                  b[i] = c[nnn-k];
          }
          //输出结果
          for (int i = 0; i < b.length; i++) {
                  System.out.println(b[i]);
          }
  }
}

执行结果：

第二题

1.题目名称：二叉树的先、中、后 序遍历与层级遍历
2.解题思路：参考CSDN的二叉树的先、中、后 序遍历与层级遍历的解答
先序：到一个节点后，即刻输出该节点的值，并继续遍历其左右子树。(根左右)
中序：到一个节点后，将其暂存，遍历完左子树后，再输出该节点的值，然后遍历右子树。(左根右)
后序：到一个节点后，将其暂存，遍历完左右子树后，再输出该节点的值。(左右根)
3.解题代码：

package test;
import java.util.LinkedList;
public class test1 {
	public static void main(String[] args) {
        /*  二叉树的结构
                     A
                    / 
                   T   6
                  /
                 D
               /   
              N     5
             /     /
            B   4  1
                 
                  9
         */
        Node root = into();
        // 先序遍历
        A(root);
        System.out.println("先序遍历");
        // 中序遍历
        B(root);
        System.out.println("中序遍历");
        // 后续遍历
        C(root);
        System.out.println("后序遍历");
        // 层级遍历
        D(root);
        System.out.println("层级遍历");

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

	    }

    private static void B(Node tree) {
        // TODO 中序遍历
        if (tree != null) {
            B(tree.l);
            System.out.print(tree.data + " ");
            B(tree.r);
        }

    }

    private static void C(Node tree) {
        // TODO 后续遍历
        if (tree != null) {
            C(tree.l);
            C(tree.r);
            System.out.print(tree.data + " ");
        }

    }

    private static void D(Node tree) {
        // TODO 层级遍历
        if (tree != null) {
            LinkedList<Node> linkedList = new LinkedList<Node>();
            //先将根节点入队,LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.
            linkedList.offer(tree);
            Node node = null;
            while (!linkedList.isEmpty()) {
                node = (Node) linkedList.pop();
                System.out.print(node.data + " ");
                if (node.l != null) {
                    //将出队结点的左子树根入队
                    linkedList.offer(node.l);
                }
                if (node.r != null) {
                    //将出队结点的右子树根入队
                    linkedList.offer(node.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;
        }
    }
}