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[] 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 < 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));
// 要加入位置的索引
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(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 < 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[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)，一般建議選擇排序，當然還有其他更好的排序方法。
到此這篇關於java數組算法例題代碼詳解(冒泡排序,選擇排序,找最大值、最小值,添加、刪除元素等)的文章就介紹到這瞭,更多相關java數組算法內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- java Array和Arrays的區別總結
- Java常問面試內容–數組、聲明、初始化、冒泡、多維數組、稀疏數組
- Java 數據結構與算法系列精講之排序算法
- 帶你粗略瞭解Java數組的使用
- 聊聊Arrays.deepToString()和Arrays.toString()的區別