Java学习路程之数组与排序(冒泡排序、选择排序、折半查找)

一.数组
1.一维数组:保存一组相同数据类型的元素.
2.数组的三种声明方式

    array为数组的命名
    数据类型表示的是数组中元素的数据类型
	int[] array = new int[数组长度];
	int[] array = new int[] {1,2,3};
	int[] array = {1,23};
	获取数组的长度:array.length

3.堆区和栈区
栈:由编译器自动分配释放 ,存放函数的参数值，局部变量的值等.
栈区特点:
1.所有的函数执行的时候都会进入栈区当中,函数执行完毕之后,会自动出栈销毁.
2.遵循先进后出的原则
堆:一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收 。
堆区特点:
1.堆内存会分配内存地址
2.堆内存会分配初值,基本数据类型的初值为0,引用数据类型的初值为null.
3.垃圾回收机制(一块内存没人使用,就会成为垃圾,在某一时候系统会自动回收)

public class Day04 {
	public static void main(String[] args) {
		
		//注意:数组的长度一旦确定就不能改变
		//关键词new表示会在堆内存中开辟一块空间如图:
		//数组会在堆内存当中开辟一块连续的内存空间
		//声明数组可以保存五个int元素
		int[] array = new int[5];
		//如何给数组赋值中的元素
		//使用下标对数组元素进行赋值和取值,下标从0开始
		//数组名[下标] = 值;
		array[3] = 10;
		System.out.println(array[3]);
		//ArrayIndexOutOfBoundsException下标越界异常
		array[5] = 15;
		System.out.println(array[5]);
		array = null;//把array保存的地址指向空
		//NullPointerException(空指针异常,访问了不属于你的内存区域)
		array[3] = 3;
		System.out.println(array[3]);
		![数组在栈和堆的运行机制](https://img-blog.csdn.net/20180823192519810?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2w3MTA4MjA3NDI=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
	}
}

练习1:
查看数组中的每一个元素(遍历数组)

int[] array1 = {1, 2, 3, 4, 5};
public class Day04 {
	public static void main(String[] args) {
		for (int i = 0; i < array1.length; i++) {
			System.out.println(array1[i]);
		}
	}
}

练习2:
需求: 随机10个数 随机的区间为[15,150]
1.把这个10个数放入数组中
2.打印最大值/最小值

public class Day04 {
	public static void main(String[] args) {
		int[] array2 = new int[10];
		int max = 0;//声明最大值
		int min = array2[0];//声明最小值可以声明数组中的某一元素
		for (int i = 0; i < 10; i++) {
		    //随机一个[15,150]之间的数
			int num = (int)(Math.random() * (150 - 15 + 1) + 15);
			array2[i] = num;
			//判断求最大值
			if (array2[i] > max) {
				max = array2[i];
			}
			//判断求最小值
			if (array2[i] < min) {
				min = array2[i];
			}
		}
		System.out.println("最大数:"+ max);
		System.out.println("最小数:" + min);
		//Arrays是数组工具类,可以打印数组.
		System.out.println(Arrays .toString(array2));
	}
}

练习3:
根据下标查找对应的元素
需求: 封装一个函数 传入数字1 返回 一 数字2 返回 二 …… 数字5 返回 五

public class Day04 {
	public static void main(String[] args) {
		System.out.println(findKeyIndex(1));
	}
	public static char findKeyIndex(int n){
        //声明char类型的数组
		char[] array = {'一', '二', '三', '四', '五'};
		return array[n - 1];
	}
}

练习4:
需求:分装一个函数:
定义一个数组 数组值 分别 3,6,11,22
在数组中 查找 11的位置

public class Day04 {
	public static void main(String[] args) {
		int[] array = {3, 6, 11, 22};
		int num = findIndex(array,11);
	}
	public static int findIndex(int[] array,int n){
		 //声明一个变量保存下标
		 int index = -1;
		 for (int i = 0; i < array.length; i++) {
			 //查找 相同的元素
			if (array[i] == n) {
				index = i;
			}
		}
		 return index;
	 }
}

练习5:
数组元素的反转
基本数据类型参数传递时是值的传递,引用数据类型比如数组参数传递时是地址的传递

public class Day04 {
	public static void main(String[] args) {
		int[] array = {1, 2, 3, 6, 8};
		reverse(array);
		//注意:交换两个元素的值分装的函数不能调用之后,在打印它们的值
		System.out.println(Arrays .toString(array));
	}
	private static void reverse(int[] array) {
		int temp;
		for (int i = 0; i < (int)(array.length/2); i++) {
			temp = array[i];
			array[i] = array[array.length - 1 - i];
			array[array.length - 1 - i] = temp;
		}
	}
}

二,冒泡排序
核心:依次交换数组中相邻元素的值
每比一个循环确定了比较元素中最大的数
外层循环控制比较的次数,内层循环控制一轮比较多少次
外层循环减一表示循环比较的次数
内层循环减一表示防止角标越界
内层循环减i表示每次外层循环后内层循环次数少一次

public class Day04 {
	public static void main(String[] args) {
		int[] array = {3, 2, 5, 1, 2, 9};
		int temp;
		for(int i = 0; i < array.length - 1; i++){
			for(int j = 0; j < array.length - 1 - i; j++){
				if(array[j] > array[j + 1]){
					temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
		System.out.println(Arrays.toString(array));
	}
}
//输出:
{
[1, 2, 2, 3, 5, 9]
}

三.选择排序
核心:选择一个数与其他的数进行比较交换,一般选第一个数

public class Day04 {
	public static void main(String[] args) {
		//外循环减一是五个数比四趟
		//内循环1+i表示每一趟确定有一个数不再比较
		int[] array = {3, 2, 5, 1, 2, 9};
		int temp;
		for(i = 0; i < array.lengh - 1; i++){
			for(j = 1 + i; j < array.length; j++){
				if(array[i] > array[j]){
					temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}
		System.out.println(Arrays.toStrring(array));
	}
}

四.折半查找

折半查找:在数组中根据元素查找对应的角标
前提:必须在有序的数组中查找
public class Day04 {
	public static void main(String[] args) {
		int[] array = {1, 10, 20, 30, 40, 50, 55, 60, 78, 90};
		int max = array.length - 1;//最大角标
		int min = 0;最小角标
		int mid = (max + min)/2;折半角标
		int num = 55;
		//有明确的循环结束条件用while循环
		while(array[mid] != num){
			if(array[mid] > num){
				max = mid - 1;
			}
			if(array[mid] < num){
				min = mid + 1;
			}
			//判断数组中有没有这个值
			mid = (max + min)/2;
			if(min > max){
				mid = -1;
				break;
			}
		}
		System.out.println(mid);
	}
}