java数组算法例题代码详解(冒泡排序,选择排序,找最大值、最小值,添加、删除元素等)

作者：lv | 来源：互联网 | 2022-07-20 15:29

这篇文章主要介绍了java数组算法例题代码详解(冒泡排序,选择排序,找最大值、最小值,添加、删除元素等),本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下

数组算法例题

1.数组逆序

第一个和最后一个互换，第二个和倒数第二个互换，就相当于把数组想下图一样，进行对折互换，如果数组个数为奇数，则中间保持不变其余元素互换即可

import java.util.Arrays;

class Demo12 {
    public static void main (String[] args) {
        int[] arr = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        System.out.println(Arrays.toString(arr));
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 数组逆序
     * @param arr
     */
    public static void reverse(int[] arr) {
        for (int i = 0; i

数组展示:System.out.println(Arrays.toString(arr));

2.找出数组中最大值所在下标位置

因为是找下标位置所以可以先定义一个值为数组下标，直接使用数组[下标] 方式进行比较

import java.util.Arrays;

class Demo13 {
    public static void main (String[] args) {
        int[] array = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        // 输出数组
        System.out.println(Arrays.toString(array));
        maxIndexOf(array);
    }

    /**
     * 找到数组中最大的数并且输出
     * @param arr
     */
    public static void maxIndexOf (int[] arr) {
        int maxIndex = 0;
        // i 可以从1开始,不需要maxIndex和自己再比较一次
        for (int i = 1; i  arr[maxIndex]){
                maxIndex = i;
            }
        }
        System.out.printf("最大的数为 : %d 下标为 : %d", arr[maxIndex] , maxIndex);
    }
}

3.找出数组中指定元素第一次出现的下标位置

分析

第一次出现位置
如果有多个重复元素
有可能不存在指定元素

import java.util.Arrays;
import java.util.Scanner;

class Demo14 {
    public static void main (String[] args) {
        int num = 0;
        int index = 0;
        // 定义数组
        int[] array = { 4399, 327, 360, 3, 4, 11, 32, 45, 123, 86};
        // 输出数组
        System.out.println(Arrays.toString(array));
        // 获取用户输入数据
        num = getInputNum();
        // 获取用户输入数据在数组中第一次出现的位置
        index = getIndexOfNum(array, num);
        // 输出位置索引
        printIndexNum(num, index);
    }

    /**
     * 接受用户传来的数据
     * @return 返回接受的数据
     */
    public static int getInputNum () {
        int num = 0;
        java.util.Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查询的数据:");
        num = sc.nextInt();
        return num;
    }

    /**
     * 找出数组中指定元素第一次出现的下标位置
     * @param array
     * @return 返回下标
     */
    public static int getIndexOfNum(int[] array, int num) {
        // 如果找不到数据,则默认是-1
        int index = -1;
        for (int i = 0; i

4.在数组中找出指定下标对应的元素

分析:有可能不存在指定的索引

import java.util.Arrays;
import java.util.Scanner;

class Demo15 {
    public static void main(String[] args) {
        // 下标值
        int indexNum = 0;
        // 下标对应的数值
        int num = 0;
        // 定义数组
        int[] array = { 4399, 327, 360, 3, 4, 11, 32, 45, 123, 86};
        // 输出数组
        System.out.println(Arrays.toString(array));
        // 接受用户传来的下标值
        indexNum = getIndexNum();
        // 查询数组中下标值对应的数值
        num = findNumInArray(indexNum, array);
        // 输出数值
        printNum(indexNum, num);
    }

    /**
     * 接受用户传来的下标值
     * @param indexNum 用户传来的下标值
     * @return 下标值
     */
    public static int getIndexNum() {
        int indexNum = 0;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入想要查询的下标值:");
        indexNum = sc.nextInt();
        return indexNum;
    }

    /**
     * 查询数组中下标值对应的数值
     * @param indexNum 下标值
     * @param array 数组
     * @return 返回下标值对应的数值
     */
    public static int findNumInArray(int indexNum, int[] array) {
        int num = 0;
        // 判断用户传来的下标值是否正确,是否越界
        if (indexNum > 0 && indexNum

5.找出指定元素在数组中最后一次出现位置

和找出第一个方法差不多

tips:

既然是找最后一个数字,可以倒序查找,提高效率
判断找不到的情况

package cn.ocean888;

import java.util.Arrays;
import java.util.Scanner;

// 找出指定元素在数组中最后一次出现位置

public class Demo1 {
	public static void main(String[] args) {
		int num = 0;
		int index = 0;
		int[] array = { 4399, 327, 360, 3, 4, 11, 32, 45, 123, 86};
		System.out.print(Arrays.toString(array));
		// 获取用户输入
		num = getInputNum();
		// 找出指定元素在数组中最后一次出现位置
		index = getLastIndexOf(array, num);
		// 输出下标
		printIndex(index);
	}
	
	/**
	 * 获取用户输入
	 * @param num 用户输入数字
	 * @return num
	 */
	public static int getInputNum() {
		int num = 0;
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入数组中的一个数字:");
		num = sc.nextInt();
		return num;
	}
	
	/**
	 * 找出指定元素在数组中最后一次出现位置
	 * @param array
	 * @param num
	 */
	public static int getLastIndexOf(int[] array, int num) {
		int index = -1;
		// 既然是找最后一个数字,可以倒序查找,提高效率
		for (int i = array.length - 1; i >= 0 ; i--) {
			if (array[i] == num) {
				index = i;
				break;
			}
		}
		return index;
	}
	
	/**
	 * 输出下标
	 * @param index
	 */
	public static void printIndex(int index) {
		if (index != -1) {
			System.out.println("指定元素在数组中最后一次出现位置为:" + index);
		} else {
			System.out.println("指定元素没有在数组中出现");
		}
	}
}

一定要注意,for循环判断 i

6.找到元素在指定数组中的所有下标位置

要求:

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

思考1:

保存查询数据的下标位置一定会用到数组
保存下标的数组数据类型是int类型

解决:

另外使用一个数组,作为形式参数,传递首地址,使用此数组存放下标位置,因为是传递的地址,可以直接更改数组内容,并不需要返回数组的值

思考2:

需要考虑保存下标的数组容量

解决:

返回值数组容量和原数组容量一致,这样及时数组内元素值一致且被选中,也可以存储下来

思考3:

返回值,怎么表示,用什么类型数据

new创建一个新的数组,int类型数组中,所有元素初始值都是0,用什么判断元素索引

解决:

返回找到的元素个数,没有则返回0

package cn.ocean888;

import java.util.Arrays;

public class Demo2 {
	public static void main(String[] args) {
		// 假设用户要查询3在数组中出现的位置
		int num = 3;
		int count = 0;
		int[] array1 = { 4399, 3, 360, 3, 4, 11, 32, 3, 123, 86};
		int[] array2 = new int[array1.length];
		// 在array1数组查num重复值索引放到array2中
		count = allIndexOf(array1, array2, num);
		// 打印输出查询3在数组中出现的位置
		printArray(array2, count);
		// 打印输出整个数组
		System.out.println(Arrays.toString(array2));
	}
	
	/**
	 * 从元素组找到元素在指定数组中的所有下标位置,将下标位置依次赋值给array2数组
	 * 返回值为array2数组长度,即有多少个重复的值
	 * @param array1 原数组
	 * @param array2 存储重复值索引的数组
	 * @return conunt 有多少个重复的值
	 */
	public  static int allIndexOf(int[] array1, int[] array2, int num) {
		// count值既是返回时的存储重复值索引的数组array2的长度,也在循环中可以当作array2的索引
		int count = 0;
		for (int i = 0; i

7.在指定位置插入指定元素

在数组指定位置添加元素,指定位置后面的依次往后移一位,最后一个0就是要被挤掉的,可以从后向前进行循环操作

核心代码

for (int i = array.length - 1; i > index; i--) {
				array[i] = array[i-1];
			}
			array[index] = insert;

全部代码

package cn.ocean888;

import java.util.Arrays;

public class Demo3 {
	// 在指定位置插入指定元素
	public static void main(String[] args) {
		// 先定义数组,最后一个0就是要被挤掉的
		int[] array = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
		System.out.println(Arrays.toString(array));
		// 要加入位置的索引
		int index = 6;
		// 要加到这个数组里的数字
		int insert = 12;
		boolean status = false;
		status = addElement(array, index, insert);
		printResult(status, array);
	}
	
	/**
	 * 在数组指定位置添加元素,后面的依次往后移一位
	 * @param array 要添加元素的数组
	 * @param index 添加进数组的位置索引
	 * @param insert 要添加进入数组对应位置的值
	 * @return 返回是否添加成功
	 */
	public static boolean addElement (int[] array, int index, int insert) {
		// 判断插入位置是否存在于数组中
		if (index <0 || index >= array.length) {
			return false;
		} else {
			// 要插入元素位置开始往后元素依次向后移一位
			for (int i = array.length - 1; i > index; i--) {
				array[i] = array[i-1];
			}
			array[index] = insert;
			
			return true;
		}
	}
	
	/**
	 * 输出更新后的数组
	 * @param status 添加元素是否成功的状态
	 * @param array 更新后的数组
	 */
	public static void printResult(boolean status, int[] array) {
		if (status) {
			System.out.println(Arrays.toString(array));
		} else {
			System.out.println("Input Parameter Error");
		}
	}
}

超出数组会溢出

8.删除数组中指定下标的元素

和添加元素基本一致,逻辑变为从删除位置开始之后的元素都往前移一位,直接覆盖掉要删除位置元素

核心代码

for (int i = index; i

0代表无效元素,占位使用

全部代码

package cn.ocean888;

import java.util.Arrays;

public class Demo3 {
	// 删除指定位置元素
	public static void main(String[] args) {
		// 先定义数组
		int[] array = { 1, 3, 5, 7, 9, 11, 11, 13, 15, 17};
		System.out.println(Arrays.toString(array));
		// 要删除位置的索引
		int index = 6;
		boolean status = false;
		status = delElement(array, index);
		printResult(status, array);
	}
	
	/**
	 * 在数组指定位置删除元素,后面的依次往前移一位
	 * @param array 要添加元素的数组
	 * @param index 添加进数组的位置索引
	 * @return 返回是否添加成功
	 */
	public static boolean delElement (int[] array, int index) {
		// 判断删除位置是否存在于数组中
		if (index <0 || index >= array.length) {
			return false;
		} else {
			// 要删除元素位置开始往后元素依次向前移一位
			for (int i = index; i

9.冒泡排序算法

首先要明白一点,形参是引用传值,传的是数组的首地址,操作的还是原来的数组

package cn.ocean888;

import java.util.Arrays;

public class Demo4 {
	public static void main(String[] args) {
		int[] array = { 4399, 3, 360, 3, 4, 11, 32, 3, 123, 86};
		System.out.println(Arrays.toString(array));
		arraySort(array);
		System.out.println(Arrays.toString(array));
	}
    
    	public static void arraySort(int[] array) {
		array[5] = 0;
	}
}

for循环示意图,也就是10个数两两比较,需要9次可以找出一个最大值,并且将最大值放到最后边

i表示外部即第一层循环控制循环次数

j表示内部即第二层循环控制那些数两两间进行比较

i=0 时,j 要循环9次,找出最大值放到最后,下一次循环时最大值就不需要再管了

i=1 时,因为已经找到了最大值,所以这次 j 循环八次就可以了

i和j的对应关系: j = 数组长度 -1 - i

为啥要减1:因为10个数两两比较,仅需要比较九次

源码如下

package cn.ocean888;

import java.util.Arrays;

public class Demo4 {
	public static void main(String[] args) {
		// 冒泡排序算法,由小到大排序
		int[] array = { 4399, 3, 360, 3, 4, 11, 32, 3, 123, 86};
		// 打印数组
		System.out.println(Arrays.toString(array));
		// 进行排序
		arraySort(array);
		// 打印数组
		System.out.println(Arrays.toString(array));
	}
	
	/**
	 * 冒泡排序
	 * @param array 要排序的数组
	 */
	public static void arraySort(int[] array) {
		// 临时变量
		int temp = 0;
		// 第一层循环控制循环次数
		for (int i = 0; i 
				if (array[j+1]

排序效果

10.选择排序

选择排序基本想法是:比如有10个数,最大值在每次循环前初始化设置为数组第1个元素的值即array[0],然后与数组的其他剩余元素进行比较,所以比较次数就是数组总元素-1,10个数循环9次就可以找到最大值,最大值和本次最后的项位置进行互换

在i=1时,因为已经找到一个最大值并且放到最后了,所以j可以少循环依次

j = 数组的长度-i-1

i = 1 时

package cn.ocean888;

import java.util.Arrays;

import javax.swing.plaf.basic.BasicInternalFrameTitlePane.MaximizeAction;

public class Demo5 {
	public static void main(String[] args) {
		// 选择排序算法,由小到大排序
		// 要排序的原数组
		int[] array = { 4399, 3, 360, 3, 4, 11, 32, 3, 123, 86};
		// 打印数组
		System.out.println(Arrays.toString(array));
		// 进行排序
		arraySort(array);
		// 打印数组
		System.out.println(Arrays.toString(array));
	}
	
	/**
	 * 选择排序算法,由小到大排序
	 * @param array 要排序的数组,引用赋值直接操作数组不需要返回值
	 */
	public static void arraySort(int[] array) {
		for (int i = 0; i  array[max]) {
					max = j;
				}
			}
			// 将最大值和本次最后的项进行互换
			temp = array[array.length - 1 -i];
			array[array.length - 1 -i] = array[max];
			array[max] = temp;
		}
	}
}

效果展示

选择排序相较于冒泡排序来说要快一些，选择排序的时间复杂度为n(n-1)/2，而冒泡排序为O(n^2)，一般建议选择排序，当然还有其他更好的排序方法。

到此这篇关于java数组算法例题代码详解(冒泡排序,选择排序,找最大值、最小值,添加、删除元素等)的文章就介绍到这了,更多相关java数组算法内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

算法

推荐阅读

算法
深入理解OAuth认证机制

本文介绍了OAuth认证协议的核心概念及其工作原理。OAuth是一种开放标准，旨在为第三方应用提供安全的用户资源访问授权，同时确保用户的账户信息（如用户名和密码）不会暴露给第三方。 ... [详细]

蜡笔小新 2024-12-28 12:07:46
算法
深入理解KMP算法中的next数组：北大OJ 2406题解

本文详细探讨了KMP算法中next数组的构建及其应用，重点分析了未改良和改良后的next数组在字符串匹配中的作用。通过具体实例和代码实现，帮助读者更好地理解KMP算法的核心原理。 ... [详细]

蜡笔小新 2024-12-28 11:30:01
算法
新浪笔试题

1:有如下一段程序：packagea.b.c;publicclassTest{privatestaticinti0;publicintgetNext(){return ... [详细]

蜡笔小新 2024-12-27 19:32:17
算法
C++实现经典排序算法

本文详细介绍了七种经典的排序算法及其性能分析。每种算法的平均、最坏和最好情况的时间复杂度、辅助空间需求以及稳定性都被列出，帮助读者全面了解这些排序方法的特点。 ... [详细]

蜡笔小新 2024-12-27 19:25:14
算法
使用动态规划算法求解0-1背包问题

本文介绍如何利用动态规划算法解决经典的0-1背包问题。通过具体实例和代码实现，详细解释了在给定容量的背包中选择若干物品以最大化总价值的过程。 ... [详细]

蜡笔小新 2024-12-27 19:17:15
算法
深入理解设计模式与七大原则

本文详细探讨了Java中的24种设计模式及其应用，并介绍了七大面向对象设计原则。通过创建型、结构型和行为型模式的分类，帮助开发者更好地理解和应用这些模式，提升代码质量和可维护性。 ... [详细]

蜡笔小新 2024-12-27 19:10:10
算法
Java并发编程：LinkedBlockingQueue的实际应用

本文介绍了Java并发库中的阻塞队列（BlockingQueue）及其典型应用场景。通过具体实例，展示了如何利用LinkedBlockingQueue实现线程间高效、安全的数据传递，并结合线程池和原子类优化性能。 ... [详细]

蜡笔小新 2024-12-27 18:51:49
算法
USACO 2014 Jan - Moolympics区间记录优化算法

题目描述：给定n个半开区间[a, b)，要求使用两个互不重叠的记录器，求最多可以记录多少个区间。解决方案采用贪心算法，通过排序和遍历实现最优解。 ... [详细]

蜡笔小新 2024-12-27 18:14:31
机器学习
深入理解C++中的KMP算法：高效字符串匹配的利器

本文详细介绍C++中实现KMP算法的方法，探讨其在字符串匹配问题上的优势。通过对比暴力匹配（BF）算法，展示KMP算法如何利用前缀表优化匹配过程，显著提升效率。 ... [详细]

蜡笔小新 2024-12-27 14:45:30
算法
LeetCode 991：故障计算器的最优解法

探讨一个显示数字的故障计算器，它支持两种操作：将当前数字乘以2或减去1。本文将详细介绍如何用最少的操作次数将初始值X转换为目标值Y。 ... [详细]

蜡笔小新 2024-12-27 14:34:44
算法
Java面试题解析

本文详细介绍了Java编程语言中的核心概念和常见面试问题，包括集合类、数据结构、线程处理、Java虚拟机（JVM）、HTTP协议以及Git操作等方面的内容。通过深入分析每个主题，帮助读者更好地理解Java的关键特性和最佳实践。 ... [详细]

蜡笔小新 2024-12-27 13:55:14
算法
设计一个安全的加密与验证算法

本文探讨如何设计一个安全的加密和验证算法，确保生成的密码具有高随机性和低重复率，并提供相应的验证机制。 ... [详细]

蜡笔小新 2024-12-27 13:49:45
机器学习
深入解析：手把手教你构建决策树算法

本文详细介绍了机器学习中广泛应用的决策树算法，通过天气数据集的实例演示了ID3和CART算法的手动推导过程。文章长度约2000字，建议阅读时间5分钟。 ... [详细]

蜡笔小新 2024-12-27 13:44:59
算法
C语言实现小写金额转换为大写金额

在金融和会计领域，准确无误地填写票据和结算凭证至关重要。这些文件不仅是支付结算和现金收付的重要依据，还直接关系到交易的安全性和准确性。本文介绍了一种使用C语言实现小写金额转换为大写金额的方法，确保数据的标准化和规范化。 ... [详细]

蜡笔小新 2024-12-27 12:39:06
算法
每日一题：寻找与众不同的数字

在给定的数组中，除了一个数字外，其他所有数字都是相同的。任务是找到这个唯一的不同数字。例如，findUniq([1, 1, 1, 2, 1, 1]) 返回 2，findUniq([0, 0, 0.55, 0, 0]) 返回 0.55。 ... [详细]

蜡笔小新 2024-12-27 12:19:16

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章