2020软件工程作业04

| 这个作业属于那个课程 | https://edu.cnblogs.com/campus/zswxy/2018SE/ |
| ---- | ---- | ---- |
| 这个作业要求在哪 | https://edu.cnblogs.com/campus/zswxy/2018SE/homework/11406 | |
| 这个作业的目标 | 知道什么是算法，会用算法 |
|学号|20189642|
1.寻找数组中第K大是数 考察算法：排序算法
解题思路
利用Java来进行一个升降序排列，对指定索引范围内的数组进行降序排序，先升序排列好已经写好的数组，后倒序赋给下一新的数组。
实现代码如下：

package zuoyesuanfa;
import java.util.Arrays;
import java.util.Scanner;
public class zuoye{
	public static void main(String[] args) {
		Scanner zy = new Scanner(System.in);
		int n =zy.nextInt();
		int arr[] = new int[n];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = zy.nextInt();
		}
		int time = zy.nextInt();//指定询问个数
		for (int i = 0; i < time; i++) {
			int start = zy.nextInt();
			int end = zy.nextInt();
			int k = zy.nextInt();
			//从键盘输入起始位置、结束位置并指定索引元素
			int temp[] = new int[end-start+1];
			int index=0;
			//将指定范围元素赋给新的数组
			for (int j = start-1; j <= end-1; j++) {
				temp[index++]=arr[j];
			}
			Arrays.sort(temp);//对刚刚指定范围元素的新数组进行排序
			int downsort[] = new int[temp.length];
			int index2 = temp.length-1;
			//排序后的数组按照倒叙的方式赋予下一个新数组
			for (int j = 0; j < downsort.length; j++) {
				downsort[j]=temp[index2--];
			}
			//输出新数组指定索引位置元素
			System.out.println(downsort[k-1]);
		}
	}

}

2.二叉树的先、中、后 序遍历与层级遍历
解题思路
先序遍历：首先访问根节点，然后先序遍历其右子树，再先序遍历其左子树；
中序遍历：首先中序遍历根节点的左子树麻烦后访问根节点，最后中序遍历其右子树；
后序遍历：首先后序遍历根节点的左子树，然后后序遍历根节点的右子树，左后访问根节点。
4.层次遍历：设置队列，将根结点引用入队，当队列非空时，循环：
1.从上到下遍历
2.从左到右遍历

代码如下

package suanfa;

import java.util.LinkedList;
public class Main {

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