数组的练习:杨辉三角
package com.fanfan;
public class YangHuiTest {
public static void main(String[] args) {
//1.声明并初始化二维数组
int[][] yangHui = new int[10][];
//2.给数组的元素赋值
for(int i = 0 ;i < yangHui.length;i++) {
yangHui[i] = new int[i + 1];
//2.1给首末元素赋值
yangHui[i][0] = yangHui[i][i] = 1;
//2.2给每行的非首末元素赋值
if(i > 1) {
for(int j = 1;j < yangHui[i].length-1;j++) {
yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
}
}
}
//3.遍历二维数组
for(int i = 0;i < yangHui.length;i++) {
for(int j = 0;j < yangHui[i].length;j++) {
System.out.print(yangHui[i][j] + " ");
}
System.out.println();
}
}
}
数组中常见的算法
1。数组元素的赋值(杨辉三角、回形数等)
2.求数值型数组中元素的最大值、最小值、平均数、总和等
练习:定义一个int型的一维数组,包含10个元素,分别附一些随机整数,然后求所有元素的最大值,最小值,和值。要求:随机数都是两位数
package com.fanfan;
/*
* [10,99]
* 公式:(int)(Math.random()*(99-10+1)+10)
*/
public class ArrayTest1 {
public static void main(String[] args) {
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++) {
arr[i] = (int)(Math.random()*(99-10+1)+10);
}
//遍历
for(int i = 0;i < arr.length;i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();
//求数组元素最大值
int maxValue = arr[0];
for(int i = 0;i < arr.length;i++) {
if(maxValue < arr[i]) {
maxValue = arr[i];
}
}
System.out.println("最大值为:" + maxValue);
//求数组元素最小值
int minValue = arr[0];
for(int i = 0;i < arr.length;i++) {
if(minValue > arr[i]) {
minValue = arr[i];
}
}
System.out.println("最小值为:" + minValue);
//求元素的总和
int sum = 0;
for(int i = 1;i < arr.length;i++) {
sum += arr[i];}
System.out.println("总和为:" + sum);
//求数组元素的平均值
int avgValue = sum / arr.length;
System.out.println("平均数为:" + avgValue);
}
}
3.数组的复制、反转、查找(线性查找、二分法查找)
复制
package com.fanfan;
/*
* 使用简单数组
* (1)创建一个名为ArrayTest2类,在main方法中声明array1,array2两个变量,他们是int[]类型的数据
* (2)使用{}把array1初始化为8个素数,2,3,5,7,11,13,17,19。
* (3)显示array1的内容
* (4)赋值array2变量等于array1,修改array2中的偶索引元素,使其等于赋值如array[0]=0,array[2]=2;
*
* array1和array2是什么关系 array1和array2地址值相同,都指向了堆空间的唯一的一个数组实体
* 拓展,修改题目实现array2对array1的复制
*
*/
public class ArrayTest2 {
public static void main(String[] args) {
int[] array1,array2;
array1 = new int[] {2,3,5,7,11,13,17,19};
//显示array1的内容
for(int i=0;i < array1.length;i++) {;
System.out.print(array1[i] + "\t");
}
//赋值array2变量等于array1
//array2 = array1;
//修改:数组的复制
array2 = new int [array1.length];
for(int i = 0; i < array2.length;i++) {
array2[i] = array1[i];
}
//修改array2中的偶索引元素,使其等于赋值如array[0]=0,array[2]=2;
for(int i = 0;i < array2.length;i++) {
if(i % 2 == 0) {
array2[i] = i;
}
}
System.out.println();
//打印出array1
for(int i = 0;i < array1.length;i++) {
System.out.print(array1[i] + "\t");
}
}
}
反转
package com.fanfan;
public class ArrayTest3 {
public static void main(String[] args) {
String[] arr = new String[] {"jj","dd","mm","bb","gg","aa"};
//数组的复制(区别于数组变量的赋值:arr1 = arr)
String[] arr1 = new String[arr.length];
for(int i = 0 ; i < arr1.length;i++) {
arr1[i] = arr[i];
}
//数组的反转
//方式一:
// for(int i = 0 ; i < arr.length / 2;i++) {
// String temp = arr[i];
// arr[i] = arr[arr.length - i - 1];
// arr[arr.length - i - 1] = temp;
// }
//方法二:
for(int i = 0,j = arr.length-1;i<j;i++,j--) {
String temp = arr[i];
arr[i] = arr[j];
arr[j] temp;
}
//遍历
for(int i = 0 ; i < arr.length ; i++ ) {
System.out.print(arr[i] + "\t");
}
}
}
查找(搜索)
线性查找
//遍历
for(int i = 0 ; i < arr.length ; i++ ) {
System.out.print(arr[i] + "\t");
}
System.out.println();
//查找(或搜索)
//线性查找
String dest = "bb";
boolean isFlag = true;
for(int i = 0 ; i< arr.length;i++) {
if(dest.equals(arr[i])) {
System.out.println("找到了指定的元素,位置为:" + i);
isFlag = false;
break;
}
}
if(isFlag) {
System.out.println("很遗憾,没有找到哦!");
}
二分法查找:前提:所要查找的数组必须有序
int[] arr2 = new int[] {-98,-34,2,34,54,66,79,105,210,333};
int dest1 = -34;
int head = 0;//初始的索引
int end = arr2.length - 1;//初始的末索引
boolean isFlag1 = true;
while(head <= end) {
int middle = (head + end)/2;
if(dest1 == arr2[middle]) {
System.out.println("找到了指定的元素,位置为:" + middle);
isFlag1 = false;
break;
}else if(arr2[middle] > dest1) {
end = middle - 1;
}else {
head = middle + 1;
}
}
if(isFlag1) {
System.out.println("很遗憾,没有找到!");
}
4.数组元素的排序算法
排序算法的优劣
1时间的复杂度:分析关键字的比较次数和记录的移动次数
2空间的复杂度:分析算法中需要多少辅助内存
3稳定性:若两个记录A和B 的关键字值相等,但排序后A、B的先后次序保持不变,则称这种排序算法是稳定的。
排序算法分类:内部排序和外部排序
内部排序:整个排序过程不需要借助外部存储器,所有排序操作都在内存中完成
外部排序:参与排序的数据非常多,数据量非常大,计算机无法把整个排序过程放在内存中完成,必须借助外部存储器。外部排序最常见的是多路归并排序。可以认为是由多次内部排序组成
十大内部排序算法:直接选择排序、堆排序、冒泡排序、快速排序、直接插入排序、折半插入排序、Shell排序、归并排序、桶式排序、基数排序
数组的冒泡排序
package com.fanfan;
public class BubbleSort {
public static void main(String[] args) {
int[] arr = new int[] {43,25,56,78,90,84,12,77,99};
//冒泡排序
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;
}
}
}
for(int i = 0; i < arr.length;i++) {
System.out.print(arr[i] + "\t");
}
}
}
package com.fanfan;
import java.util.Arrays;
/*
* java.util.Arrays:操作数组的工具类,里面定义了很多操作数组的方法
*
*
*/
public class ArraryTest {
public static void main(String[] args) {
//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
int[] arr1 = new int[] {1,2,3,4};
int[] arr2 = new int[] {1,3,2,4};
boolean isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);
//2.String toString(int[] a):输出数组信息
System.out.println(Arrays.toString(arr1));
//3.void fill(int[] a,int val):将指定值填充到数组之中
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//4.void sort(int[] a):对数组进行排序
Arrays.parallelSort(arr2);
System.out.println(Arrays.toString(arr2));
//5.int binarySearch(int[] a,int key)
}
}
数组中常见的异常
1.数组角标越界异常:ArrayIndexOutOfBoundsExcetion
2.空指针异常:NullPointerException