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

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 < arr.length / 2; i++) {

int temp = arr[arr.length - 1 - i];

arr[arr.length - 1 - i] = arr[i];

arr[i] = temp;

}

}

}

数组展示: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.length; i++) {

if (arr[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 < array.length; i++) {

if (array[i] == num) {

index = i;

break;

}

}

return index;

}

/**

* 输出数据

* @param num 数组中某一项的值

* @param indexNum 索引值

*/

public static void printIndexNum(int num, int indexNum) {

if (indexNum == -1) {

System.out.println(num + "不在数组中");

} else {

System.out.println("数组中" + num + "第一次出现的下标位置 : " + indexNum);

}

}

}

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 < array.length) {

num = array[indexNum];

} else {

// 如果越界num值为-1

num = -1;

}

return num;

}

/**

* 输出数值

* @param num

*/

public static void printNum(int indexNum, int num) {

if (num == -1) {

System.out.println(indexNum + "索引越界");

System.exit(0);

} else {

System.out.println("数组中" + indexNum + "位置的元素为 : " + num);

}

}

}

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

和找出第一个方法差不多

tips:

既然是找最后一个数字,可以倒序查找,提高效率

判断找不到的情况

package cn.ocean888;

import java.util.Arrays;

import java.util.Scanner;

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

public class Demo1 {

public static void main(String[] argsyXAjQbv) {

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 < array.length 不是小于等于,因为是从0开始

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 < array1.length; i++) {

if (array1[i] == num) {

array2[count] = i;

count++;

}

}

return count;

}

/**

* 打印array2数组

* @param array2

*/

public static void printArray(int[] array2, int count) {

for (int i = 0; i < count; i++) {

System.out.println(array2[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));

// 要加yXAjQbv入位置的索引

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 < array.length - 1; i++) {

array[i] = array[i+1];

}

// 最后一个元素补零

array[array.length - 1] = 0;

return true;

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 < array.length - 1; i++) {

array[i] = array[i+1];

}

// 最后一个元素补零

array[array.length - 1] = 0;

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");

}

}

}

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(Arhttp://rays.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 < array.length - 1; i++) {

// 第二层循环控制那些数两两间进行比较

for (int j = 0; j < array.length -1 - i; j++) {

// 如果时从小到大排序if判断就用<

// 如果时从小到大排序if判断就用>

if (array[j+1] < array[j]) {

// 两个值间通过一个临时变量进行互换

temp = array[j+1];

array[http://j+1] = array[j];

array[j] = temp;

}

}

}

}

}

排序效果

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.length; i++) {

int max = 0;

int temp = 0;

// 找出最大值索引,赋值给max

for (int j = 0; j < array.length - i; j++) {

if (array[j] > 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)，一般建议选择排序，当然还有其他更好的排序方法。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。