数组的概念:
- 数组可以看成是多个相同类型数据组合,对这些数据的统一管理。
- 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。
- 数组的元素可以是任何数据类型,包括基本类型和引用类型。
- C和C++中的数组都可以分配在栈上面,而JAVA中的数组是只能分配在堆上面的,因为JAVA中的数组是引用类型。
数组的特点:
数组的主要优点是按照索引查找某个元素效率高,同时按照元素值查询某个元素效率也很高,但是添加和删除元素需要大量移动元素,效率低下。
数组的特点:查询快、增删慢 集合。可以利用偏移地址来访问元素,效率高;可以利用折半方法查找元素,效率较高,查询快,增删慢
数组相关的题目
一、填空题
1.数组会在内存中开辟一块___连续_____的空间,每个空间相当于之前的一个变量,称为数组的元素。数组的长度一经确定,就无法再改变。
2.要获取一个数组的长度,可以通过___length____属性来获取,但获取的只是为数组分配的空间的数量,而不是数组中实际已经存放的元素的个数。
3.int[] arr_____仅仅是给出了数组名字和元素的数据类型,要想真正的使用数组还必须使用new关键字为它分配内存空间。
4.创建数组后,系统会给每一个数组元素一个默认的值,如String类型元素的默认值是__null_____。
5.在Java中有二维数组int [ ] [ ] array={{1,2,3},{4,5}} ,可以使__array[1][0].length_____得到二维数组中第二维中第一个数组的长度。
二、选择题
-
在Java中,以下程序段能正确为数组赋值的是( a )。(选择二项)
A int a[]={1,2,3,4};
B. int b[4]={1,2,3,4};
C. int c[];c={1,2,3,4};
D. int d[];d=new int[]{1,2,3,4}; -
数组元素的索引可以是( d )。(选择一项)
A 整型常量
B. 整型变量
C. 整型表达式
D. 以上都可以 -
已知表达式int [] m={0,1,2,3,4,5,6};下面( b )表达式的值与数组最大下标数相等。(选择一项)
A m.length()
B. m.length-1
C. m.length()+1
D. m.length+1 -
在Java中,以下定义数组的语句正确的是( c d )。(选择二项)
A int t[10]=new int[ ];
B. char [ ]a=”hello”;
C. String [ ] s=new String [10];
D. double[ ] d [ ]=new double [4][ ]; -
在Java中,下面代码的输出结果为( a )。(选择一项)
public static void main(String[] args) {
int[] arrA = { 12, 22, 8, 49, 3 };
int k = 0;
int len = arrA.length; //5
for (int i = 0; i < len; i++) { //0
for (int j = i + 1; j < len; j++) {//1
if (arrA[i] > arrA[j]) {//
k = arrA[i];
arrA[i] = arrA[j];
arrA[j] = k;
}
}
}
for (int i = 0; i < arrA.length; i++) {
System.out.print(arrA[i]);
if (i < arrA.length - 1) {
System.out.print(",");
}
}
}A 3,8,12,22,49
B. 12,22,8,49,3
C. 49,22,12,8,3
D. 编译错误 -
以下选项中能够正确创建一个数组的是( ad )。(选择二项)
A. float []f[] = new float[6][6];
B. float f[][] = new float[][];
C. float [6][]f = new float[6][6];
D. float [][]f = new float[6][];
三、判断题
1.数组可以声明为任何数据类型,包括任何基本数据类型和引用数据类型。( 对 )
2.数组的长度是确定的,数组一旦被创建,它的大小就是不可以改变的。但是其元素类型可以是不同类型,允许出现混合类型。( 错 )
3.声明数组并分配空间后,数组的每个元素将会赋予初始值。( 对 )
4.创建数组后,系统会给每个数组元素一个默认值,如double型元素的默认值是0.0。( 对 )
5.数组的主要优点是按照索引查找某个元素效率高,同时按照元素值查询某个元素效率也很高,但是添加和删除元素需要大量移动元素,效率低下。(T)
数组的特点:查询快、增删慢 集合
可以利用偏移地址来访问元素,效率高;可以利用折半方法查找元素,效率较高
查询快,增删慢
6.数组的某个元素被传递给一个方法并被该方法修改,当被调用方法执行完毕时,这个元素中含有修改过的数值。( 对 )
7.Java允许创建不规则数组,即Java多维数组中各行的列数可以不同。( 对 )
8.对于数组int[][] t={{1,2,3},{4,5,6}}来说,t.length等于3,t[0].length等于2( 错 )
四、简答题
1.数组的特点。
查询快、增删慢、集合
2.数组的优缺点
查询快
增删慢
3.冒泡排序的算法。
数组中相邻的两个元素比较,将最大或者最小值放到末尾,以此循环比较:算法如下:
public static void getFunction2(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] < arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
printArray(arr);
}
import java.util.Arrays;
排序算法
/*
Java中五种常见的排序方法:
1.Arrays.sort()
2.冒泡排序
3.选择排序
4.反转排序
5.直接插入排序
*/
public class zy8 {
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
if (i == 0) {
System.out.print("[" + arr[i] + ",");
} else if (i == arr.length - 1) {
System.out.print(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
System.out.println();
}
public static void getFunction1(int[] arr) {
Arrays.sort(arr);
printArray(arr);
}
//int[] arr = {2, 62, 14, 3, 7, 9, 1}
//冒泡排序
public static void getFunction2(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] < arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
printArray(arr);
}
//选择排序
public static void getFunction3(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int num = i;
for (int j = i; j < arr.length; j++) {
if (arr[j] < arr[num]) {
num = j;
}
}
int temp = arr[num];
arr[num] = arr[i];
arr[i] = temp;
}
printArray(arr);
}
//反转排序(逆序)
public static void getFunction4(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
printArray(arr);
}
//直接插入排序
public static void getFunction5(int[] arr) {
int temp;
for (int i=1;i<arr.length;i++){
//待排元素小于有序序列的最后一个元素时,向前插入
if (arr[i]<arr[i-1]){
temp = arr[i];
for (int j=i;j>=0;j--){
if (j>0 && arr[j-1]>temp) {
arr[j]=arr[j-1];
}else {
arr[j]=temp;
break;
}
}
}
// printArray(arr);
}
printArray(arr);
}
public static void main(String[] args) {
int[] arr = {2, 62, 14, 3, 7, 9, 1};
System.out.println("原数组:");
printArray(arr);
System.out.println("************************************");
System.out.println("Arrays.sort()排序后的数组:");
getFunction1(arr);
System.out.println("************************************");
System.out.println("冒泡排序后的数组:");
getFunction2(arr);
System.out.println("************************************");
System.out.println("选择排序后的数组:");
getFunction3(arr);
System.out.println("************************************");
System.out.println("反转排序后的数组:");
getFunction4(arr);
System.out.println("************************************");
System.out.println("直接插入排序后的数组:");
getFunction5(arr);
}
}
二分查找(非递归)
/*
二分法查找操作:使用二分法查找有序数组中元素。找到返回索引,不存在输出-1。
分析:二分法查找的前提是数组有序。
假如有一组数为3,12,24,36,55,68,75,88要查给定的值24.可设三个变量front,mid,end分别指向数据的上界,中间和下界,mid=(front+end)/2.
1)开始令front=0(指向3),end=7(指向88),则mid=3(指向36)。因为mid>x,故应在前半段中查找。
2)令新的end=mid-1=2,而front=0不变,则新的mid=1。此时x>mid,故确定应在后半段中查找。
3)令新的front=mid+1=2,而end=2不变,则新mid=2,此时a[mid]=x,查找成功。
4)如要查找的数不是数列中的数,例如x=25,当第三次判断时,x>a[mid],按以上规律,令front=mid+1,即front=3,出现front>end的情况,表示查找不成功。
*/
import java.util.Scanner;
public class zy11 {
public static boolean myBinarySearch(int[] arr, int x) {
int front = 0;
int end = arr.length - 1;
while (front <= end) {
int mid = (front + end) / 2;
if (x == arr[mid]) {
return true;
}
if (arr[mid] > x) {
end = mid - 1;
}
if (arr[mid] < x) {
front = mid + 1;
}
}
return false;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] arr = {3, 12, 24, 36, 55, 68, 75, 88};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
System.out.println("输入你想要查找的数字:");
int x = sc.nextInt();
if (myBinarySearch(arr, x)) {
System.out.println("找到了!");
} else {
System.out.println("没找到!");
}
}
}
二分查找(递归方法)
import java.util.Arrays;
import java.util.Scanner;
public static int recursionBinarySearch(int[] arr, int key, int low, int high) {
if (key < arr[low] || key > arr[high] || low > high) {
return -1;
}
int middle = (low + high) / 2; //初始中间位置
if (arr[middle] > key) {
//比关键字大则关键字在左区域
return recursionBinarySearch(arr, key, low, middle - 1);
} else if (arr[middle] < key) {
//比关键字小则关键字在右区域
return recursionBinarySearch(arr, key, middle + 1, high);
} else {
return middle;
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] arr = {3, 12, 24, 36, 55, 68, 75, 88};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
System.out.println("输入你想要查找的数字:");
int x = sc.nextInt();
int front = 0;
int end = arr.length - 1;
int m = recursionBinarySearch(arr, x, front, end);
if (m == -1) {
System.out.println("在数组中查找不到!");
} else {
m = m + 1;
System.out.println("查找的数字在第" + m + "位");
}
}