java(数组及常用简单算法 )

数组

数组：数组是存储同一种数据类型数据的集合容器。

数组的定义格式：
数据类型[]  变量名  =  new  数据类型[长度];

数组的好处：对分配到数组对象中每一个数据都分配一个编号（索引值、角标、下标）,索引值的范围是从0开始，最大是：长度-1。

局部变量：如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。

成员变量：成员变量就是定义在方法之外，类之内的.

数组中最常见的问题：

1.NullPointerException 空指针异常原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。
2.ArrayIndexOutOfBoundsException索引值越界。原因：访问了不存在的索引值。

数组的初始化方式：

动态初始化:
	数据类型[] 变量名 = new 数据类型[长度];

静态初始化：	
	数据类型[] 变量名 = {元素1，元素2.....};

如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果数据一开始还不太明确，这时候就建议使用动态初始化。

class Demo7 {
	public static void main(String[] args) {	
		//动态初始化
		//int[] arr = new int[10];
	
		//静态初始化
		int[] arr = {10,20,30,40,50};
		for(int index = 0 ; index<arr.length ; index++){
			 System.out.print(arr[index]+",");
		}
	/*
		int[] arr = new int[50];
		Scanner scanner = new Scanner(System.in);
		for(int i  = 0 ; i< arr.length ; i++){
			arr[i] = scanner.nextInt();
		}
		*/
	}
}

class Demo8 {
	public static void main(String[] args) 
{
		int[] arr = {-12,-14,-5,-26,-4};
		int max = getMax(arr);
		System.out.println("最大值："+ max); 
	}

    public static int  getMax(int[] arr) {
		int max = arr[0]; //用于记录最大值
		for(int i = 1 ; i < arr.length ; i++){
			if(arr[i]>max){  //如果发现有元素比max大，那么max变量就记录该元素。
				max = arr[i];
			}
		}
		return max;
	}
}

选择排序(直接排序)：使用一个元素与其他 的元素挨个比较一次，符合条件交换位置。

class Demo9 {
	public static void main(String[] args) {
		int[] arr = {12,5,17,8,9};  //对于5元素的数组，只需要找出4个最大值就可以排序了。
		selectSort(arr);
	}
	
	public static void selectSort(int[] arr) {
		//把最大值放在首位置。
		for(int j = 0; j<arr.length-1; j++){  //  控制的是轮数。
			for(int i = j+1 ; i<arr.length ; i++){ // 找出最大值
				if(arr[i]>arr[j]){
					//交换位置
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}		
		//遍历数组，查看效果
		System.out.print("目前的元素：");
		for (int i = 0 ; i<arr.length  ;i++){
			System.out.print(arr[i]+",");
		}
	}
}

冒泡排序：冒泡排序的思想就是使用相邻的两个 元素挨个比较一次，符合条件交换位置。

class Demo10 {
	public static void main(String[] args) {
		int[] arr = {12,8,17,5,9}; // 最大的索引值: 4   容量：5 
 		bubbleSort(arr);
	}

	public static void bubbleSort(int[] arr){
		// 把最大值放在最后一个位置
		for(int j = 0 ; j<arr.length-1 ; j++){ //控制轮数
			for(int i = 0 ; i<arr.length-1-j  ; i++){  // 找出一个最大值  
				//相邻的元素比较
				if(arr[i]>arr[i+1]){
					int temp  = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
			}
		}
		//遍历数组，查看效果
		System.out.print("目前的元素：");
		for (int i = 0 ; i<arr.length  ;i++){
			System.out.print(arr[i]+",");
		}
		
	}
}

折半查找法(二分法): 使用前提必需是有序的数组。

class Demo12 {
	public static void main(String[] args) {
		int[] arr = {12,16,19,23,54};
		//int index = searchEle(arr,23);
		int index = halfSearch(arr,116);
		System.out.println("元素所在的索引值是："+ index);
	}	
	public static int halfSearch(int[] arr, int target){
		//定义三个变量分别记录最大、最小、中间的查找范围索引值
		int max = arr.length-1;
		int min = 0;
		int mid = (max+min)/2;
		while(true){
			if(target>arr[mid]){
				min = mid+1;
			}else if(target<arr[mid]){
				max = mid -1;
			}else{
				//找到了元素
				return mid;
			}
			//没有找到的情况
			if (max<min){
				return -1;
			}
			//重新计算中间索引值
			mid = (min+max)/2;
		}
	
	}

	public static int searchEle(int[] arr, int target) {
		for(int i = 0 ; i<arr.length ; i++){
			if(arr[i]==target){
				return i;
			}
		}
		return -1;
	}
}

二维数组： 二维数组就是数组中的数组。

二维数组的定义格式：

数据类型[][] 变量名 = new 数据类型[长度1][长度2];

二维数组 的初始化方式：

动态初始化:
数据类型[][] 变量名 = new 数据类型[长度1][长度2];  

静态初始化：
数据类型[][]  变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}

class Demo16 {
	public static void main(String[] args) {
		int[][] arr = {{10,11,9},{67,12},{33,35,39,40}};
		//遍历二维数组
		for(int i = 0;  i <arr.length ; i++){
			for(int j = 0 ; j<arr[i].length ; j++){
				System.out.print(arr[i][j]+",");
			}
			//换行
			System.out.println();
		}
	}
}

数组的特点：

1.数组只能存储同一种数据类型的数据。
2.数组是会给存储到数组中的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；
3.数组一旦初始化，长度固定。
4.数组中的元素与元素之间的内存地址是连续的。