數組常見思想

1.最值思想

原理：

假設第一個數為最大值max，周遊擷取到數組的每一個元素

拿到每一個元素和這個max進行比較

如果比假定的最大值還要大，那麼将該數指派給最大值

功能：求出最大值

傳回值類型：int

參數清單：int[] arr

方法名：getMax

public static int getMax(int[] arr){
				//假設第一個數為最大值
				int max = arr[0];
				//周遊數組中的每一個元素
				for(int i = 0; i < arr.length; i++){
					//擷取到數組中的每一個元素arr[i]，擷取的元素并判斷是否比max大
					if(arr[i] > max){
					//設定arr[i]的值為最大值
						max = arr[i];
					}
				}
				return max;
			}

功能：求出最小值

傳回值類型：int

參數清單：int[] arr

方法名：getMin

public static int getMin(int[] arr) {
	//假設第一個數為最小值
	int min = arr[0];
	//周遊數組中的每一個數，擷取arr[i]
	for (int i = 0; i < arr.length; i++) {
	if (arr[i] < min) {
		min = arr[i];
}
}
	return min;
}

2.求和思想

周遊數組中的元素，定義求和變量

功能：求出數列中所有數值的和

傳回這類型：int

參數清單：int[] arr

方法名：getSum;

//定義求和變量
double sum = 0.0;
	for(int i = 0; i < arr.length; i++){
	//累加求和
	sum += arr[i];
	}return sum;

3.求平均值思想

功能：求和數組中所有資料的平均值

傳回值類型：int

參數清單：int[] arr

方法名：getAvgValue

周遊數組中的元素，定義求和變量，擷取數組元素之和，然後與數組長度相除

public static int getAvgValue(int[] arr) {
			//定義數組中所有數值求和變量
			double sum = 0.0;
			for(int i = 0; i < arr.length; i++){
				sum += arr[i];
			}
			//定義平均值變量
			double average = sum / arr.length;
			return average；
}

4.倒置思想

定義臨時變量，周遊次數為i/2,講A值賦給臨時變量，再将B值賦給A值，再将臨時變量的值賦給B值

功能：将數組中的數倒置并輸出

傳回這類型：void

參數清單：int[] arr

方法名：reverseArray

/*
eg:{8,4,2,1,23,344,12}  --> {12,344,23,1,2,4,8}
分析：
第一次交換
第一個數和最後一個數交換位置
定義臨時變量
int temp = 0;
temp = arr[0];
arr[0] == arr[arr.length - 1 - 0];
arr[arr,length - 1 - 0] = temp;

第二次交換
第二個數和倒數第二個數交換位置
int temp = 0;
temp = arr[1];
arr[1] = arr[arr.length - 1 - 1];
arr[arr.length -1 - 1] = temp;

第三次交換
第三個數和倒數第三個數交換位置
int temp = 0;
temp = arr[2];
arr[2] = arr[arr.length - 1 - 2];
arr[arr.length - 1 - 2] = temp;

循環體代碼：
int temp = 0;
temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;

循環此數：
7個數-------------->交換三次
6個數-------------->交換三次
5個數-------------->交換二次
4個數-------------->交換二次
3個數-------------->交換一次
2個數-------------->交換一個
i個數-------------->交換i/2次
*/
public static void reverseArray(int[] arr){
				for(int i = 0; i < arr.length / 2; i++){
					int temp = 0;
					temp = arr[i];
					arr[i] = arr[arr.length - 1 - i];
					arr[arr.length - 1 - i] = temp;
				}
			}

5.查找思想

1.基本查找

1.1周遊查找

功能：查找數組中是否包含此數

數組查找：從鍵盤中任意輸入一個資料，判斷數列中是否包含此數

參數清單：int[] arr, int num

傳回值類型：boolean

方法名：isContainsNum

public static boolean isContainsNum(int[] arr int num) {
	//定義要查找的數預設在數組中不存在
	boolean flag = false;
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == num) {
		//如果要查找的數等于數組中的數，将flag置為true，并退出循環
			flag = true;
			break;
		}
}
	return flag；
	
}

1.2通過索引查找，并傳回該數在數組中的索引值index

傳回值類型：int

參數清單：int[] arr ,int num

方法名：baiscSearch

public static int baiscSearch(int[] arr,int num) {
	//定義預設索引值為-1，表示沒找到
	int index = -1;
	//周遊數組中的數
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == num) {
		//如果周遊數組中的某個數等于要查找的數，将數列中這個數的下标指派給index，并退出循環
			index = i;
			break;
}

}
	return index;
}

2.二分查找

前提條件：這個數組中的元素是有序排列的

二分查找的查找過程圖

數組常見思想

傳回值類型：int

參數清單：int[] arr,int num

方法名:binarySearch

public static int binarySearch(int[] arr, int num) {
	//定義最大索引和最小索引
	int maxIndex = arr.length - 1;
	int minIndex = 0;
	//計算中間索引
	int midIndex = (maxIndex + minIndex) / 2;
	
	//将中間索引對應的值與要查找的數進行比較，如果比要查找的數大，那麼往左邊找，如果比要查找的數小，那麼往右邊找，依次類推，縮小範圍
	//定義while循環，一直找這個數
	while ( arr[midIndex] != num) {
		if (arr[midIndex] > num) {
			//如果大于num，下一次的查找的最大值将會變化，等于中間索引的值-1，最小值不變為0
			maxIndex = minIndex - 1;
	}else if (arr[midIndex] < num) {
			//如果小于num,下一次的查找最小值将會變化，等于中間索引的值+1，這時最大值就不變了為maxIndex = arr.length - 1
			minIndex = midIndex + 1;
	}
	//還要判斷下如果最小索引大于最大索引的時候
	if (minIndex > maxIndex) {
	//傳回-1表示沒找到
		return -1;
	}
	midIndex = (maxIndex+minIndex) / 2;	
}
	//相等的話直接傳回中間索引
	return midIndex;
}

6.排序思想

1.冒泡排序

原理

a.相鄰兩個元素進行比較，大的數會冒泡，每趟比較結束後，最大值就出現在最大索引處

b.一共比較了arr.length - 1趟

c.每趟比較的此數比上一次少一次

冒泡排序過程圖

數組常見思想

傳回值類型：void

參數清單：int[] arr

方法名：bubbleSort

public static void bubbleSort (int[] arr) {
	//int [] arr = {24,69,80,55,13};
	/*for (int i = 0; i < arr.lenght - 1 - 0; i++) {
		
		//arr[0]與arr[1]比較
		//arr[1]與arr[2]比較
		//arr[2]與arr[3]比較
		//arr[3]與arr[4]比較
		
		if (arr[i] > arr[i+1]) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	System.out.println("第一趟排序後的結果："+Arrays.toString(arr));
		for (int i = 0; i < arr.lenght - 1 - 1; i++) {
		
		//arr[0]與arr[1]比較
		//arr[1]與arr[2]比較
		//arr[2]與arr[3]比較
		
		if (arr[i] > arr[i+1]) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	System.out.println("第二趟排序後的結果："+Arrays.toString(arr));
		for (int i = 0; i < arr.lenght - 1 - 2; i++) {
		
		//arr[0]與arr[1]比較
		//arr[1]與arr[2]比較
		
		if (arr[i] > arr[i+1]) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	System.out.println("第三趟排序後的結果："+Arrays.toString(arr));
		for (int i = 0; i < arr.lenght - 1 - 3; i++) {
		
		//arr[0]與arr[1]比較
		
		if (arr[i] > arr[i+1]) {
			int temp = 0;
			temp = arr[i];
			arr[i] = arr[i+1];
			arr[i+1] = temp;
		}
	}
	System.out.println("第四趟排序後的結果："+Arrays.toString(arr));
	*/
	//循環體
	for (int i = 0; i < arr.length -1;i++) {
		for (int j = 0; j < arr.length - 1 - i) {
		if (arr[j] > arr [j+1]) {
			int temp = 0;
			temp = arr[j];
			arr[j] = arr[j + 1];
			arr[j + 1] = temp;
		}
		
		}

	}
	System.out.println("排序後的結果為："+Arrays.toString(arr));
}

2.選擇排序

原理

從左邊開始，依次和後面的所有數進行比較，小的數往前移，每一趟比較完畢後，最小的數出現在最前面

規律

1.一共比較了arr.length -1趟

2.每趟比上一趟少比較1次

3.每一趟初始比較位置是上一趟位置+1

4.前面的元素依次和後面每一個元素進行比較，小的往前移動

選擇排序過程圖

數組常見思想

傳回值類型：void

參數清單：int[] arr

方法名：selectSort

public static void selectSort(int[] arr) {
	/*
	//int[] arr = {44,89,100,77,33};
	arr[0]與arr[1]比較
	arr[0]與arr[2]比較
	arr[0]與arr[3]比較
	arr[0]與arr[4]比較
	比較4次
	int i = 0;
	for (int j = i + 1;j < arr.length; i++) {
		if (arr[i] > arr[j]) {
			int temp = o;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	System.out.println("第一次選擇排序的結果為："+Arrays.toString(arr));

	int i = 1;
	for (int j = i + 1;j < arr.length; i++) {
		if (arr[i] > arr[j]) {
			int temp = o;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	System.out.println("第二次選擇排序的結果為："+Arrays.toString(arr));
	
	int i = 2;
	for (int j = i + 1;j < arr.length; i++) {
		if (arr[i] > arr[j]) {
			int temp = o;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	System.out.println("第三次選擇排序的結果為："+Arrays.toString(arr));

	int i = 3;
	for (int j = i + 1;j < arr.length; i++) {
		if (arr[i] > arr[j]) {
			int temp = o;
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	System.out.println("第四次選擇排序的結果為："+Arrays.toString(arr));
	*/
	//循環體
	for (int i = 0; i < arr.length; i++) {
		for (int j = i + 1; j < arr.length; j++) {
			if (arr[i] > arr[j]) {
				int temp = 0;
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

3.插入排序

插入過程分析圖

數組常見思想

分析過程

插入排序，分有序區和無序區，有序區選數組中最左邊的一個，其他屬于無序區，然後将無序區的第一個數拿出來，放到臨時變量裡面，然後這個臨時變量裡面的值與有序區的第一個數進行比較

如果大于臨時區，就放到它後面，如果小于，将臨時變量的值指派給有序區的第一個，有序區的數往後排，依次類推

代碼實作如下：

public class DoInsertSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = {22,10,1,55,66,43};
		int i,j;
		//定義臨時變量存儲要比較的值
		int temp = 0;
		for (i = 1; i < arr.length; i++) {
			temp = arr[i];
			for (j = i - 1; j >= 0; j--) {				
				if (arr[j] < temp) {
					break; 
				}else {
					arr[j+1] = arr[j];
				}
			}
			arr[j+1] = temp;
		}
		System.out.println(Arrays.toString(arr));
	}

}

數組常見思想

1.最值思想

2.求和思想

3.求平均值思想

4.倒置思想

5.查找思想

1.基本查找

2.二分查找

6.排序思想

1.冒泡排序

原理

2.選擇排序

原理

3.插入排序

繼續閱讀

JAVA Math類與Random類Math類Random類

【React】1020- React useEffect 使用指南

面向對象與面向過程思想的概述

CodeChef PRIMEDST Prime Distance On Tree

delphi播放flash

力扣每日一練之數組下篇Day3

java多線程初步

JavaSE概念

HDU 5719 Arrange

數組複制

javaEE和javaweb的差別JavaEEJavaSEJavaEE 與 JavaSE 的差別與聯系JavaEE和JavaWeb的差別JavaEE與Java 的關系

HDU 4609 3-idiots

Java列印出任意規模空心菱形（菱形）

HDU 1402 A * B Problem Plus

Java中的日期類（Date）月曆類(Calendar)及其與String的轉換綜合練習——輸入生産日期計算保存期限及促銷日

數組和類數組