java數(shù)組算法例題代碼詳解(冒泡排序,選擇排序,找最大值、最小值,添加、刪除元素等)

更新時間：2021年05月10日 09:46:27 作者：Ocean:)

這篇文章主要介紹了java數(shù)組算法例題代碼詳解(冒泡排序,選擇排序,找最大值、最小值,添加、刪除元素等),本文給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下

1.數(shù)組逆序
2.找出數(shù)組中最大值所在下標(biāo)位置
3.找出數(shù)組中指定元素第一次出現(xiàn)的下標(biāo)位置
4.在數(shù)組中找出指定下標(biāo)對應(yīng)的元素
5.找出指定元素在數(shù)組中最后一次出現(xiàn)位置
6.找到元素在指定數(shù)組中的所有下標(biāo)位置
7.在指定位置插入指定元素
8.刪除數(shù)組中指定下標(biāo)的元素
9.冒泡排序算法
10.選擇排序

數(shù)組算法例題

1.數(shù)組逆序

第一個和最后一個互換，第二個和倒數(shù)第二個互換，就相當(dāng)于把數(shù)組想下圖一樣，進行對折互換，如果數(shù)組個數(shù)為奇數(shù)，則中間保持不變其余元素互換即可

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

    /**
     * 數(shù)組逆序
     * @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;
        }
    }
}

數(shù)組展示:System.out.println(Arrays.toString(arr));

2.找出數(shù)組中最大值所在下標(biāo)位置

因為是找下標(biāo)位置所以可以先定義一個值為數(shù)組下標(biāo)，直接使用數(shù)組[下標(biāo)] 方式進行比較

import java.util.Arrays;

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

    /**
     * 找到數(shù)組中最大的數(shù)并且輸出
     * @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("最大的數(shù)為 : %d 下標(biāo)為 : %d", arr[maxIndex] , maxIndex);
    }
}

3.找出數(shù)組中指定元素第一次出現(xiàn)的下標(biāo)位置

分析

第一次出現(xiàn)位置
如果有多個重復(fù)元素
有可能不存在指定元素

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

class Demo14 {
    public static void main (String[] args) {
        int num = 0;
        int index = 0;
        // 定義數(shù)組
        int[] array = { 4399, 327, 360, 3, 4, 11, 32, 45, 123, 86};
        // 輸出數(shù)組
        System.out.println(Arrays.toString(array));
        // 獲取用戶輸入數(shù)據(jù)
        num = getInputNum();
        // 獲取用戶輸入數(shù)據(jù)在數(shù)組中第一次出現(xiàn)的位置
        index = getIndexOfNum(array, num);
        // 輸出位置索引
        printIndexNum(num, index);
    }

    /**
     * 接受用戶傳來的數(shù)據(jù)
     * @return 返回接受的數(shù)據(jù)
     */
    public static int getInputNum () {
        int num = 0;
        java.util.Scanner sc = new Scanner(System.in);
        System.out.println("請輸入您要查詢的數(shù)據(jù):");
        num = sc.nextInt();
        return num;
    }

    /**
     * 找出數(shù)組中指定元素第一次出現(xiàn)的下標(biāo)位置
     * @param array
     * @return 返回下標(biāo)
     */
    public static int getIndexOfNum(int[] array, int num) {
        // 如果找不到數(shù)據(jù),則默認(rèn)是-1
        int index = -1;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == num) {
                index = i;
                break;
            }
        }
        return index;
    }

    /**
     * 輸出數(shù)據(jù)
     * @param num 數(shù)組中某一項的值
     * @param indexNum 索引值
     */
    public static void printIndexNum(int num, int indexNum) {
        if (indexNum == -1) {
            System.out.println(num + "不在數(shù)組中");
        } else {
            System.out.println("數(shù)組中" + num + "第一次出現(xiàn)的下標(biāo)位置 : " + indexNum);
        }
    }
}

4.在數(shù)組中找出指定下標(biāo)對應(yīng)的元素

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

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

class Demo15 {
    public static void main(String[] args) {
        // 下標(biāo)值
        int indexNum = 0;
        // 下標(biāo)對應(yīng)的數(shù)值
        int num = 0;
        // 定義數(shù)組
        int[] array = { 4399, 327, 360, 3, 4, 11, 32, 45, 123, 86};
        // 輸出數(shù)組
        System.out.println(Arrays.toString(array));
        // 接受用戶傳來的下標(biāo)值
        indexNum = getIndexNum();
        // 查詢數(shù)組中下標(biāo)值對應(yīng)的數(shù)值
        num = findNumInArray(indexNum, array);
        // 輸出數(shù)值
        printNum(indexNum, num);
    }

    /**
     * 接受用戶傳來的下標(biāo)值
     * @param indexNum 用戶傳來的下標(biāo)值
     * @return 下標(biāo)值
     */
    public static int getIndexNum() {
        int indexNum = 0;
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入想要查詢的下標(biāo)值:");
        indexNum = sc.nextInt();
        return indexNum;
    }

    /**
     * 查詢數(shù)組中下標(biāo)值對應(yīng)的數(shù)值
     * @param indexNum 下標(biāo)值
     * @param array 數(shù)組
     * @return 返回下標(biāo)值對應(yīng)的數(shù)值
     */
    public static int findNumInArray(int indexNum, int[] array) {
        int num = 0;
        // 判斷用戶傳來的下標(biāo)值是否正確,是否越界
        if (indexNum > 0 && indexNum < array.length) {
            num = array[indexNum];
        } else {
            // 如果越界num值為-1
            num = -1;
        }
        return num;
    }

    /**
     * 輸出數(shù)值
     * @param num
     */
    public static void printNum(int indexNum, int num) {
        if (num == -1) {
            System.out.println(indexNum + "索引越界");
            System.exit(0);
        } else {
            System.out.println("數(shù)組中" + indexNum + "位置的元素為 : " + num);
        }
    }
}

5.找出指定元素在數(shù)組中最后一次出現(xiàn)位置

和找出第一個方法差不多

tips:

既然是找最后一個數(shù)字,可以倒序查找,提高效率
判斷找不到的情況

package cn.ocean888;

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

// 找出指定元素在數(shù)組中最后一次出現(xiàn)位置

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();
		// 找出指定元素在數(shù)組中最后一次出現(xiàn)位置
		index = getLastIndexOf(array, num);
		// 輸出下標(biāo)
		printIndex(index);
	}
	
	/**
	 * 獲取用戶輸入
	 * @param num 用戶輸入數(shù)字
	 * @return num
	 */
	public static int getInputNum() {
		int num = 0;
		Scanner sc = new Scanner(System.in);
		System.out.println("請輸入數(shù)組中的一個數(shù)字:");
		num = sc.nextInt();
		return num;
	}
	
	/**
	 * 找出指定元素在數(shù)組中最后一次出現(xiàn)位置
	 * @param array
	 * @param num
	 */
	public static int getLastIndexOf(int[] array, int num) {
		int index = -1;
		// 既然是找最后一個數(shù)字,可以倒序查找,提高效率
		for (int i = array.length - 1; i >= 0 ; i--) {
			if (array[i] == num) {
				index = i;
				break;
			}
		}
		return index;
	}
	
	/**
	 * 輸出下標(biāo)
	 * @param index
	 */
	public static void printIndex(int index) {
		if (index != -1) {
			System.out.println("指定元素在數(shù)組中最后一次出現(xiàn)位置為:" + index);
		} else {
			System.out.println("指定元素沒有在數(shù)組中出現(xiàn)");
		}
	}
}

一定要注意,for循環(huán)判斷 i < array.length 不是小于等于,因為是從0開始

6.找到元素在指定數(shù)組中的所有下標(biāo)位置

要求:

不允許在方法內(nèi)打印展示
考慮多個數(shù)據(jù)情況
需要在方法外獲取到下標(biāo)數(shù)據(jù)信息
不允許使用數(shù)組作為返回值

思考1:

保存查詢數(shù)據(jù)的下標(biāo)位置一定會用到數(shù)組
保存下標(biāo)的數(shù)組數(shù)據(jù)類型是int類型

解決:

另外使用一個數(shù)組,作為形式參數(shù),傳遞首地址,使用此數(shù)組存放下標(biāo)位置,因為是傳遞的地址,可以直接更改數(shù)組內(nèi)容,并不需要返回數(shù)組的值

思考2:

需要考慮保存下標(biāo)的數(shù)組容量

解決:

返回值數(shù)組容量和原數(shù)組容量一致,這樣及時數(shù)組內(nèi)元素值一致且被選中,也可以存儲下來

思考3:

返回值,怎么表示,用什么類型數(shù)據(jù)

new創(chuàng)建一個新的數(shù)組,int類型數(shù)組中,所有元素初始值都是0,用什么判斷元素索引

解決:

返回找到的元素個數(shù),沒有則返回0

package cn.ocean888;

import java.util.Arrays;

public class Demo2 {
	public static void main(String[] args) {
		// 假設(shè)用戶要查詢3在數(shù)組中出現(xiàn)的位置
		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數(shù)組查num重復(fù)值索引放到array2中
		count = allIndexOf(array1, array2, num);
		// 打印輸出查詢3在數(shù)組中出現(xiàn)的位置
		printArray(array2, count);
		// 打印輸出整個數(shù)組
		System.out.println(Arrays.toString(array2));
	}
	
	/**
	 * 從元素組找到元素在指定數(shù)組中的所有下標(biāo)位置,將下標(biāo)位置依次賦值給array2數(shù)組
	 * 返回值為array2數(shù)組長度,即有多少個重復(fù)的值
	 * @param array1 原數(shù)組
	 * @param array2 存儲重復(fù)值索引的數(shù)組
	 * @return conunt 有多少個重復(fù)的值
	 */
	public  static int allIndexOf(int[] array1, int[] array2, int num) {
		// count值既是返回時的存儲重復(fù)值索引的數(shù)組array2的長度,也在循環(huán)中可以當(dāng)作array2的索引
		int count = 0;
		for (int i = 0; i < array1.length; i++) {
			if (array1[i] == num) {
				array2[count] = i;
				count++;
			}
		}
		return count;
	}
	
	/**
	 * 打印array2數(shù)組
	 * @param array2
	 */
	public static void printArray(int[] array2, int count) {
		for (int i = 0; i < count; i++) {
			System.out.println(array2[i]);
		}
	}
}

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

在數(shù)組指定位置添加元素,指定位置后面的依次往后移一位,最后一個0就是要被擠掉的,可以從后向前進行循環(huán)操作

核心代碼

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) {
		// 先定義數(shù)組,最后一個0就是要被擠掉的
		int[] array = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
		System.out.println(Arrays.toString(array));
		// 要加入位置的索引
		int index = 6;
		// 要加到這個數(shù)組里的數(shù)字
		int insert = 12;
		boolean status = false;
		status = addElement(array, index, insert);
		printResult(status, array);
	}
	
	/**
	 * 在數(shù)組指定位置添加元素,后面的依次往后移一位
	 * @param array 要添加元素的數(shù)組
	 * @param index 添加進數(shù)組的位置索引
	 * @param insert 要添加進入數(shù)組對應(yīng)位置的值
	 * @return 返回是否添加成功
	 */
	public static boolean addElement (int[] array, int index, int insert) {
		// 判斷插入位置是否存在于數(shù)組中
		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;
		}
	}
	
	/**
	 * 輸出更新后的數(shù)組
	 * @param status 添加元素是否成功的狀態(tài)
	 * @param array 更新后的數(shù)組
	 */
	public static void printResult(boolean status, int[] array) {
		if (status) {
			System.out.println(Arrays.toString(array));
		} else {
			System.out.println("Input Parameter Error");
		}
	}
}

超出數(shù)組會溢出

8.刪除數(shù)組中指定下標(biāo)的元素

和添加元素基本一致,邏輯變?yōu)閺膭h除位置開始之后的元素都往前移一位,直接覆蓋掉要刪除位置元素

核心代碼

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) {
		// 先定義數(shù)組
		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);
	}
	
	/**
	 * 在數(shù)組指定位置刪除元素,后面的依次往前移一位
	 * @param array 要添加元素的數(shù)組
	 * @param index 添加進數(shù)組的位置索引
	 * @return 返回是否添加成功
	 */
	public static boolean delElement (int[] array, int index) {
		// 判斷刪除位置是否存在于數(shù)組中
		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;
		}
	}
	
	/**
	 * 輸出更新后的數(shù)組
	 * @param status 添加元素是否成功的狀態(tài)
	 * @param array 更新后的數(shù)組
	 */
	public static void printResult(boolean status, int[] array) {
		if (status) {
			System.out.println(Arrays.toString(array));
		} else {
			System.out.println("Input Parameter Error");
		}
	}
}

9.冒泡排序算法

首先要明白一點,形參是引用傳值,傳的是數(shù)組的首地址,操作的還是原來的數(shù)組

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循環(huán)示意圖,也就是10個數(shù)兩兩比較,需要9次可以找出一個最大值,并且將最大值放到最后邊

i表示外部即第一層循環(huán)控制循環(huán)次數(shù)

j表示內(nèi)部即第二層循環(huán)控制那些數(shù)兩兩間進行比較

i=0 時,j 要循環(huán)9次,找出最大值放到最后,下一次循環(huán)時最大值就不需要再管了

i=1 時,因為已經(jīng)找到了最大值,所以這次 j 循環(huán)八次就可以了

i和j的對應(yīng)關(guān)系: j = 數(shù)組長度 -1 - i

為啥要減1:因為10個數(shù)兩兩比較,僅需要比較九次

源碼如下

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};
		// 打印數(shù)組
		System.out.println(Arrays.toString(array));
		// 進行排序
		arraySort(array);
		// 打印數(shù)組
		System.out.println(Arrays.toString(array));
	}
	
	/**
	 * 冒泡排序
	 * @param array 要排序的數(shù)組
	 */
	public static void arraySort(int[] array) {
		// 臨時變量
		int temp = 0;
		// 第一層循環(huán)控制循環(huán)次數(shù)
		for (int i = 0; i < array.length - 1; i++) {
			// 第二層循環(huán)控制那些數(shù)兩兩間進行比較
			for (int j = 0; j < array.length -1 - i; j++) {
				// 如果時從小到大排序if判斷就用<
				// 如果時從小到大排序if判斷就用>
				if (array[j+1] < array[j]) {
					// 兩個值間通過一個臨時變量進行互換
					temp = array[j+1];
					array[j+1] = array[j];
					array[j] = temp;
				}
			}
		}	
	}
}

排序效果

10.選擇排序

選擇排序基本想法是:比如有10個數(shù),最大值在每次循環(huán)前初始化設(shè)置為數(shù)組第1個元素的值即array[0],然后與數(shù)組的其他剩余元素進行比較,所以比較次數(shù)就是數(shù)組總元素-1,10個數(shù)循環(huán)9次就可以找到最大值,最大值和本次最后的項位置進行互換

在i=1時,因為已經(jīng)找到一個最大值并且放到最后了,所以j可以少循環(huán)依次

j = 數(shù)組的長度-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) {
		// 選擇排序算法,由小到大排序
		// 要排序的原數(shù)組
		int[] array = { 4399, 3, 360, 3, 4, 11, 32, 3, 123, 86};
		// 打印數(shù)組
		System.out.println(Arrays.toString(array));
		// 進行排序
		arraySort(array);
		// 打印數(shù)組
		System.out.println(Arrays.toString(array));
	}
	
	/**
	 * 選擇排序算法,由小到大排序
	 * @param array 要排序的數(shù)組,引用賦值直接操作數(shù)組不需要返回值
	 */
	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;
		}
	}
}

效果展示