数组、冒泡，选择排序、顺序，二分查找

经常不写数组的我，都快忘记咋写数组了，最近整好复习，今天记录下， 勿忘初心

数组

数组声明

方式一：数据类型[] 数组名
方式二：数据类型 数组名[]
推荐使用方式一，C#等越来越多的语言已经不支持方式二定义数组

Java中的数组必须先初始化，然后才可以使用，所谓初始化，就是为数组中的数组元素分配内存空间，并为每个数组元素赋初始值

静态初始化

初始化时由程序员指定每个数组元素的初始值，由系统计算数组长度

语法：数组元素类型[] 数组名 = new 数组元素类型[]{元素0，元素1,…};

可简写为：数组元素类型[] 数组名 = {元素0，元素1,…};

//注意：简写静态初始化只能一条语句完成，不能分割成两条语句。
//初始化时由程序员指定每个数组元素的初始值，由系统计算数组长度
int[] arr=new int[]{1,2,3,4};
int[] arr1={1,2,3,4};
String[] arr2=new String[]{"434","gfg","gjf545"};
String[] arr3={"434","gfg","gjf545"}

动态初始化

初始化时程序员只指定数组长度，由系统为数组元素分配初始值

语法：元素类型[] 数组名 = new 元素类型[元素个数或者数组长度]；

/*
	动态初始化：初始化时由程序员指定数组的长度，系统负责分配元素的初始值
*/
	int[] array1 = new int[5];//0

	String[] array2 = new String[3];//null

	char[] array3 = new char[10];//\u0000
	注意：
	a.在初始化数组时，不要静态初始化和动态初始化同时使用，也就是说，不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值
	b.既然数组也是一种数据类型，则在初始化的时候也可以先声明，再初始化
		例如：int[] scores;
			 scores = new int[3];

数组遍历 foreach 简单for循环

int[] arr1=new int[]{1,2,3,4,5,6};

//1>简单for循环
//i表示下标，0~arr1.length
for(int i = 0;i < arr1.length;i++) {
	int n = arr1[i];
	System.out.println(n);
}

/*
2>增强for循环【foreach】
JDK1.5之后新增的
优点：用于遍历数组和集合，无需通过数组下标，就可以直接访问数组或者集合中的元素
语法：
for(元素数据类型 变量名：数组名称) {
	System.out.println(变量名);
}
*/
//底层工作原理：根据下标获取数组元素
for(int num : arr1) {
	System.out.println("增强for循环的结果：" + num);
}

/*
两种遍历方式的选择：不需要知道下标，只需要获取元素值，则采用增强for循环
*/

数组内存分配

内存空间:
栈：存储基本类型数据和引用类型的地址，特点：先进后出，一般空间比较小，存取速度较快
堆：存储引用类型数据，特点：空间比较大，存储速度相对较慢
数组引用变量只是一个引用，这个引用变量可以指向任何有效的内存空间，只有当这个引用指向有效的空间时，才可以通过引用去操作真正数组中的元素
结论：数组的引用变量存储在栈空间中，而真正的数组数据存储在堆空间在中

冒泡排序

//冒泡思路：比较两个相邻的下标对应的元素，
//如果符合条件就交换位置（最值出现在最后位）
class ArraySortedDemo{
	public static void main(){
		int[] arr={1,2,3,4,5};
		//以升序为例
		//外层循环：控制比较的轮数n-1轮
		for(int i=0;i<arr.length-1;i++){
			//内层循环：控制每一轮参与比较的下标
           	for(int j=0;j<arr.length-1-i;i++){
				if(arr[j]>arr[j+1]){
					//交换位置
					int temp =arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}		
		}
		for(int num:arr){
			System.out.println(num);
		}
	}
}

选择排序

//选择思路：固定一个下标，
//然后拿这个下标对应的值依次和后面的元素进行比较
class ArraySortedDemo {
	public static void main(String[] args){
		in[] arr= {1,2,3,4,5,6};
		//以升序为例
		for(int i=0;i<arr.length-1;i++){
			for(int j=i+1;j<arr.length;j++){
				if(arr[i]>arr[j]){
					int temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
		for(int num:arr){
			System.out.println(num);
		}
	}
}

顺序查找

//顺序查找：遍历这个数组，
//依次把每一位元素和要查找的数据进行比较
class ArraySearchDemo {
	public static void main(String[] args){
	    int[] arr={1,2,3,4,5};
		//需求：查找1在数组中的位置
		int key=1;
		for(int i=0;i<arr.length;i++){
			if(key == arr[i]){
				System.out.println(i);
			}
		}
		
	}
}

二分法查找

//二分查找
//查找思路：前提是数组是有序（升序或者降序）的，
//通过折半来缩小查找范围，提高查找效率
//将待查找的元素与中间下标对应的元素比较，
//如果大于中间下标对应的元素，则去右半部分查找
class ArraySearchDemo {
	public static void main(String[] args){
	    int[] arr={1,2,3,4,5,6,7,8,9};
		//待查找的元素
		int key=6;
		//下标
		int left = 0;
		int right = arr.length - 1;
        while(left<=right){
		  //中间下标
		  int middle=(left + right)/2; //取整
		  if(arr[middle] > key) {
			right=middle-1;			
		}else if(arr[middle]<key){
			left=middle+1;
		}else 
            System.out.println(middle);
            break;		
 		}
	}
}