A:计算机科学
AP计算机科学A的学习概念，示例问题和解释
例子问题
例子问题1:插入
Int [] arr = {0,0,0,0,0,0,0,0,0};
int arrFill = 0;
int val;
//在这里，添加了n个条目。ArrFill是n，假设n <= 9
//变量val现在包含要添加的新值
下列哪个代码块将新值推入加勒比海盗好像它是一堆东西?
其他的都没有
arr[arrFill - 1] = val;
arrFill + +;
Arr [0] = val;
arrFill + +;
arr[arrFill + 1] = val;
arrFill + +;
arr[arrFill] = val;
arrFill + +;
arr[arrFill] = val;
arrFill + +;
让我们假设数组加勒比海盗看起来像下面的整数列表:
{4, 51岁,41岁,0,0,0,0,0,0,0}
假设我们的新值是77．
堆栈可以要么推到开头并将所有内容向后移动，得到如下内容:
{77 4, 51岁,41岁,0,0,0,0,0,0}
但是，没有一个选项可以做到这一点。(不，即使是使用索引的那个也不行0．这个元素并不会添加到数组中，而是替换数组的第一个元素。)
所以，另一个选择是把它放在列表的“末尾”。的变量arrFill正被用于此目的。如果是的话3.，这意味着它是第四个元素的值。因此，你可以设置arr[4] = 77(实际上是4)arrFill）.
这将给你:
{4, 51岁,41岁,77年,0,0,0,0,0,0}
的值还要加上1arrFill．
其他选项不能正确地寻址数组。它们要么太大，要么太小。
问题11:数据结构操作
对或错。
插入数组列表的最坏情况是O(N)。
真正的
假
真正的
插入数组列表通常是O(1)。然而，由于ArrayList使用数组作为其底层数据结构，因此可能需要调整底层数组的大小。调整数组大小需要创建一个新数组，并将所有数据从旧数组复制到新数组，这需要O(N)时间。
示例问题21:计算机科学
下面哪个定义了从整数数组中成功删除项的方法?
public static int[] del(int[] a,int delIndex) {
if(a == null || delIndex < 0 || delIndex >= a.length) {
返回null;
｝
Int [] ret = new Int [a.]长度- 1];
For (int i1=0,i2 =0;I1 < a.length;i1 + +) {
if(i1 == delIndex) {
删除(i1);
｝
｝
返回受潮湿腐烂;
｝
public static int[] del(int[] a,int delIndex) {
if(a == null || delIndex < 0 || delIndex >= a.length) {
返回null;
｝
For (int I = 0;i <= delIndex;我+ +){
if(i == delIndex) {
删除一个[我];
打破;
｝
｝
返回一个;
｝
这些都不能正常工作
public static int[] del(int[] a,int delIndex) {
if(a == null || delIndex < 0 || delIndex >= a.length) {
返回null;
｝
Int [] ret = new Int [a.]长度- 1];
For (int i1=0,i2 =0;I1 < a.length;i1 + +) {
if(i1 != delIndex) {
Ret [i2] = a[i1];
i2 + +;
｝
｝
返回受潮湿腐烂;
｝
public static int[] del(int[] a,int delIndex) {
if(a == null || delIndex < 0 || delIndex >= a.length) {
返回null;
｝
Int [] ret = new Int [a.]长度- 1];
For (int I = 0;i <= delIndex;我+ +){
Ret [i] = a[i];
｝
返回受潮湿腐烂;
｝
public static int[] del(int[] a,int delIndex) {
if(a == null || delIndex < 0 || delIndex >= a.length) {
返回null;
｝
Int [] ret = new Int [a.]长度- 1];
For (int i1=0,i2 =0;I1 < a.length;i1 + +) {
if(i1 != delIndex) {
Ret [i2] = a[i1];
i2 + +;
｝
｝
返回受潮湿腐烂;
｝
当然，这是一种低效的删除方式，但数组是相当“锁定”的数据结构，因为它们的大小在不重新赋值的情况下不能改变。(当然，您可以跟踪最后“使用”的索引。然而，这是一个不同的实现，这里没有反映。)正确的答案是仔细地遍历原始数组，将这些内容复制到新数组中，跳过一个不需要的值。
例子问题1:删除
删除Boolean (int[] arr, int val) {
Boolean found = false;
int我;
For (i = 0;我< arr。长度&& !我+ +){
如果(arr[i] == val) {
Found = true;
｝
｝
如果(发现){
For (int j = i;J < arr.length;j++) {
Arr [j - 1] = Arr [j];
｝
arr (arr)。长度- 1]= 0;
｝
返回发现;
｝
对于上面的代码，变量的内容是什么加勒比海盗在执行结束时，如果用下面的参数值调用方法:
Arr = {3,4,4,5,17,4,3,1}
Val = 4
{3,5,17,3,1}
{3,4,5,17,4,3,1,0}
{3,4,5,17,4,3,1}
其他答案都没有
{3,5,17,3,1,0,0,0}
{3,4,5,17,4,3,1,0}
这段代码模拟从数组中删除一个值，方法是移动该值之后的所有元素，使数组不再包含该值的第一个实例。例如，这段代码取原始数组{17, 3、4、4、5、4、3、1}并注意到4的第一个实例:{3,44、4、5、17日,3日,1}．接下来，它开始向左移动。因此，一些步骤看起来像这样:
{17, 3、4、4、5、4、3、1}
{17, 3、4、5、5、4、3、1}
{3、4、5,17日,17日,4、3、1}
.．.
{17, 3、4、5、5、4、1、1}
然后，在最后，它将最后一个元素设置为0:
{3、4、5,17岁,4、3、1,0}
示例问题21:计算机科学
Int [] arr = new Int [20];
Int x = 6,i=2;
For (int j = 0;J < x;j + +) {
Arr [j] = j * 40 + 20;
｝
For (int j = x;J > i;j () {
Arr [j] = Arr [j - 1];
｝
Arr [i] = 20;
For (int j = 0;J < x;j + +) {
system . out。打印(arr[j] + " ");
｝
上面代码的输出是什么?
20 60 20 100 140 180
20 60 20 100 140 180 220
20 60 20 140 180 220
其他的都没有
20 60 20 100 100 100
20 60 20 100 140 180
通过一些代码解析最容易理解这一点:
首先，有一个循环:for(int j = 0;J < x;j++){//…
这将用20 + 0,20 + 40,20 + 80，…因此，它将是:
20, 60, 100, 140, 180, 220
接下来是数组:for(int j = x;J > i;J——){//…
这基本上移位了index后面的所有内容我后退1。因此你有:
20,60,100,100,140, 180, 220
接下来，你设置arr[2]等于20:
20, 60, 20,100, 140, 180, 220
最后输出每个第一个6元素。这里要小心。注意它来自J = 0到x - 1!
因此，答案是:
20 60 20 100 140 180
该算法基本上实现了一种简单的数组删除。
示例问题21:计算机科学
下面哪个定义了从整数数组中成功删除项的方法?
public static int[] del(int[] a,int delIndex) {
if(a == null || delIndex < 0 || delIndex >= a.length) {
返回null;
｝
Int [] ret = new Int [a.]长度- 1];
For (int i1=0,i2 =0;I1 < a.length;i1 + +) {
if(i1 == delIndex) {
删除(i1);
｝
｝
返回受潮湿腐烂;
｝
public static int[] del(int[] a,int delIndex) {
if(a == null || delIndex < 0 || delIndex >= a.length) {
返回null;
｝
For (int I = 0;i <= delIndex;我+ +){
if(i == delIndex) {
删除一个[我];
打破;
｝
｝
返回一个;
｝
这些都不能正常工作
public static int[] del(int[] a,int delIndex) {
if(a == null || delIndex < 0 || delIndex >= a.length) {
返回null;
｝
Int [] ret = new Int [a.]长度- 1];
For (int i1=0,i2 =0;I1 < a.length;i1 + +) {
if(i1 != delIndex) {
Ret [i2] = a[i1];
i2 + +;
｝
｝
返回受潮湿腐烂;
｝
public static int[] del(int[] a,int delIndex) {
if(a == null || delIndex < 0 || delIndex >= a.length) {
返回null;
｝
Int [] ret = new Int [a.]长度- 1];
For (int I = 0;i <= delIndex;我+ +){
Ret [i] = a[i];
｝
返回受潮湿腐烂;
｝
public static int[] del(int[] a,int delIndex) {
if(a == null || delIndex < 0 || delIndex >= a.length) {
返回null;
｝
Int [] ret = new Int [a.]长度- 1];
For (int i1=0,i2 =0;I1 < a.length;i1 + +) {
if(i1 != delIndex) {
Ret [i2] = a[i1];
i2 + +;
｝
｝
返回受潮湿腐烂;
｝
当然，这是一种低效的删除方式，但数组是相当“锁定”的数据结构，因为它们的大小在不重新赋值的情况下不能改变。(当然，您可以跟踪最后“使用”的索引。然而，这是一个不同的实现，这里没有反映。)正确的答案是仔细地遍历原始数组，将这些内容复制到新数组中，跳过一个不需要的值。
例子问题1:删除
删除Boolean (int[] arr, int val) {
Boolean found = false;
int我;
For (i = 0;我< arr。长度&& !我+ +){
如果(arr[i] == val) {
Found = true;
｝
｝
如果(发现){
For (int j = i;J < arr.length;j++) {
Arr [j - 1] = Arr [j];
｝
arr (arr)。长度- 1]= 0;
｝
返回发现;
｝
对于上面的代码，变量的内容是什么加勒比海盗在执行结束时，如果用下面的参数值调用方法:
Arr = {3,4,4,5,17,4,3,1}
Val = 4
{3,5,17,3,1}
{3,4,5,17,4,3,1,0}
{3,4,5,17,4,3,1}
其他答案都没有
{3,5,17,3,1,0,0,0}
{3,4,5,17,4,3,1,0}
这段代码模拟从数组中删除一个值，方法是移动该值之后的所有元素，使数组不再包含该值的第一个实例。例如，这段代码取原始数组{17, 3、4、4、5、4、3、1}并注意到4的第一个实例:{3,44、4、5、17日,3日,1}．接下来，它开始向左移动。因此，一些步骤看起来像这样:
{17, 3、4、4、5、4、3、1}
{17, 3、4、5、5、4、3、1}
{3、4、5,17日,17日,4、3、1}
.．.
{17, 3、4、5、5、4、1、1}
然后，在最后，它将最后一个元素设置为0:
{3、4、5,17岁,4、3、1,0}
示例问题21:计算机科学
Int [] arr = new Int [20];
Int x = 6,i=2;
For (int j = 0;J < x;j + +) {
Arr [j] = j * 40 + 20;
｝
For (int j = x;J > i;j () {
Arr [j] = Arr [j - 1];
｝
Arr [i] = 20;
For (int j = 0;J < x;j + +) {
system . out。打印(arr[j] + " ");
｝
上面代码的输出是什么?
20 60 20 100 140 180
20 60 20 100 140 180 220
20 60 20 140 180 220
其他的都没有
20 60 20 100 100 100
20 60 20 100 140 180
通过一些代码解析最容易理解这一点:
首先，有一个循环:for(int j = 0;J < x;j++){//…
这将用20 + 0,20 + 40,20 + 80，…因此，它将是:
20, 60, 100, 140, 180, 220
接下来是数组:for(int j = x;J > i;J——){//…
这基本上移位了index后面的所有内容我后退1。因此你有:
20,60,100,100,140, 180, 220
接下来，你设置arr[2]等于20:
20, 60, 20,100, 140, 180, 220
最后输出每个第一个6元素。这里要小心。注意它来自J = 0到x - 1!
因此，答案是:
20 60 20 100 140 180
该算法基本上实现了一种简单的数组删除。
示例问题21:计算机科学
下面哪个实现了一个名为包含为了搜索一个数组的顺序，确认数组是否包含一个请求的元素?
其他答案都不正确
Public Boolean contains(int[] arr, int val) {
For (int I = 0;I < arrr .length;我+ +){
如果(arr[i] == val) {
返回true;
｝
｝
返回错误;
｝
Public Boolean contains(int[] arr, int val) {
布尔成功;
For (int I = 0;I <= arrr .length;我+ +){
如果(arr[i] == val) {
成功=真实;
}其他{
成功=错误;
｝
｝
返回成功;
｝
公共int包含(int[] arr, int val) {
Int success = -1;
For (int I = 0;I < arrr .length;我+ +){
如果(arr[i] == val) {
成功= val;
｝
｝
返回成功;
｝
Public Boolean contains(int[] arr, int val) {
For (int I = 0;I < arrr .length;我+ +){
If (arr[i] != val) {
返回错误;
｝
｝
返回true;
｝
Public Boolean contains(int[] arr, int val) {
For (int I = 0;I < arrr .length;我+ +){
如果(arr[i] == val) {
返回true;
｝
｝
返回错误;
｝
实现顺序搜索的基本方法是测试数组的每个元素，直到匹配想要查找的值。所有这些可能的答案都非常接近这个结果。它们都遍历给定的数组。他们都会检查价值。但是，有一个选项(使用if-else逻辑)即使找到了元素也可以返回false，因为它在找到之后会继续运行。如果在数组的后面没有匹配另一个值，则变量成功然后设置为假．这将返回，表示查找值失败。整数返回方法似乎很好，但如果搜索值为- 1，则会产生歧义。在本例中，这个返回值不一定表示已经找到它——它可能只是一个“标志”，表明没有找到任何东西。因此，这里最简单的方法是最好的方法:返回真正的只要找到了。
示例问题21:计算机科学
Public static int foo(int[] arr, int x) {
For (int I = 0;I < arrr .length;我+ +){
如果(arr[i] == x) {
返回我;
｝
｝
返回1;
｝
给定上面定义的方法，下面的代码会输出多少次单词“Indubitably!”?
Int [] val = {1,4,51,3,14,91,130,14};
For (int I = 0;I < 20;我+ +){
If (foo(vals,i%4) < 0) {
System.out.println(“无疑!”);
｝
｝
2
没有一个
10
5
4
10
为了使这个问题简单得多，首先注意喷火方法实现顺序搜索。(这是一个仅仅遍历数组中的每个元素并查看它是否等于探测值的搜索。)如果找到索引，则返回索引。否则，返回-1。现在，在问题本身的代码块中，循环从i = 0迭代到i = 19。但是，它只会在值0…3上执行搜索。这是因为模算子。因此，它将做(从0到19)，0…3 .共5次。因此，它将探测5次1和3——它们都在数组中。因此，单词“Indubitably!”将总共输出10次。
