public class test06{
public static void main(String[]args){
int[] arr1;//在Java中int[]是一种引用数据类型，是数组类型
int arr2[];
//最早的时候，C语言不提对象的概念，所以没有把int[]看成一种数据类型，
//只是强调一组数，而最重要的是这组数据的类型是int类型
//int[] arr = new int[5]{1,2,3,4,5};//错误的语法
//int[]ss=new int[]{5,4,5};//这样就是对的了
/*
数组的算法：
1、找最值
2、找最值及其下标
3、统计：累加和、平均值等
4、反转
5、复制
6、查找：在数组中，查找某个值是否存在，或者查找某个值的下标
（1）数组中的元素是无序的
顺序查找(很简单，遍历数组就行了)
（2）数组中的元素是有序的
①顺序查找
②二分查找
*/
//数组中的查找：顺序查找，二分查找（二分查找的前提是必须是有序的）
int[] arr={1,2,3,5,7,10};//有序的数组，如果不是有序的，要进行二分查找可以先进行排序（冒泡排序、选择排序）
//假设我们要查询value的值 请把value的值和他的下标找出来
int value=10;
int index=-1;
int left=0;
int right=arr.length-1;
int mid=(left+right)/2;
//顺序查找----------------------------------------------------------------------------------
for(int i=0;i<arr.length;i++){
if(arr[i]==value){
System.out.println("顺序查找：最大值是"+value+"；下标是"+i);
break;
}
}
//二分查找--------------------------------------------------------------------
while(left<=right){
if(arr[mid]==value){//找到了
index=mid;
break;
}else if(arr[mid]<value){//去右边找
left=mid+1;//因为mid比较过了，就不用比较了，从mid的下一个作为左边界
}else{
right=mid-1;
}
mid=(left+right)/2;//重新计算mid，因为left或right修改了
}
if(index==-1){
//没有找到这个值
System.out.println("二分查找"+value+"不存在于这个数组");
}else{
System.out.println("二分查找"+value+"在数组中的下标是"+index);
}
//希望数组最终是{1,2,3,4,8}或{8,4,3,2,1}
//现在要实现从小到大
/*
冒泡排序：（所有编程语言最基础的排序算法）通过相邻元素比较，如果相邻元素的顺序不符合要求，那么就交换。-----------------------------------------------------------
经过几轮之后，实现最终的排序。每一轮都会有一个已经到达正确位置的元素退出比较。
分析：请拿出稿纸
第一轮：
第1次：arr[0]和arr[1]比较，4和2比较，不符合要求，交换，{2,4,1,8,3}
第2次：arr[1]和arr[2]比较，4和1比较，不符合要求，交换，{2,1,4,8,3}
第3次：arr[2]和arr[3]比较，4和8比较，符合要求
第4次：arr[3]和arr[4]比较，8和3比较，不符合要求，交换，{2,1,4,3,8}
第一轮之后，最大的，沉到底，跑到最右边
第二轮：
第1次：arr[0]和arr[1]比较，2和1比较，不符合要求，交换，{1,2,4,3,8}
第2次：arr[1]和arr[2]比较，2和4比较，符合要求
第3次：arr[2]和arr[3]比较，4和3比较，不符合要求，交换，{1,2,3,4,8}
第二轮之后，次大的到达正确位置
第三轮：
第1次：arr[0]和arr[1]比较，1和2比较，符合要求
第2次：arr[1]和arr[2]比较，2和3比较，符合要求
第四轮：
第1次：arr[0]和arr[1]比较，1和2比较，符合要求
轮数 = 数组的长度 - 1; //因为每一轮只能确定一个
*/
//轮数
for(int i=1; i<arr.length; i++){//循环次数 = 长度 -1，控制轮数
/*
例如：5个元素
每一轮的次数 = 长度 - i;
第1轮：4次
第2轮：3次
第3轮：2次
第4轮：1次
第1轮：arr[0]与arr[1]、arr[1]和arr[2]、arr[2]和arr[3]、arr[3]和arr[4]
第2轮：arr[0]与arr[1]、arr[1]和arr[2]、arr[2]和arr[3]
第3轮：arr[0]与arr[1]、arr[1]和arr[2]
第4轮：arr[0]与arr[1]
相邻元素：arr[j] 与 arr[j+1]
第1轮：j的值 ：0,1,2,3 j<4 j<5-1 j<5-i
第2轮：j的值 ：0,1,2 j<3 j<5-2
第3轮：j的值 ：0,1 j<2 j<5-3
第4轮：j的值 ：0 j<1 j<5-4
*/
for(int j=0; j<5-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] + " ");
}
//直接选择排序（交换次数更少）有一点绕，要好好去理解---------------------------------------------------
int[] arr = {4,2,1,8,3};
/*
直接选择排序：
经过很多轮
每一轮，把当前“未排序”的元素中最大/最小的元素及其位置找出来，
然后与这“最大/最小”值本来/正确的位置的元素进行交换
也可以理解为直接插入排序
以从小到大为例
第一轮：
找出本轮最小的值：1，它的下标[2]
这个最小值，应该在[0]位置，就交换[2]和[0]位置的元素
{1,2,4,8,3}
第二轮：
找出本轮未排序元素中最小的值：2，它的下标[1]
这个最小值，应该在[1]位置，就可以不动
第三轮：
找出本轮未排序元素中最小的值：3，它的下标[4]
这个最小值，应该在[2]位置，就交换[4]和[2]位置的元素
{1,2,3,8,4}
第四轮：
找出本轮未排序元素中最小的值：4，它的下标[4]
这个最小值，应该在[3]位置，就交换[4]和[3]位置的元素
{1,2,3,4,8}
轮数：长度-1
*/
for(int i=0; i<arr.length-1; i++){//总轮数 = 长度-1
//(1)找出本轮未排序元素中的最小值及其下标
/*
第1轮：[0]~[4]范围内最小值及其下标
第2轮：[1]~[4]范围内最小值及其下标
第3轮：[2]~[4]范围内最小值及其下标
第4轮：[3]~[4]范围内最小值及其下标
思路：假设本轮未排序的第一个元素最小，然后用min与本轮后面的元素一一比较
*/
int min = arr[i];
int index = i;
for(int j = i+1; j<arr.length; j++){
if(arr[j] < min){
min = arr[j];
index = j;
}
}
//(2)看这个最小值是否在它应该在的位置
/*
第1轮：最小值应该在[0]
第2轮：最小值应该在[1]
第3轮：最小值应该在[2]
第4轮：最小值应该在[3]
*/
if(index != i){//交换arr[i]和arr[index]
int temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
}
}
//显示结果
for(int i=0; i<arr.length; i++){
System.out.print(arr[i] + " ");
}
//-------------------------------------------------------------------------------
/*
数组的维度：
一维数组、二维数组、三维数组...
二维数组：
有行有列的表格，二维表
1、如何声明一个二维数组？
语法格式：
元素的数据类型[][] 数组名;
2、如何初始化二维数组？
初始化：
（1）确定行数
（2）确定每一行的列数
（3）确定元素的值
回忆：
一维数组初始化（1）确定长度，元素的个数（2）确定元素的值
（1）静态初始化
二维数组名 = new 元素的数据类型[][]{{第一行的值列表},{第二行的值列表},...{第n行的值列表}};
（2）动态初始化
3、如何表示二维数组的行数？
二维数组名.length
4、如何表示一行
此时把二维数组看成一个一维数组，把一行看成一个元素
一行：二维数组名[行下标]
行下标的范围：[0,二维数组总行数-1]
5、如何表示每一行的列数？即每一行元素的个数
二维数组的一行，其实又是一个一维数组
二维数组名[行下标].length
6、如何表示某行某列的一个元素呢？
二维数组名[行下标][列下标]
列下标的范围：[0, 该行的列数-1]
7、遍历二维数组
for(int i=0; i<行数; i++){
for(int j=0; j<该行的列数; j++){
System.out.print(二维数组名[i][j] + " ");
}
System.out.println();
}
for(int i=0; i<二维数组名.length; i++){
for(int j=0; j<二维数组名[i].length; j++){
System.out.print(二维数组名[i][j] + " ");
}
System.out.println();
}
*/
//实例:存储多个组的学员的成绩，每一个组单独一行存储
//1、声明一个二维数组
//int[][]scores;
//2、静态初始化
//scores=new int[][]{{50,70},{99,100},{100,80,99}};
//如果把1和2声明和静态初始化可以一起完成
int[][]scores={
{50,70},
{99,100},
{100,80,99}
};
System.out.println("行数"+scores.length);//行数即是长度
//遍历这个二维数组
for(int i=0;i<scores.length;i++){
for(int j=0;j<scores[i].length;j++){
System.out.print(scores[i][j]+" ");
}
System.out.println();
}
}
}