一、数组
1. 概述:
多个数据的容器。
线性顺序排列。所谓线性顺序是指除第一个元素外,每一个元素都有唯一的前驱元素;除最后一个 元素外,每一个元素都有唯一的后继元素。(“简单理解就是:一个跟一个按照顺序排列”)。
2. 创建格式:
格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];
格式 2. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3...数组内容 n};
格式 3. 数据类型[] 数组名;
格式 3 属于只创建了数组引用名, 并未在内存创建数组空间。
格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3...内容 n};
3. 下标:
可以理解为数组中内容的数字序号,从 0 开始 ,对于长度为 n 的数组,下标的范围是 0~n-1。
可以通过下标的方式访问数组中的每一个元素。
例如: 创建 int 类型数组 arr , 给数组 arr 的 5 下标赋值数据 , 然后打印
int[] arr = new int[10];
arr[5] = 123;
System.out.println(arr[5]);
4. 数组长度获取:
数组名称.length
5. 注意:
使用数组不当, 会出现如下问题:
数组未赋值: 空指针异常
超出长度的下标操作: 数组越界异常
注意:数组的长度在创建时就固定了。
package com.kaikeba.demo1;
public class Demo2 {
public static void main(String[] args) {
//常见问题:
// 1. 数组下标越界问题:
//int[] nums = {10,11,12,13,14};
//System.out.println(nums[5]);
// 2. 空指针问题
int[] nums = null;
System.out.println(nums[1]);
}
}
补充:找出无序数组中的最大/最小值。
package com.kaikeba.demo1;
public class Demo3 {
//寻找数组中的最大值 | 最小值
public static void main(String[] args) {
int[] nums = {10,30,40,33,22,20,11,0};
//1. 创建一个变量, 用于存储遍历数组时发现的最大值
int n = nums[0];
//2. 循环取出数组中的每一个内容, 从1开始
for(int i=1;i<nums.length;i++) {
//将数组中的每一个内容与n比较, 如果比n大, 则将n的值赋值为这个内容。
n = n<nums[i]?n:nums[i];
}
System.out.println(n);
}
}
二、数组常用算法
1. 冒泡排序:
原理:
- 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
- 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的 数。
- 针对所有的元素重复以上的步骤,除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
名字由来:
是因为最小(或最大)的元素会经由交换慢慢“浮”到数列的顶端(降序或升序),就如同水中的气泡最终会上浮到顶端一样,故名“冒泡排序”。
升序排列的口诀:
N个数字来排队
两两相比小靠前,
外层 循环length-1
内层循环length-i-1
降序排序的口诀:
N个数字来排队
两两相比大靠前,
外层 循环length-1
内层循环length-i-1
冒泡排序代码示例:
package com.kaikeba.demo1;
public class Demo4 {
/**
* 冒泡排序
* @param args
*/
public static void main(String[] args) {
int[] nums = {20,15,18,13,30,60};
int temp;
//外层循环控制的是, 比较的轮数。
//外层循环次数: length-1
for(int i=0;i<nums.length-1;i++) {
//内层循环控制的是,每轮比较的次数
//第i轮(i从0开始计算), 比较次数为:length-i-1
for(int j=0;j<nums.length-i-1;j++) {
if(nums[j]>nums[j+1]) {
//两两相比, 满足移动条件
temp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = temp;
}
}
}
//排序已经完成。 下面是遍历打印查看的过程
for(int i=0;i<nums.length;i++) {
System.out.println(nums[i]);
}
}
}
2. 二分查找(折半查找):
概述:
二分查找也称折半查找(Binary Search),它是一种效率较高的查找方法。但是,二分查找要求数组数据必须采用顺序存储结构有序排列。
原理:
首先,假设数组中元素是按升序排列,将数组中间位置的数据与查找数据比较,如果两者相等,则查找成功;否则利用 中间位置记录将数组分成前、后两个子数组,如果中间位置数据大于查找数据,则进一步查找前子数组,否则进一步查 找后子数组。
重复以上过程,直到找到满足条件的数据,则表示查找成功, 直到子数组不存在为止,表示查找不成功。
二分查找代码示例:
package com.kaikeba.demo1;
public class Demo5 {
/**
* 二分查找(折半查找)
*/
public static void main(String[] args) {
int[] nums = {10,20,30,40,50,60,70,80,90};
//要查找的数据
int num = 20;
//关键的三个变量:
//1. 最小范围下标
int minIndex = 0;
//2. 最大范围下标
int maxIndex = nums.length-1;
//3. 中间数据下标
int centerIndex = (minIndex+maxIndex)/2;
while(true) {
System.out.println("循环了一次");
if(nums[centerIndex]>num) {
//中间数据较大
maxIndex = centerIndex-1;
}else if(nums[centerIndex]<num) {
//中间数据较小
minIndex = centerIndex+1;
}else {
//找到了数据 数据位置:centerIndex
break;
}
if(minIndex > maxIndex) {
centerIndex = -1;
break;
}
//当边界发生变化, 需要更新中间下标
centerIndex = (minIndex+maxIndex)/2;
}
System.out.println("位置:"+centerIndex);
}
}