| 这个作业属于哪个课程 | 2018软件工程3班 |
|---|---|
| 这个作业要求在哪里 | 现代软件工程 作业 第四次博客作业 |
| 这个作业的目标 | 两则算法的理解与实现 |
| 其他参考文献 | 看懂二叉树的三种遍历 二叉树的前中后和层序遍历详细图解（递归和非递归写法） |
算法
01.寻找数组中第K大是数
-
题目名称：寻找数组中第K大是数 考察算法：
排序算法
-
解题思路：首先阅读题目，以及示例,可知本题是想使用数组存储数值，然后写出算法按需求进行遍历，取出所需要的的数值。
1. 定义一个数组，通过Scanner来获取输入，达到自定义序列长度的目的
2. 给定好数组空间大小后，依次输入序列
3. 定义一个tag数组，来存储条件
4. 定义一个getK（）方法，通过sort方法进行排序，取出第K大值
5. 调用方法，实现输出第K大的数 -
解题代码
import java.util.Arrays;
import java.util.Scanner;
public class t1 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//System.out.println("请给定序列长度");
int l = input.nextInt();
int[] a = new int[l];
//System.out.println("请依次给定序列");
for (int i = 0; i < a.length; i++) {
a[i] = input.nextInt();
}
//System.out.println("请给定询问个数");
int n = input.nextInt();
int[][] tag = new int[n][3];
//System.out.println("请依次给定：" + " 当前询问次数 " + " 到序列第几个数 " + " 第K大的数 ");
for (int i = 0; i < n; i++) {
tag[i][0] = input.nextInt();
tag[i][1] = input.nextInt();
tag[i][2] = input.nextInt();
}
for (int i = 0; i < n; i++) {
// 调用getK（）方法，输出第K大的数
//System.out.println("第" + (i + 1) + "次的第K大数为：");
System.out.println(getMaxK(a, tag[i][0], tag[i][1], tag[i][2]));
}
//结束输出流
System.out.close();
// 结束输入流
input.close();
}
// 遍历找K
public static int getK(int[] a, int star, int over, int k) {
int[] T = new int[over - star + 1];
for (int i = 0; i < T.length; i++) {
T[i] = a[star - 1 + i];
}
//数组排序——升序
Arrays.sort(T);
return T[T.length - k];
}
}
-
运行效果
-
算法的时间复杂度与空间复杂度
时间复杂度：O（n*n*n） 立方阶
空间复杂度：S（n）=O（f(n)） -
实现对数器，验证算法的有效性
【算法基础】如何验证算法是否正确？ 对数器是一把利器。
02.二叉树的先、中、后 序遍历与层级遍历
- 题目名称：二叉树的先、中、后 序遍历与层级遍历 考察算法：
dfs + bfs搜索算法 - 解题思路:参考学习——简书——二叉树遍历(先序、中序、后序)
三种遍历方法的考查顺序一致，得到的结果却不一样，原因在于：
-
先序：考察到一个节点后，即刻输出该节点的值，并继续遍历其左右子树。(根左右)
-
中序：考察到一个节点后，将其暂存，遍历完左子树后，再输出该节点的值，然后遍历右子树。(左根右)
-
后序：考察到一个节点后，将其暂存，遍历完左右子树后，再输出该节点的值。(左右根)
- 解题代码
import java.util.LinkedList;
public class t2 {
public static void main(String[] args) {
/*
作业要求：叉树的先、中、后 序遍历与层级遍历
自己实现四个方法，main方法中调用，将结果打印到控制台
*/
/* 二叉树的结构
A
/
T 6
/
D
/
N 5
/ /
B 4 1
9
*/
long start = System.currentTimeMillis();
//要测试的程序或方法
Node root = into();
// 先序遍历
A(root);
System.out.println("以上是先序遍历结果");
// 中序遍历
B(root);
System.out.println("以上是中序遍历结果");
// 后序遍历
C(root);
System.out.println("以上是后序遍历结果");
// 层级遍历
D(root);
System.out.println("以上是层级遍历结果");
long end = System.currentTimeMillis();
System.out.println("程序运行时间："+(end-start)+"ms");
}
private static void A(Node firstRoot) {
// TODO 先序遍历
if (firstRoot == null) return;
System.out.print(firstRoot.data + " ");
A(firstRoot.l);
A(firstRoot.r);
}
private static void B(Node midRoot) {
// TODO 中序遍历
if (midRoot == null) return;
B(midRoot.l);
System.out.print(midRoot.data + " ");
B(midRoot.r);
}
private static void C(Node lastRoot) {
// TODO 后续遍历
if (lastRoot == null) return;
C(lastRoot.l);
C(lastRoot.r);
System.out.print(lastRoot.data + " ");
}
private static void D(Node levelRoot) {
// TODO 层级遍历
LinkedList<Node> list = new LinkedList<>();
list.add(levelRoot);
while (! list.isEmpty()){
Node layer = list.pop();
if (layer.l != null){
list.offer(layer.l);
}
if (layer.r != null){
list.offer(layer.r);
}
System.out.print(layer.data + " ");
}
}
// 构建一颗树，返回根节点
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;
}
}
}
-
运行效果
-
算法的时间复杂度与空间复杂度
时间复杂度：
空间复杂度： -
实现对数器，验证算法的有效性
往期博客园作业链接
| 期数 | 我的主页 |
|---|---|
| 第一期 | 从蓝天到名利 所有你想要的 都别随风去 |
| 第二期 | 第二次作业 计划与执行 |
| 第三期 | 第三次作业 墨刀 |
| 第四期 | 第四次作业 算法 |
| 第五期 | 第五次作业 产品分析测评 |