数组常用算法学习

最新推荐文章于 2022-04-07 17:26:38 发布

匿名程序员老师

最新推荐文章于 2022-04-07 17:26:38 发布

阅读量208

点赞数

分类专栏：每日Java笔记

本文链接：https://blog.csdn.net/m0_37696726/article/details/104548000

版权

每日Java笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1. 数组练习题【重点】

1.1 找出数组中最大值的下标位置

/*
方法分析：
	public static 不要问
	返回值类型:
		最大值的下标位置，int类型
	方法名:
		maxIndexOfArray 最大值下标位置
	形式参数列表:
		需要一个int类型数组
		(int[] array)
方法声明:
	public static int maxIndexOfArray(int[] array)
*/
/**
* 找出数组中的最大值所在下标位置
*
* @param array int类型数组
* @return 最大值下标所在位置
*/
public static int maxIndexOfArray(int[] array) {
    // 假设数组中最大值的下标位置为0
    int maxIndex = 0;

    for (int i = 1; i < array.length; i++) {
        // 如果发现maxIndex对应元素小于下标为i的元素
        if (array[maxIndex] < array[i]) {
            // 保留i值
            maxIndex = i;
        }
    }
    
    return maxIndex;
}

1.2 找出数组中最小值的下标位置

/*
方法分析:
	public static 不要问
	返回值类型：
		找出对应元素的下标位置，返回值为int类型
	方法名:
		minIndexOfArray
	形式参数列表:
		(int[] array)
方法声明：
	public static int minIndexOfArray(int[] array)
*/
/**
* 找出数组中最小值的下标位置
*
* @param array int类型数组
* @return 返回值是当前数组中最小值的下标位置
*/
public static int minIndexOfArray(int[] array) {
    int minIndex = 0;
    
    for (int i = 1; i < array.length; i++) {
        if (array[minIndex] > array[i]) {
            minIndex = i;
        }
    }
    
    return minIndex;
}

1.3 找出数组中指定元素的下标位置

/*
方法分析:
	public static
	返回值类型:
		返回值是数组的下标位置，为int类型
	方法名:
		indexOf
	形式参数列表:
		1. int类型数组
		2. 告知方法指定查询的数据
		(int[] array, int find);
方法声明:
	public static int indexOf(int[] array, int find)
*/
/**
* 找出指定元素的下标位置
* 
* @param array 指定的int类型数组
* @param find 指定查询的数据，为int类型
* @return 找到对应下标位置，返回值大于等于0，没有找到返回-1
*/
public static int indexOf(int[] array, int find) {
	// 这里假设找不到对应的数据
    int index = -1;
    
    // 利用循环遍历数组
    for (int i = 0; i < array.length; i++) {
        // 发现存在数据和指定find数据一致
        if (find == array[i]) {
            // 保留下标
            index = i;
            // 没有继续循环下去的必要，终止循环
            break;
        }
    }
    
    return index;
}

1.4 获取数组中指定下标的元素

/**
* 找出指定下标的元素
*
* @param array 指定的数组 
* @param index 指定的下标位置
* @return 对应当前下标的元素，为int类型
*/
public static int get(int[] array, int index) {
    // 参数合法性判断的思想
    if (index > array.length - 1 || index < 0) {
        System.out.println("Input Parameter is Invalid!");
        System.exit(0);
    }
    
    return array[index];
}

1.5. 找出指定元素在指定数组中所有下标位置【难点】

/*
要求：
	a. 不允许在方法内打印展示
	b. 考虑多个数据情况
	c. 需要在方法外获取到下标数据信息
	d. 不允许使用数组作为返回值

方法分析:
	public static 不要问
	返回值类型:
		int类型，返回找的指定数据的个数
	方法名:
		findAll
	形式参数列表:
		a. 指定查询数据的数组，int类型数组
		b. 指定查询的目标数据，int类型
		c. 一个可以保存下标的int类型数组，数组的容量是源数据数组容量
		分析:	
			所有指定元素的下标位置
			1. 数据个数不确定，但是有极值，数据多个。
			2. 下标是 int类型
		需要
			int类型数组，数组容量是指定源数据数组的容量
方法声明：
	public static int findAll(int[] arr, int find, int[] index)
*/

/**
* 在指定数组中找出指定数据，保存指定数据的下标位置到index数组中。
* 
* @param arr 源数据int类型数组
* @param find 需要查找的指定数据为int类型
* @param index 保存找到数据下标位置的数组，要求和源数据数组容量一致
* @return 找到目标数据的个数，没有找到返回0
*/
public static int findAll(int[] arr, int find, int[] index) {
    /*
    参数合法性判断
    null == arr 你目前可以理解成给予当前方法的参数中数组为“空”
    arr.index == 0 给予当前方法的数组容量为0
    index.length < arr.length 保存下标的数组容量和源数据数组容量一致
    */
    if (null == arr || null == index || arr.length == 0 
        || index.length == 0 || index.length < arr.length) {
        System.out.println("Input Parameter is Invalid!");
        return 0;
    }
    
    // int类型变量，计数当前找到的元素个数
    // 还有一个功能，是下一次存储指定数据下标的位置【尾插法】
    int size = 0;
    
    // 利用循环遍历源数据数组
    for (int i = 0; i < arr.length; i++) {
        // 发现数组中下标为i的元素和指定find值一致，保存对应下标位置
        if (find == arr[i]) {
            // 下标保存到index数组中
            index[size] = i;
            size += 1;
        }
    }
    
    return size;
}

1.6 在指定位置插入指定元素【难点】

/*
存在一个数组，数组中的元素为
	int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
	要求
		1. 0是无效元素，仅占位使用
		2. 当前数组中【有效元素】个数为9
	需求
		在该数组中的指定下标位置放入指定元素
方法分析：
	public static 不要问
	返回值类型:
		void 没有返回值，不太合适
		int 也不太合适
		boolean 判断添加操作是否成功
	方法名:
		add 添加
	形式参数列表:
		1. 插入数据的数组
		2. 指定插入数据的下标位置
		3. 插入的数据
		(int[] arr, int index, int insert)
方法声明：
	public static boolean add(int[] arr, int index, int insert);
*/

在这里插入图片描述

/**
* 在数组中指定下标位置插入指定元素，操作成功返回true，否则返回false
*
* @param arr 指定插入数据的int类型数组，并且存在空余位置
* @param index 指定插入数据的下标位置，不能超出数组的有效下标范围
* @param insert 指定插入的数据
* @return 操作成功返回true，否则返回false
*/
public static boolean add(int[] arr, int index, int insert) {
    // 参数合法性判断
    if (null == arr || arr.length == 0 || index < 0 
        || index > arr.length - 1) {
        System.out.println("Input Parameter is Invalid!");
        // 方法运行失败，返回false
        return false;
    }
    
    // 从最后一个有效位置开始，到插入位置循环结束，目的是移动数组中的元素
    /*
    1 3 5 7 9 11 13 15 17 0
    index = 5 insert = 20
    arr[9] = arr[8];
    arr[8] = arr[7];
    arr[7] = arr[6];
    arr[6] = arr[5];
    */
    for (int i = arr.length - 1; i > index; i--) {
        arr[i] = arr[i - 1];
    }
    
    arr[index] = insert;
    
    return true;
}

1.7 删除数组中的指定下标的元素【难点】

/*
存在一个数组，数组中的元素为
	int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
	要求:
		1. 0是无效元素，仅占位使用
	需求:
		在当前数组中删除指定下标的元素
	例如:
		指定下标5
		结果 {1, 3, 5, 7, 9, 13, 15, 17, 19, 0} 
		0占位！！！
方法分析:
	public static 不要问
	返回值类型:
		boolean 
	方法名:
		remove 
	形式参数列表:
		1. 删除数据的目标数组
		2. 指定的下标位置
		(int[] arr, int index)
方法声明:
	public static boolean remove(int[] arr, int index)
*/

在这里插入图片描述

/**
* 删除指定下标的元素 
* 
* @param arr 指定删除数据的int类型数组
* @param index 指定删除的下标位置，不能超出数组的有效下标范围
* @return 删除成功返回true，失败返回false
*/
public static boolean remove(int[] arr, int index) {
    // 参数合法性判断
    if (null == arr || arr.length == 0 || index < 0 
        || index > arr.length - 1) {
        System.out.println("Input Parameter is Invalid!");
        // 参数异常告知开发者这里有问题
        return false;
    }
    
    /*
    1 3 5 7 9 11 13 15 17 19
    index = 5
    arr[5] = arr[6];
    arr[6] = arr[7];
    arr[7] = arr[8];
    arr[8] = arr[9];
    arr[9] = arr[10] ???
    */
    for (int i = index; i < arr.length - 1; i++) {
        arr[i] = arr[i + 1];
    }
    
    arr[arr.length - 1] = 0;
    return true;
}

1.8 找出数组中最大值元素，放到下标为0的位置

main(String[] args) {
    int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
    int maxIndex = 0;

    for (int i = 1; i < arr.length; i++) {
        // 如果发现maxIndex对应元素小于下标为i的元素
        if (arr[maxIndex] < arr[i]) {
            // 保留i值
            maxIndex = i;
        }
    }
    
    // 假如最大值的下标不是0，可以交换
    if (maxIndex != 0) {
        int temp = arr[maxIndex];
        arr[maxIndex] = arr[0];
        arr[0] = temp;
    }
    
    System.out.println(Arrays.toString(arr))
}

1.9 接上一题，找出数组中剩余元素的最大值，放到下标为1的位置

main(String[] args) {
    int[] arr = {10, 3, 5, 7, 9, 2, 4, 6, 8, 1};
    int maxIndex = 1;

    for (int i = 2; i < arr.length; i++) {
        // 如果发现maxIndex对应元素小于下标为i的元素
        if (arr[maxIndex] < arr[i]) {
            // 保留i值
            maxIndex = i;
        }
    }
    
    // 假如最大值的下标不是0，可以交换
    if (maxIndex != 1) {
        int temp = arr[maxIndex];
        arr[maxIndex] = arr[1];
        arr[1] = temp;
    }
    
    System.out.println(Arrays.toString(arr))
}

1.10 再接上一题，找出数组中剩余元素的最大值，放到下标为2的位置

main(String[] args) {
    int[] arr = {10, 9, 5, 7, 3, 2, 4, 6, 8, 1};
    int maxIndex = 2;

    for (int i = 3; i < arr.length; i++) {
        // 如果发现maxIndex对应元素小于下标为i的元素
        if (arr[maxIndex] < arr[i]) {
            // 保留i值
            maxIndex = i;
        }
    }
    
    // 假如最大值的下标不是0，可以交换
    if (maxIndex != 2) {
        int temp = arr[maxIndex];
        arr[maxIndex] = arr[2];
        arr[2] = temp;
    }
    
    System.out.println(Arrays.toString(arr))
}

1.11 选择排序算法

/**
* 选择排序算法
* 
* @param array int类型数组
* @return 方法运行成功返回true，方法运行失败返回false
*/
public static boolean selectSort(int[] array) {
    // 参数合法性判断
    if (null == array || array.length == 0) {
        System.out.println("Input Parameter is Invalid");
        return false;
    }
    
    for (int i = 0; i < array.length - 1; i++) {
        // i是每一次极值的存放位置，i值也是每一次假设比较位置
        int maxIndex = i;
        for (int j = i + 1; j < array.length; j++) {
            if (array[maxIndex] < array[j]) {
                maxIndex = j;
            }
        }
        
        if (maxIndex != i) {
            int temp = array[maxIndex];
            array[maxIndex] = array[i];
            array[i] = temp;
        }
    }   
    
    return true;
}