2020软件工程作业04

| 这个作业属于哪个课程 | https://edu.cnblogs.com/campus/zswxy/2018SE |
| ---- | ---- | ---- |
| 这个作业要求在哪里 | https://edu.cnblogs.com/campus/zswxy/2018SE/homework/11406 |
| 这个作业的目标 | 排序算法、二叉树的先、中、后 序遍历与层级遍历 |
| 其他参考文献 | 《数据结构与算法Java语言描述》 |
| 学号 | 20189618 |

一.区间K大数查询

1.思路

先要理解区间k大的数的意思，比如区间[2,5]中的第二大的数是多少，就是问序列中第二个数到第5个数中第二大的数是多少；
用键盘输入序列，采用了冒泡排序的方法进行

2.代码

import java.util.Scanner;
public class K {
        public static void main(String[] args) {
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入序列的个数：");
            int num1 = sc.nextInt();
            System.out.println("请输入序列：");
            int[] arr1 = new int[num1 + 1];
            for(int i = 1; i <= num1; i++) {
                arr1[i] = sc.nextInt();
            }
            System.out.println("请输入要查找的个数：");
            int[] arr2 = new int[num1 + 1];
            int temp;
            int l,r,k;
            int num2 = sc.nextInt();
            System.out.println("请输入三个数：");
            for(int i = 1; i <= num2; i++) {
                for(int j = 1;j <= num1; j++) {
                    arr2[j]=arr1[j];
                }
                l = sc.nextInt();
                r = sc.nextInt();
                k = sc.nextInt();
                //用冒泡排序排列
                for(int z = l;z <= r; z++) {
                    for(int j = z;j <= r; j++) {
                        if(arr2[j] > arr2[z]) {
                            temp=arr2[j];
                            arr2[j]=arr2[z];
                            arr2[z]=temp;
                        }
                    }
                }
                System.out.println("从左往右，从大往小第"+ k + "大的数是：");
                System.out.println(arr2[l + k - 1]);
     }
   }
 }

3.运行效果

二.二叉树的先、中、后 序遍历与层级遍历

1.思路

先序：采用递归，根-> 左-> 右
中序：采用递归，左-> 根-> 右
后序：采用递归，左-> 右-> 根
层级：从根节点往下一层一层的访问，每一层从左往右访问

2.代码

import java.util.LinkedList;
import java.util.Queue;
public class Main {

    // 先序遍历  根-> 左-> 右 DLR
    private static void preOrder(Node root) {
        if (root == null) return;
        System.out.print(root.value);
        preOrder(root.left);
        preOrder(root.right);
    }

    // 中序遍历  左-> 根-> 右 LDR
    private static void midOrder(Node root) {
        if (root == null) return;
        midOrder(root.left);
        System.out.print(root.value);
        midOrder(root.right);
    }

    // 后续遍历  左-> 右-> 根 LRD
    private static void postOrder(Node root) {
        if (root == null) return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.value);
    }
    // 层级遍历

    private static void cjOrder(Node root) {
        if (root == null) return;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            Node node = queue.poll();
            System.out.print(node.value);
            if(node.left != null) queue.add(node.left);
            if(node.right != null) queue.add(node.right);
        }
    }

    /*  二叉树的结构
                         A
                        / \
                       T   6
                      /
                     D
                   /   \
                  N     5
                 / \    /
                B   4  1
                     \
                      9
             */
            // 构建一颗树，返回根节点

            public static void main (String[]args){
                    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.left = node1;
                    root.right = node5;
                    node1.left = node2;
                    node2.left = node3;
                    node2.right = node6;
                    node3.left = node4;
                    node3.right = node7;
                    node7.right = node8;
                    node6.left = node9;

                    System.out.print("先序遍历：");
                    preOrder(root);
                    System.out.println();

                    System.out.print("中序遍历：");
                    midOrder(root);
                    System.out.println();

                    System.out.print("后序遍历：");
                    postOrder(root);
                    System.out.println();

                    System.out.print("层级遍历：");
                    cjOrder(root);
                    System.out.println();
            }
            // 节点
            public static class Node {
                public String value;
                public Node left;
                public Node right;

                public Node(String value) {
                    this.value = value;
                }
            }
        }

3.运行效果