2020软件工程作业04

这个作业属于哪个课程	https://edu.cnblogs.com/campus/zswxy/2018SE
这个作业要求在哪里	https://edu.cnblogs.com/campus/zswxy/2018SE/homework/11406
这个作业的目标	学习算法与数据结构，并完成两道算法题
其他参考文献	无

第一题:

• 题目名称

寻找数组中第K大的数 考察算法：排序算法

• 解题思路

将正整数存储在列表中，按照左边界和右边界获得新的列表并进行从大到小的排序，这里使用的是快速排序，最后返回K值。

• 解题代码

  data = list(map(lambda x: int(x), input('请输入{}个正整数(空格隔开)：'.format(input('请输入序列长度：'))).split()))  # 将输入的正整数存储为列表并将列表中的每个元素转化成int类型
  # 获取第K大的数的函数
  def get_kValue(data):
      l_r_k = list(map(lambda x: int(x), input('请输入三个数l,r,k(空格隔开)：').split()))  # 列表，按顺序存储输入的左边界l与右边界r，以及第K大
      quick_sort = lambda array: array if len(array) <= 1 else quick_sort([x for x in array[1:] if x >= array[0]]) + [array[0]] + quick_sort([x for x in array[1:] if x < array[0]])  # 实现快速排序的匿名函数
      return quick_sort(data[l_r_k[0] - 1:l_r_k[1]])[l_r_k[2] - 1]  # 取出询问序列从左至右第l个数到第r个数，调用匿名函数从大到小排序，然后返回第K大的数
  out_put = [str(get_kValue(data)) for i in range(int(input('请输入询问个数：')))]  # 按照询问个数调用函数
  print('\n对应询问顺序输出第K大的数如下：\n{}'.format('\n'.join(out_put)))  # 对应询问顺序输出K值

   

　运行结果：

第二题:

• 题目名称

二叉树的先、中、后序遍历与层级遍历 考察算法：搜索算法

• 解题思路

先序遍历：根在前，从左往右，一棵树的根永远在左子树前面，左子树又永远在右子树前面

中序遍历：根在中，从左往右，一棵树的左子树永远在根前面，根永远在右子树前面

后序遍历：根在后，从左往右，一棵树的左子树永远在右子树前面，右子树永远在根前面

层级遍历：就是按层，从上到下，从左到右遍历

• 解题代码

  import java.util.LinkedList;
  public class BinaryTreeDemo {
      public static void main(String[] args) {
          /*
              作业要求：叉树的先、中、后 序遍历与层级遍历
              自己实现四个方法，main方法中调用，将结果打印到控制台
           */
          /*  二叉树的结构
                       A
                      / \
                     T   6
                    /
                   D
                 /   \
                N     5
               / \    /
              B   4  1
                   \
                    9
           */
          Node root = into();
          // 先序遍历
          System.out.println("\n"+"前序遍历");
          A(root);
          // 中序遍历
          System.out.println("\n"+"中序遍历");
          B(root);
          // 后续遍历
          System.out.println("\n"+"后续遍历");
          C(root);
          // 层级遍历
          System.out.println("\n"+"层级遍历");
          D(root);
  
      }
  
      private static void A(Node node) {
          // TODO 先序遍历
          System.out.print(node.data + "\t");
          if(node.l != null){
              A(node.l);
          }
          if(node.r != null){
              A(node.r);
          }
  
      }
      private static void B(Node node) {
          // TODO 中序遍历
          if(node.l != null){
              B(node.l);
          }
          System.out.print(node.data + "\t");
          if(node.r != null){
              B(node.r);
          }
      }
      private static void C(Node node) {
          // TODO 后续遍历
          if(node.l != null){
              C(node.l);
          }
          if(node.r != null){
              C(node.r);
          }
          System.out.print(node.data + "\t");
      }
  
      private static void D(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;
          }
      }
  }

   

　运行结果：