| 这个作业属于哪个课程 | https://edu.cnblogs.com/campus/zswxy/2018SE |
|---|---|
| 这个作业要求在哪里 | https://edu.cnblogs.com/campus/zswxy/2018SE/homework/11406 |
| 这个作业的目标 | 排序算法和搜索算法的实现 |
| 其他参考文献 | https://www.bilibili.com/video/BV1os41117Fs?p=47 |
| 算法第一题 |
|
| 题目：寻找数组中第K大是数 考察算法：排序算法 |
解题思路：
先输入序列长度，定义一个和序列长度长度相等的数组，然后输入序列值存入数组，输入询问的次数，定义一个数组存储答案，大小和询问次数相等，然后进行循环输入i r k,用数组自带属性
Arrays.copyOfRange()截取序列数组中的i-r,利用冒泡数组排列，然后从大到小选出第k位，存入答案，最后输出结果。
解题代码：
package suanfa;
import java.util.Arrays;
import java.util.Scanner;
public class PaiXuSuanFa {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc =new Scanner(System.in);
int length=0;//定义序列长度
System.out.print("请输入序列长度：");
length =sc.nextInt();
int [] xulie = new int[length]; //定义给定的正整数序列
System.out.print("请输入给定的序列：");
for (int i = 0; i < length; i++) {
xulie[i]=sc.nextInt();
}
System.out.print("请输入询问个数：");
int num =sc.nextInt(); //定义询问个数
int l,r,k;
//定义数组存储答案
int []anser =new int[num];
for (int j = 0; j < num; j++) {
System.out.print("请输入l r k:");
l =sc.nextInt();
r=sc.nextInt();
k=sc.nextInt();
//Arrays.copyOfRange截取数组中下标l到r的数值，不包括r
int[] newxulie =Arrays.copyOfRange(xulie, l-1, r);
for (int i = 0; i < newxulie.length-1; i++) {
for (int a = 0; a < newxulie.length-1-i; a++) {
if (newxulie[a]>newxulie[a+1]) {
int temp =newxulie[a];
newxulie[a]=newxulie[a+1];
newxulie[a+1]=temp;
}
}
anser[j]=newxulie[newxulie.length-k];
}
}
System.out.println("样例输出:");
for (int i : anser) {
System.out.println(i);
}
}
}
算法第二题
题目：二叉树的先、中、后 序遍历与层级遍历 考察算法： dfs + bfs搜索算法
解题思路：
1.先序遍历：先访问了根节点，然后判断节点是否为空，不为空就输出其数据值，再遍历其左右子树；
2.中序遍历：先访问了根节点，然后判断节点是否为空，不为空就先遍历其左子树，再输出其数据值，再遍历其右子树；
3.后序遍历：先访问了根节点，然后判断节点是否为空，不为空就先遍历左子树，再遍历右子树，再输出数据值；
解题代码：
package suanfa;
import java.util.LinkedList;
public class SuanFa {
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);
System.out.println();
}
private static void A(Node node) {
// TODO 先序遍历
if (node != null) {
System.out.print(node.data + " ");
A(node.l);
A(node.r);
}
}
private static void B(Node node) {
// TODO 中序遍历
if (node != null) {
B(node.l);
System.out.print(node.data + " ");
B(node.r);
}
}
private static void C(Node node) {
// TODO 后续遍历
if (node != null) {
C(node.l);
C(node.r);
System.out.print(node.data + " ");
}
}
private static void D(Node node) {
// TODO 层级遍历
if (node != null) {
LinkedList<Node> list = new LinkedList<Node>();
//先把根节点放到list
list.add(node);
Node newnode = null;
while (!list.isEmpty()) {
//移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
newnode = (Node) list.pop();
System.out.print(node.data + " ");
if (newnode.l != null) {
list.add(newnode.l);
}
if (newnode.r != null) {
list.add(newnode.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;
}
}
}
