AP计算机科学A:遍历
学习AP计算机科学A的概念，示例问题和解释
例子问题
问题1:数据结构操作
考虑下面的代码:
静态类BTNode {
public static final int PARSE_IN = 1;
public static final int PARSE_PRE = 2;
public static final int PARSE_POST = 3;
字符串名称;
BTNode lPointer rPointer;
public BTNode(String s) {
Name = s;
lPointer = rPointer = null
}
public void insert(字符串s) {
插入(s);
}
私有静态空插入(BTNode节点，字符串s) {
int comparison = s.p areto (node.name);
If(比较< 0){
如果节点。= null) {
插入(node.lPointer s);
} else {
节点。lPointer = new BTNode(s);
}
} else if(比较> 0){
如果节点。= null) {
插入(node.rPointer s);
} else {
节点。rPointer = new BTNode(s);
}
}
}
public ArrayList
返回解析(这个,parseOrder);
}
私有静态数组列表
ArrayList
If (node == null) {
返回(retVal);
}
ArrayList
ArrayList
if(parseOrder == PARSE_PRE) {
retVal.add (node.name);
retVal.addAll (leftList);
retVal.addAll (rightList);
} else if (parseOrder == PARSE_POST) {
retVal.addAll (leftList);
retVal.addAll (rightList);
retVal.add (node.name);
} else {
retVal.addAll (leftList);
retVal.add (node.name);
retVal.addAll (rightList);
}
返回retVal;
}
}
public static void main(String[] args) {
String[]的名字= {" Hervaeus”、“彼得Auriol”、“Guiral”,“费利克斯”,“紫色”,“劳拉”,“Yippy”、“Yiiiipppy”、“阿克顿”、“皮尔斯”,“贝蒂”};
BTNode node = new BTNode(names[0]);
For (int I = 1;I < names.length;我+ +){
node.insert(名称[我]);
}
ArrayList
for(字符串s: traversedNames) {
System.out.println(年代);
}
}
这个方法的输出是什么?
Hervaeus
Guiral
费利克斯
阿克顿
贝蒂
彼得Auriol
莱拉
萝拉
Yippy
Yiiiipppy
皮尔斯
贝蒂
阿克顿
费利克斯
Guiral
萝拉
莱拉
皮尔斯
Yiiiipppy
Yippy
彼得Auriol
Hervaeus
彼得Auriol
Hervaeus
Guiral
阿克顿
贝蒂
费利克斯
莱拉
萝拉
Yippy
皮尔斯
Yiiiipppy
BTNode的递归出错。
阿克顿
贝蒂
费利克斯
Guiral
Hervaeus
莱拉
萝拉
彼得Auriol
皮尔斯
Yiiiipppy
Yippy
阿克顿
贝蒂
费利克斯
Guiral
Hervaeus
莱拉
萝拉
彼得Auriol
皮尔斯
Yiiiipppy
Yippy
给出的代码是一个包含插入和解析方法的二叉树的标准实现。现在，您只需关注解析逻辑，特别是将为指示符值PARSE_IN调用的逻辑。(注意，这仅仅是在其他的的。这是在为解析顺序提供错误值的情况下的“catch all”/默认值。)
retVal.addAll (leftList);
retVal.add (node.name);
retVal.addAll (rightList);
这只是基于插入的标准二叉树解析方式。较小的项位于当前节点的左侧，较大的项位于当前节点的右侧。因此，你有:
所有较小值的列表+当前值+所有较大值的列表
递归地，这将以有序列表结束，这正是您所需要的。
问题1:遍历
考虑下面的代码:
进口java.util.ArrayList;
公共类MethodClass5 {
静态类BTNode {
public static final int PARSE_IN = 1;
public static final int PARSE_PRE = 2;
public static final int PARSE_POST = 3;
字符串名称;
BTNode lPointer rPointer;
public BTNode(String s) {
Name = s;
lPointer = rPointer = null
}
public void insert(字符串s) {
插入(s);
}
私有静态空插入(BTNode节点，字符串s) {
int comparison = s.p areto (node.name);
If(比较< 0){
如果节点。= null) {
插入(node.lPointer s);
} else {
节点。lPointer = new BTNode(s);
}
} else if(比较> 0){
如果节点。= null) {
插入(node.rPointer s);
} else {
节点。rPointer = new BTNode(s);
}
}
}
public ArrayList
返回解析(这个,parseOrder);
}
私有静态数组列表
ArrayList
If (node == null) {
返回(retVal);
}
ArrayList
ArrayList
if(parseOrder == PARSE_PRE) {
retVal.add (node.name);
retVal.addAll (leftList);
retVal.addAll (rightList);
} else if (parseOrder == PARSE_POST) {
retVal.addAll (leftList);
retVal.addAll (rightList);
retVal.add (node.name);
} else {
retVal.addAll (leftList);
retVal.add (node.name);
retVal.addAll (rightList);
}
返回retVal;
}
}
public static void main(String[] args) {
字符串[]名称={“托马斯·阿奎那”、“托马斯·卡捷坦”、“托马斯·普鲁特”、“坦克引擎托马斯”、“吃面包的托马斯”};
BTNode node = new BTNode(names[0]);
For (int I = 1;I < names.length;我+ +){
node.insert(名称[我]);
}
ArrayList
for(字符串s: traversedNames) {
System.out.println(年代);
}
}
}
的输出是什么主要以上方法?
托马斯·阿奎那
托马斯Cajetan
托马斯Prufer
吃面包的托马斯
坦克发动机托马斯
坦克发动机托马斯
托马斯Prufer
吃面包的托马斯
托马斯·阿奎那
托马斯Cajetan
托马斯·阿奎那
坦克发动机托马斯
托马斯Prufer
吃面包的托马斯
托马斯Cajetan
吃面包的托马斯
坦克发动机托马斯
托马斯Prufer
托马斯Cajetan
托马斯·阿奎那
吃面包的托马斯
托马斯·阿奎那
坦克发动机托马斯
托马斯Prufer
托马斯Cajetan
吃面包的托马斯
坦克发动机托马斯
托马斯Prufer
托马斯Cajetan
托马斯·阿奎那
这段代码是二叉树类的标准实现。我们正在打的电话主要用于按后修复顺序解析(遍历)树。这意味着我们总是先看每个节点的左边，然后看右边，最后看我们所在的值。但是，该树是不平衡的，因此解析将比其他任何操作进行更多的右遍历。请看下面的插入顺序:
步骤1:
步骤2:
步骤3:
步骤4:
步骤5:
现在，你的遍历路径看起来像这样:
有趣的是，这意味着您最终将得到一个顺序相反的列表。这只适用于碰巧插入的给定数据。
问题3:数据结构操作
复发定义如下:Public int return (int x)
{
If (x <= 1)
{
返回1;
}
其他的
{
返回x + recr (x/2);
}
复发在以下声明中调用?Int num = recr (6);
3.
5
4
1
2
3.
第一个调用在声明中。因为6 > 1，它调用复发，总数为2。
接下来，它调用复发(6/2)。因为3 > 1，它调用复发再一次，总数是3。
接下来，它调用复发(3/2)。因为它除以的是整数，所以结果是复发(1)。
因为1 <= 1，它不会调用复发所以总调用次数是3。
问题4:数据结构操作
下列哪一段代码对定义为:
Int [][] vals = new Int [50][100];
假定数组已经正确初始化并填充了值。
For (int I = 0;I < val .length;i++) {
For (int j = 0;J < vals[i].length;j + +) {
Vals [j][j] *= 5;
}
}
For (int I = 0;I < val .length;i++) {
For (int j = 0;J < vals[i].length;j + +) {
Vals [i][j] *= 5;
}
}
For (int I = 0;I < val .length;i++) {
For (int j = 0;J < val .length;j + +) {
Vals [i][j] *= 5;
}
}
For (int I = 0;I < val .length;i++) {
瓦尔斯[我][0…[99] *= 5;
}
For (int I = 0;I < val .length;i++) {
Vals [i] *= 5;
}
For (int I = 0;I < val .length;i++) {
For (int j = 0;J < vals[i].length;j + +) {
Vals [i][j] *= 5;
}
}
我们在这个问题中寻找的是一个二维数组的标准遍历。当你这样做的时候，你需要确保你进行了迭代这两个行和列。为了做到这一点，你首先必须建立一个循环，如下所示:
For (int I = 0;I < val .length;i++){…
的价值vals.length表示二维数组的行数。
现在，对于每一行，都有一定数量的列。(2D数组就像“数组的数组”。)因此，对于每一行，您需要遍历该行的整个列集:
For (int j = 0;J < vals[i].length;j++){…
请注意，所有错误的问题都没有使用vals[i]。长度是这样的。因此，它们都不能正确地遍历数组的两个维度。
问题1:标准操作与算法
树的遍历
给定如下树形结构:
树的预序遍历是什么?
1 2 3 4 6 7 5 8 9 5
1 2 3 4 5 5 6 7 8 9
1 2 4 5 3 6 8 9 5 7
5 4 2 1 3 6 7 8 9 5
1 2 4 5 3 6 8 9 5 7
当预购遍历完成后，您将执行以下操作:
1.根
2.左子
3.右子
因此，从根节点(1)开始，我们到左节点(2)。然而，这个节点是其他节点的根/父节点，所以我们再向左走(4)。这个节点是父节点/根节点，所以我们向左走(5)。现在是时候往右走了;然而,只有节点1右子,所以要我们土地的权利(3),节点的父/根更多的孩子所以我们向左(6),节点6没有留下孩子,但它确实有权利我们(8)。8有左子节点遍历(9)和(5)。我们将正确的完成遍历的三(7)。这是一个相当复杂的例子;但是，要确保能够正确遍历树。
在上图中，你可以看到预顺序遍历的方法。首先是树根，然后是左边的树，然后是右边的树。如果您正在使用上面的图像进行引导，请确保您不会重复已经遍历的节点。理解算法是关键。
问题1:标准操作与算法
遍历并打印出这个列表
new ArrayList
integers.add (1);
integers.add (2);
integers.add (3);
For (int I = 0;I < integer .length-1;我+ +){
System.out.println (integers.get (i));
}
For (int I = 0;I < integer .size()-1;我+ +){
System.out.println (integers.get (i));
}
System.out.println (integers.get (0));
System.out.println (integers.get (1));
System.out.println (integers.get (2));
For (int I = 0;I < integer .size()-1;我+ +){
System.out.println(整数[我]);
}
For (int I = 0;I < integer .size()-1;我+ +){
System.out.println (integers.get (i));
}
使用for循环遍历列表。.size()方法用于列表，而不是用于数组的.length方法。get()方法用于列表，而不是访问数组的索引。
问题11:数据结构操作
假设给你一个整数数组:
Int array[] = {1,2,3,4,5};
并采用以下方法:
printArray(int[] arr)
{
For (int a = 0;R < arr.length-1;+ +)
{
如果(% 2 = = 0)
{
System.out.println (arr [a]);
}
}
}
调用方法call printArray(array)后，输出将是:
1
3.
5
2
4
1
2
3.
4
5
1
3.
2 4 6
1
3.
正确答案是:
1
3.
这里重要的一行是if语句，它只在(a%2==0)为真或循环计数器除以2为0时执行。一个可能的错误是将数组的每个元素除以2，而不是循环计数器。所以println语句只会在循环计数器为偶数时执行，这种情况发生在第一次迭代(a=0)和第三次迭代(a=2)时。for循环在arr处结束。Length-1，这意味着a的最大值为3，而不是4(选择选项1 - 3 - 5意味着您没有注意到for循环的边界)。最后，println每次打印一个新行，因此，不可能所有的整数都在一行上，因为println被执行了两次。
