2020软件工程作业04
| 这个作业属于哪个课程 | https://edu.cnblogs.com/campus/zswxy/2018SE/ |
|---|---|
| 这个作业要求在哪里 | https://edu.cnblogs.com/campus/zswxy/2018SE/homework/11406 |
| 这个作业的目标 | 用排序算法寻找数组中第K大是数&&二叉树的先、中、后 序遍历与层级遍历 |
| 学号 | 20189650 |
题1：寻找数组中第K大的数
解题思路：
1：创建键盘录入，定义数组
2：用for循环将键盘录入的数组存入数组中（检查遍历数组）
3：定义一个新的数组，变量m用于循环几次查询，l,r,k三个变量以及一个中间变量temp
4：for循环嵌套循环查询次数，将要查的数存入新的数组
5：冒泡排序将序列从大到小排序得到k
6：输出从l到r第k大的数k
代码：
import java.util.ArrayList;
import java.util.Scanner;
public class suanfa{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入数列的个数：");
int n = sc.nextInt();
System.out.println("请输入数列的数：");
int [] arr = new int[n+1];
for (int i = 1; i <= n; i++){
arr[i] = sc.nextInt();//将键盘录入的数值存入数组中
}
/*//检验遍历数组
for (int i = 1 ; i <= n ; i++){
System.out.print(arr[i]);
}
System.out.println();*/
System.out.println("请输入你要查询的次数：");
int [] arr1 = new int[n+1];
int l,r,k;
int temp;
int m = sc.nextInt();
System.out.println("请输入你要查询的数：");
for (int i = 1 ; i <= m ; i++){
for (int j = 1 ; j<= n; j++){
arr1[j] = arr[j];
}
l = sc.nextInt();
r = sc.nextInt();
k = sc.nextInt();
//冒泡排序
for (int y = l; y <= r; y++){
for (int j = y; j <= r; j++){
if (arr1[j] > arr1[y]){
temp = arr1[j];
arr1[j] = arr1[y];
arr1[y] = temp;
}
}
}
System.out.println(arr1[l+k-1]);
}
}
}
题2：二叉树的先、中、后 序遍历与层级遍历
解题思路：
先序遍历：先访问根节点，然后先序遍历左孩子，在先序遍历右孩子。
中序遍历：从根结点开始，中序遍历根结点的左孩子，然后访问根结点，最后遍历右孩子。
后序遍历：从左往右先孩子后根结点遍历左右孩子，最后访问根结点。
层级遍历：从树的根结点开始从上往下，同一级中从左往右的顺序访问每个结点。
代码:
import java.util.LinkedList;
import java.util.Stack;
public class tree {
public static void main(String[] args) {
/*
作业要求：叉树的先、中、后 序遍历与层级遍历
自己实现四个方法，main方法中调用，将结果打印到控制台
*/
/* 二叉树的结构
A
/ \
T 6
/
D
/ \
N 5
/ \ /
B 4 1
\
9
*/
Node root = into();
// 先序遍历
System.out.print("先序：");
A(root);
System.out.println();
// 中序遍历
System.out.print("中序：");
B(root);
System.out.println();
// 后续遍历
System.out.print("后序：");
C(root);
System.out.println();
// 层级遍历
System.out.print("层级：");
D(root);
}
private static void A(Node root) {
// TODO 先序遍历
if (root != null) {
System.out.print(root.data);
A(root.l);
A(root.r);
}
}
private static void B(Node root) {
// TODO 中序遍历
if (root != null) {
B(root.l);
System.out.print(root.data);
B(root.r);
}
}
private static void C(Node root) {
// TODO 后序遍历
if (root != null) {
C(root.l);
C(root.r);
System.out.print(root.data);
}
}
private static void D(Node root) {
// TODO 层级遍历
if (root != null) {
LinkedList<Node> linkedList = new LinkedList<Node>();
//先将根节点入队
linkedList.offer(root);
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;
}
}
}
