java数组下
目录
[TOC]
数组基本操作
杨辉三角
使用二维数组打印一个10行杨辉三角。
- 1.第一行有1个元素,第n行有n个元素
- 2.每一行的第一个元素和最后一个元素都是1
- 3.从第三行开始,对于非第一个元素和最后一个元素的元素。即：
- yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
package com.jyc.project;
/*
1. 第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j]
* */
public class yanghuiTest {
public static void main(String[] args) {
//声明初始化二维数组
int[][] yanghui=new int[10][];
//给数组元素赋值
for(int i=0; i<yanghui.length;i++){
yanghui[i]=new int[i+1];
//给元素首末元素赋值
yanghui[i][0]=yanghui[i][i]=1;
//非首末元素赋值
for(int j=1;j<yanghui[i].length-1;j++){
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
}
}
//遍历二维数组
for(int i=0; i<yanghui.length;i++){
for(int j=0;j<yanghui[i].length;j++){
System.out.println(yanghui[i][j]+ " ");
}
System.out.println();
}
}
}
求数值型数组中元素的最大值、最小值、平均数、总和
定义一个int型的一维数组，包含10个元素，分别赋一些随机整数， 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有随机数都是两位数。
提示； [0,1) * 90[0,90) + 10[10,100)[10,99] (int)(Math.random() * 90 + 10
package com.jyc.project;
/*
* 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
* 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有随机数都是两位数。 (int)(Math.random() * 90 + 10
* */
public class test1 {
public static void main(String[] args) {
int[] arr=new int[10];
int maxVal=arr[0];
int minVal=arr[0];
int sum=0;
int avgVal=0;
for(int i=0;i<arr.length;i++){
arr[i]= (int)(Math.random() * 90 + 10);
if(arr[i]>maxVal){
maxVal=arr[i];
};
if(arr[i]<minVal){
minVal=arr[i];
};
sum+=arr[i];
System.out.println(arr[i]);
}
avgVal=sum/arr.length;
System.out.println("最大值:"+maxVal);
System.out.println("最小值:"+minVal);
System.out.println("总和:"+sum);
System.out.println("平均值:"+avgVal);
}
}
数组的复制、反转、查找(线性查找、二分法查找)
复制
int[] arr =new int[]{1,2,3,4,5,6};
//数组的复制
int [] arr2=new int[arr.length];
for(int i=0;i<arr2.length;i++){
arr2[i]=arr[i];
}
反转
//数组的反转
for(int i=0;i<arr.length / 2;i++){
int temp=arr[i];
arr[i]=arr[arr.length-i-1];
arr[arr.length-i-1]=temp;
}
for(int i=0,j=arr2.length-1;i<j;i++,j--){
int temp=arr2[i];
arr2[i]=arr2[j];
arr2[j]=temp;
}
线性查找
String [] str=new String[]{"aa","bb","cc","dd"};
String dest="a";
boolean isFlage=true;
for(int i=0;i<str.length;i++){
if(dest.equals(str[i])){
System.out.println("找的了指定元素索引为:"+i);
isFlage=false;
break;
}
};
if(isFlage){
System.out.println("很遗憾没有找到呢");
}
二分查找
//二分查找数组是有序的
int [] arr3=new int[]{-99,-20,0,15,23,88,92};
int num=100;
int head=0;//初始化索引值
int end=arr3.length-1;//初始化结束索引
boolean flage=true;
while(head<=end){
int middle=(head+end)/2;
if(num==arr3[middle]){
System.out.println("找的了指定元素索引为:"+middle);
flage=false;
break;
}else if(arr3[middle]>num){
end=middle-1;
}else{
head=middle+1;
}
}
if(flage){
System.out.println("很遗憾没有找到呢");
}
算法介绍
算法的 5 大特征
说明：满足确定性的算法也称为：确定性算法。现在人们也关注更广泛的概念，例如考虑各种非确定性的算法，如并行算法、概率算法等。另外，人们也关注并不要求终止的计算描述，这种描述有时被称为过程（procedure）
冒泡排序
冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元 素，如果他们的顺序错误就把他们交换过来。
- 1.比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
- 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 3.针对所有的元素重复以上的步骤，除了最后一个。
- 4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。
int[] arr=new int[]{5,8,3,1,55,22,0,-8};
for(int i=0;i<arr.length;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;
}
}
}
快速排序
快速排序通常明显比同为O(nlogn)的其他算法更快，因此常被采用，而且快 排采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可 见掌握快排的重要性
- 1.从数列中挑出一个元素，称为"基准"（pivot），
- 2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后， 该基准就处于数列的中间位置。这个称为分区（partition）操作。
- 3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数 列排序。
- 4.递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代 （iteration）中，它至少会把一个元素摆到它最后的位置去。
public class QuickSort {
//快排实现方法
public static void quickRow(int[] array, int low, int high){
int i,j,pivot;
//结束条件
if (low >= high) {
return;
}
i = low;
j = high;
//选择的节点，这里选择的数组的第一数作为节点
pivot = array[low];
while (i < j){
//从右往左找比节点小的数，循环结束要么找到了，要么i=j
while (array[j] >= pivot && i < j){
j--;
}
//从左往右找比节点大的数，循环结束要么找到了，要么i=j
while (array[i] <= pivot && i < j){
i++;
}
//如果i!=j说明都找到了，就交换这两个数
if (i < j){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
//i==j一轮循环结束，交换节点的数和相遇点的数
array[low] = array[i];
array[i] = pivot;
//数组“分两半”,再重复上面的操作
quickRow(array,low,i - 1);
quickRow(array,i + 1,high);
}
//测试
public static void main(String[] args) {
int[] array = {6,3,7,1,9,4,8,5,2,10};
int low = 0,high = array.length - 1;
quickRow(array,low,high);
for (int i : array){
System.out.println(i);
}
}
}
排序算法性能对比
- 1. 从平均时间而言 ：快速排序最佳。但在最坏情况下时间性能不如堆排序和归 并排序。
- 2. 从算法简单性看 ：由于直接选择排序、直接插入排序和冒泡排序的算法比较简单，将其认为是简单算法。对于Shell排序、堆排序、快速排序和归并排序 算法，其算法比较复杂，认为是复杂排序。
- 3. 从稳定性看 ：直接插入排序、冒泡排序和归并排序时稳定的；而直接选择排 序、快速排序、 Shell排序和堆排序是不稳定排序
- 4. 从待排序的记录数 n 的大小看 ，n较小时，宜采用简单排序；而n较大时宜采用改进排序
排序算法的选择
- (1)若n较小(如n≤50)，可采用 直接插入 或 直接选择排序 。 当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直 接插入，应选直接选择排序为宜。
- (2)若文件初始状态基本有序(指正序)，则应选用 直接插入 、 冒泡 或随机的 快速排 序 为宜；
- (3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法： 快速排序 、 堆排序 或 归并排序 。
Arrays工具类的使用
java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。
package com.jyc.project;
import java.util.Arrays;
/*
* java.util.Arrays类即为操作数组的工具类，包含了用来操作数组
* */
public class test3 {
public static void main(String[] args) {
int[] arr1=new int[]{1,2,3};
int[] arr2=new int[]{6,9,4,5,2,88,54,24};
// boolean equals(int[] a,int[] b),判断两个数组是否相等
boolean isEquals= Arrays.equals(arr1, arr2);
System.out.println(isEquals);
//String toString(int[] a)输出数组信息。
System.out.println(Arrays.toString(arr1));
//void fill(int[] a,int val) 将指定值填充到数组之中
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//void sort(int[] a) 对数组进行排序。
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//int binarySearch(int[] a,int key)) 对排序后的数组进行二分法检索指定的值。
int index=Arrays.binarySearch(arr2,88);
if(index>=0){
System.out.println("找到了索引是"+index);
}else{
System.out.println("没找到");
}
}
}
数组使用中的常见异常
数组脚标越界异常 (ArrayIndexOutOfBoundsException)
空指针异常 (NullPointerException)
访问到了数组中的不存在的脚标时发生
int[] arr = new int[2];
System.out.println(arr[2]);
System.out.println(arr[-1]);
arr引用没有指向实体，却在操作实体中的元素时。
int[] arr = null;
System.out.println(arr[0]);
