Java数组之反转、排序、折半查找

数组的运用

1.通过角标查找对应的元素
需求: 封装一个函数 传入数字1 返回 一 数字2 返回 二....
    // 查表法
    public static char findArray(int a) {
        char[] array = new char[] {'一', '二', '三', '四', '五'};
        // 按角标 返回对应字符
        return array[a - 1];
    }
    
    public static void main(String[] args) {
        System.out.println(fun(1));
    }

2.通过元素查找该元素在数组中得位置(角标)
需求:封装一个函数 定义一个数组 数组值分别 3,6,11,22,查找22的角标
    // 为了让方法的使用性更强,可以把数组也当参数传进来
    public static int fun(int a, int[] array) {
        int l = -1;
        // 遍历查找 元素对应角标
        for(int i=0; i < array.length; i++) {
            // 有可能你传入的值不在数组中,可能会没有返回值
            if(array[i] == a) {
                l = i;
            }
        }
        return l;
    }
    
	public static void main(String[] args) {
		int[] array = new int[] {3, 6, 11, 22};
		System.out.println(fun(22,array));
	}

数组元素反转

如何交换?
例如: 需求 交换两个整数
    int a = 10;
    int b = 15;
    int temp = 0;
    temp = a;
    a = b;
    b = temp;
    
数组元素反转(即将数组中的值倒过来) 
分析:
    1.换 length/2 整数次
    2.第一个数和最后一个数换 一次换...
    如:
        array[0] 和 array[length - 1 - 0]
        array[1] 和 array[length - 1 - 1]
        array[2] 和 array[length - 1 - 2]
        ...
结论:array[i] 和 array[length -1 -i] 相互交换

例: 定义一个长度为5的数组,并将数组元素反转
    public static void reverse(int[] array) {
        for(int i = 0; i < array.length / 2; i++) {
            // 数组元素交换
            int temp = array[i];
            array[i] = array[array.length - 1 - i];
            array[array.length - 1 - i] = temp;
        }
        System.out.println(Arrays.toString(array));
    }
    
    public static void main(String[] args) {
        int[] array = new int[] {1, 2, 3, 4, 5};
        // 这里做的是一个地址的传递
        reverse(array);
    }

写一个交换两个整数的方法,无法实现交换,是因为做的只是一个值的快递,并没有给main函数地址,如:
	public static void reverseNum(int a, int b) {
		int temp = a;
		a = b;
		b = temp;
	}  
	
	public static void main(String[] args) {
		int a = 10;
		int b = 15;
		// 这里做的是一个 值的传递
		reverseNum(a, b);
		System.out.println("a = " + a);
		System.out.println("b = " + b);
	}	

数组排序

冒泡排序

冒泡排序核心思想:相邻两个数进行比较,交换位置
分析:
int[] array = new int[]{3, 2, 5, 1}
3       2   5   1
第一趟     比较完毕,确定一个最大值,放到最后
第一次:2   3   5   1
第二次:2   3   5   1
第三次:2   3   1   5

length - 1 - 0

第二趟
比较完毕,确定一个最大值,放到最后
第一次:2   3   1   5
第二次:2   1   3   5

length - 1 - 1

第三趟   
比较完毕,确定一个最大值,放到最后
第一次:1   2   3   5

length - 1 - 2

实例:
    int[] array = new int[] {3, 2, 5, 1}
    // 外循环相当于比较多少趟,-1代表比较数组长度-1趟
    for(int i = 0; i < array.length - 1; i++) {
        // 内循环相当于一趟比较多少次,-i相当于每趟都少比一次(注意内循环-1 防止数组越界)
        for(int j = 0; j < array.length - 1 - i; j++) {
            if(array[j] > array[j+1]) {
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
    System.out.println(Arrays.toString(array));

选择排序

选择排序的核心思想:选择一个数,一次和后面的数比较 换位
分析:
array[0] --- array[1]       array[2]        array[3]
array[1] --- array[2]       array[3]
array[2] --- array[3]

实例:
		int[] array = new int[] {3, 2, 1, 5};
		// 外循环 -1 相当于 比较长度-1趟
		for (int i = 0; i < array.length -1; i++) {
			// 内循环  1+i把不需要比较的去除 array[0] 和 array[0]
			for (int j = i + 1; j < array.length; j++) {
				if(array[i] > array[j]) {
					int temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}
		System.out.println(Arrays.toString(array));

折半查找(提高效率的查找)

折半查找前提:在数组中查找,查找这个数在数组中得角标
注意:在有序的数组中查找

例: 查找数组 int[] array = new int[]{3,5,6,9,12,18,22,33} 22的角标
    int[] array = new int[]{3, 5, 6, 9, 12, 18, 22, 33};
    // 声明最大 最小 中间 角标
    int min = 0;
    int max = array.length - 1;
    int mid = (max + min) / 2;
    // 要查找的值
    int key = 22;
    // 循环结束条件 key == array[mid]
    while(key != array[mid]) {
        // 比较 如果比中间角标大 挪动小角标
        // 比较 如果比中间角标小 挪动大角标
        if(key > array[mid]) {
            min = mid + 1;
        } else if(key < array[mid]) {
            max = mid - 1;
        }
        // 挪动完角标后 还要进行折半操作
        mid = (max + min) / 2;
        // 当最大角标小于最小角标的时候,说明数组中没有这个数
        if(max < min) {
            // 进到这里说明没有这个数,停止循环
            mid = -1;
            break;
        }
    }
    System.out.println("这个数的角标是:" + mid);