Java 基礎09-數組和算法
數組和算法
1. 數組
1.1 爲何要使用數組
在開發中會出現大量重複的，而且是同一個類型的數據，須要同時時候，若是按照一個一個的變量定義，會致使代碼出現如下一些問題：
1、代碼過於臃腫
2、代碼閱讀性極差
3、代碼維護性極差
複製代碼
1.2 Java 中定義數組的格式
變量的定義格式：
數據類型 變量名 = 初始化數據;
數組的定義格式：
數據類型[] 數組名 = new 數據類型[容量];
賦值號左側：
數據類型：
肯定當前數組中可以保存數據類型是什麼，要求當前數組中有且只能保存指定的數據類型，嚴格執行數據類型一致化。
[]：
1、肯定當前建立的是一個數組類型;
2、肯定數組名是一個"引用數據類型"，引用數據的變量裏面保存的是另外一個數據空間的地址。
數組名：
1、操做當前數組使用的名字;
2、數組名是一個引用數據類型變量。
賦值號右側：
new：
建立數組空間的關鍵字。
數據類型：
先後一致，保證數據類型一致化，要求建立的數據類型是指定的數據類型。
[容量]：
肯定當前數組中數據容量是多少，並且建立以後，不能夠改變。
數組的下標：
數組的有效下標是從 0 開始到 數組的容量 - 1。
若是數組的容量是 10，有效小標的範圍就是 0 ~ 9。
使用格式：
數組名[有效下標];
arr[0] = 10;
System.out.println(arr[0]);
複製代碼
1.3 數組的內存分析圖
棧內存，存儲的是值
數據存儲在內存中
內存是分區域的，目前代碼中會涉及到"棧區"和"堆區"
複製代碼
0x8848 這是內存地址。
認爲是**省**市**區**路**號
數組下標 arr[0] arr[5]
認爲是須要尋找的房間號 1001A 1005A
複製代碼
1.4 數組和循環不得不說的祕密
對於數組的 CRUD 操做都是依賴循環完成的，並且大部分使用的循環都是 for 循環。
由於 for 循環能夠經過第一行的循環語句得知當前循環的大概次數，這個特徵很是適用於數組。
複製代碼
public class Demo {
public static void main(String[] args) {
// 定義一個數組 int 類型，容量爲 10
int[] arr = new int[10];
/* arr.length 是獲取數組中的屬性，數組的容量。 arr.length 獲取的結果就是 10 */
for(int i = 10; i < arr.length; i++) {
arr[i] = i + 1;
}
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
複製代碼
1.5 數組做爲方法的參數
// main方法就是一個使用數組做爲形式參數列表的方法
// String[] args 就是一個數組做爲方法參數的格式
// 數據類型[] 形式參數的名字
public static void main(String[] args) {
}
public class Demo {
public static void main(String[] args) {
// 定義一個int類型數組，容量爲10
int[] array = new int[10];
/* 該方法須要的參數是一個數組類型 把數組名做爲方法的參數傳入！！！ */
assignIntArray(array);
printIntArray(array);
}
/* 需求: 完成一個方法，給予int類型數組進行賦值操做 方法名: assignIntArray 形式參數列表： 須要一個int類型數組，格式 int[] arr 返回值類型: void 這裏目前不考慮返回值類型 public static void assignIntArray(int[] arr) */
/** * 完成一個方法，給予int類型數組進行賦值操做 * @param arr int類型的數組 */
public static void assignIntArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = i + 1;
}
}
/* 需求： 完成一個方法，展現int類型數組 方法名： printIntArray 形式參數列表: 須要展現的int類型數組，格式 int[] arr 返回值類型： void 這裏目前不考慮返回值類型，後期會考慮！！！boolean int public static void printIntArray(int[] arr); */
/** * 展現一個int類型數組 * @param arr 須要的int類型數組 */
public static void printIntArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
複製代碼
2.練習
2.1 找出指定 int 類型數組中【最大值下標】和【最小值下標】位置
public class Demo {
public static void main(String[] args) {
int[] array = {1, 3, 5, 17, 9, 2, 4, 6, 17, 10};
int index = maxIndexInArray(array);
System.out.println(index);
}
/* 定義一個方法，能夠找出指定 int 類型數組中最大值下標位置 方法分析： 方法名: maxIndexInArray 形式參數列表： 這裏須要一個 int 類型的數組 int[] array 返回值類型: 這裏但願獲得的是最大值下標，全部返回值類型是下標範圍，就是 int 類型 public static int maxIndexInArray(int[] array) */
/** * 找出指定數組中最大值所在下標位置 * @param array 指定的 int 類型數組 * @return 返回最大值所在下標位置 */
public static int maxIndexInArray(int[] array) {
// 一、假設下標爲 0 的數據時最大值
int maxIndex = 0;
// 二、利用循環進行兩兩比較，而且數據比較從 1 開始
for (int i = 1; i < array.length; i++) {
// 三、判斷下標爲 maxIndex 元素若是小於下標爲 i 的元素，保存下標 i 的值到 maxIndex
if (array[maxIndex] < array[i]) {
maxIndex = i;
}
}
return maxIndex;
}
}
複製代碼
/* 定義一個方法，能夠找出指定 int 類型數組中最小值下標位置 方法分析： 方法名: minIndexInArray 形式參數列表： 這裏須要一個 int 類型的數組 int[] array 返回值類型: 這裏但願獲得的是最小值下標，全部返回值類型是下標範圍，就是 int 類型 public static int minIndexInArray(int[] arra */
/** * 找出指定數組中最小下標的元素 * @param array 指定的 int 類型數組 * @return 當前數組中最小值的下標位置 */
public static int minIndexInArray(int[] array) {
int minIndex = 0;
for (int i = 1; i < array.length; i++) {
if (array[minIndex] > array[i]) {
minIndex = i;
}
}
return minIndex;
}
複製代碼
2.2 找出指定 int 類型數據所在的【下標】位置
/* 定義一個方法，在指定 int 類型數組中，找出指定 int 類型數據所在的下標位置 找到返回值下標值: 0 ~ arr.length - 1 找不到返回 -1 方法分析: 方法名: indexOf 形式參數列表: 第一個: 須要一個 int類型的數據 int[] array 第二個: 肯定須要查詢的數據， int int find 返回值類型： int 類型，找到返回值大於等於 0，沒有找到返回-1 public static int indexOf(int[] array, int find) */
/** * 找出指定數據在指定數組中下標位置，找到返回值大於等 0，沒有找到返回 -1 * @param array 查詢數據的數組 int 類型數組 * @param find 查詢的指定數據 in t類型數據 * @return 找到返回值大於等 0，沒有找到返回 -1 */
public static int indexOf(int[] array, int find) {
// 一、假設找不到數據
int index = -1;
// 二、利用循環，兩兩比較，找出指定數據在數組中下標位置，而且保存到 index 變量中
for (int i = 0; i < array.length; i++) {
// 三、下標爲 i 的元素就是指定 find 數據，大家保存 下標 i 到 index 變量中
if (array[i] == find) {
index = i;
// 四、若是找到數據，終止循環！！！break;
break;
}
}
return index;
}
複製代碼
2.3 找出全部指定數據的下標位置
import java.util.Arrays;
public class FindAllInArray {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};
int[] indexes = new int[arr.length];
int count = findAllIndexes(arr, indexes, 5);
System.out.println(count);
for (int i = 0; i < count; i++) {
System.out.println(indexes[i]);
}
}
/* 在一個數組中，找出全部指定數據的下標位置 【難】 方法分析: 方法名: findAllIndexes 找出全部指定元素的下標位置 形式參數列表： 1. 哪個數組中進行查詢操做！！！ int[] arr 2. 要查詢的數據 int find 3. 須要另外的一個數組，保存找到的下標位置 a) 該數組是什麼是就類型??? int類型數組 b) 該數組的容量應該是什麼??? 和須要查詢的目標數組容量是一致的！！！ 返回值類型； 不考慮使用數組做爲返回值，這裏存在必定的隱患】 boolean: 運行成功返回true，運行失敗返回false int: ??? 返回找到的數據有多少個 public static int findAllIndexes(int[] arr, int[] indexes, int find) */
/** * 找出數組中指定元素 find在目標數組 arr的下標位置，而且保存到 indexes 數組中 * 返回值是找到的元素個數，沒有找到，返回 0 * @param arr 查詢數據目標數組，int類型 * @param indexes 保存找到數據下標位置的數組，int類型 * @param find 須要查詢的數據，int類型 * @return 返回值找到的元素個數，沒有找到，返回 0 */
public static int findAllIndexes(int[] arr, int[] indexes, int find) {
// 1. 參數合法性判斷
if (null == arr || null == indexes || arr.length == 0
|| indexes.length == 0 || indexes.length < arr.length) {
System.out.println("Input parameter is invalid!");
// 返回 0。結束方法，表示沒有找到
return 0;
}
// 2. 定義一個變量，計數
int count = 0;
// 3. 使用 for循環，遍歷目標數組 arr，使用 if判斷，找到目標元素
for (int i = 0; i < arr.length; i++) {
if (arr[i] == find) {
/* a. 計數 count++ b. 把找到的下標位置放到 indexes數組中 第一次找到: 須要存放到下標爲 0的位置，count++ count自增以前是 0 第二次找到： 須要存放到下標爲 1的位置，count++ count自增以前是 1 indexes是存放下標位置的數組，count是計數有多少個目標數據 i是找到的下標位置 count同時能夠表示當前 indexes數組中的有效元素個數 */
indexes[count++] = i;
}
}
return count;
}
}
複製代碼
2.4 替換指定元素
import java.util.Arrays;
public class ArrayReplace {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 0, 0, 0, 0, 0};
boolean ret = replace(array, 10);
System.out.println(ret);
System.out.println(Arrays.toString(array));
}
/* 完成一個方法，替換掉數組中全部元素之爲0的元素，替換爲指定元素 方法分析: 方法名: replace 形式參數列表： 須要替換數據的int類型數據 須要指定的元素 int類型 (int[] array, int newNumber) 返回值類型： 不推薦使用void，使用void做爲返回值的方法，是一個黑盒方法！！！ 給予當前方法一個狀態的監控！！！ boolean 方法運行成功返回true，失敗返回一個false 這玩意能失敗??? 1. 若是數組的容量爲0？？？ 會失敗！！！ 2. 數組名是一個引用數據類型，其中保存的內存地址不能爲 null 會失敗！！！ public static boolean replace(int[] array, int newNumber) */
/** * 替換指定數據中元素爲 0的值，替換爲 newNumber * @param array int類型數組 * @param newNumber 替換的int類型數組 * @return 方法運行成功返回 true，方法運行失敗，返回 false */
public static boolean replace(int[] array, int newNumber) {
// 1. 參數合法性判斷！！！
if (null == array || array.length == 0) {
System.out.println("輸入參數不合法！！！");
// 輸入參數不合法，返回 false 告知調用者，方法執行失敗！！！
return false;
}
for (int i = 0; i < array.length; i++) {
if (0 == array[i]) {
array[i] = newNumber;
}
}
return true;
}
}
複製代碼
2.4 刪除指定下標元素
import java.util.Arrays;
public class ArrayRemove {
public static void main(String[] args) {
int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
remove(array, 0);
System.out.println(Arrays.toString(array));
}
/* 完成一個方法，刪除指定下標的元素，要求從刪除位置開始，以後的元素總體前移。【難】 要求源數據數組是 int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19}; 刪除以後，須要在數組的末尾補0，0是無效元素 方法分析: 方法名: remove / delete 形式參數列表： 1. 刪除數據的目標數組 int[] arr 2. 指定刪除數據的下標位置 int index 返回值類型: boolean 刪除成功返回true，失敗返回false 什麼狀況下會失敗: a) 數組容量爲0 b) 數組中保存的地址爲 null c) 給予的刪除下標是一個非法下標 public static boolean remove(int[] arr, int index) */
/** * 在指定數組中，刪除指定下標 index上的元素。 * @param arr 指定的 int類型數組 * @param index 指定的刪除數據的下標，可是不能超出數組的有效下標範圍 0 ~ arr.length - 1 * @return 刪除操做成功返回 true，失敗返回 false */
public static boolean remove(int[] arr, int index) {
// 1. 參數合法性判斷
if (null == arr || arr.length == 0 || index < 0 || index > arr.length -1 ) {
System.out.println("Input parameter is invalid!");
return false;
}
/* 2. 使用 for循環完成操做 這裏使用 arr[i] = arr[i + 1]; */
for (int i = index; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
/* index = 5; arr.length = 10; arr[5] = arr[6]; i++ == 6 arr[6] = arr[7]; i++ == 7 arr[7] = arr[8]; i++ == 8 arr[8] = arr[9]; i++ == 9 arr[9] = arr[10]; ArrayIndexOutOfBoundsException */
}
arr[arr.length - 1] = 0;
return true;
}
}
複製代碼
2.5 添加元素到指定下標
import java.util.Arrays;
public class ArrayInsert {
public static void main(String[] args) {
int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
add(array, 20, 30);
System.out.println(Arrays.toString(array));
}
/* 完成一個方法，添加指定元素到指定下標位置，要求從指定下標位置以後的元素，總體向後移動。【難】 要求源數據數組是 int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0}; 0是無效元素，表示目前數組存在一個空位置 方法分析: 方法名： add 形式參數列表: 1. 數組 int[] arr 2. 指定下標位置 int index 3. 添加的數據 int number 返回值類型： boolean 成功返回true，失敗返回false 什麼狀況下會失敗: a) 數組容量爲0 b) 數組中保存的地址爲 null c) 給予的刪除下標是一個非法下標 public static boolean add(int[] arr, int index, int number) */
/** * 在數組中指定位置，添加指定元素 * * @param arr 指定的操做的數據，爲 int類型 * @param index 指定的下標位置，必須是在數組的有效下標範圍之內 0 ~ 數組容量 - 1 * @param number 添加的數據，爲 int類型 * @return 添加成功返回 true ，失敗返回 false */
public static boolean add(int[] arr, int index, int number) {
// 1. 參數合法性判斷
if (null == arr || arr.length == 0 || index < 0 || index > arr.length - 1) {
System.out.println("Input parameter is invalid!");
return false;
}
// 2. 利用循環移動數組中的元素，從最後一位開始
for (int i = arr.length - 1; i > index; i--) {
arr[i] = arr[i - 1];
/* index = 5; arr.length = 10; arr[9] = arr[8]; i-- == 8 arr[8] = arr[7]; i-- == 7 arr[7] = arr[6]; i-- == 6 arr[6] = arr[5]; i-- == 5 */
}
arr[index] = number;
return true;
}
}
複製代碼
3. 算法
3.1 選擇排序算法
import java.util.Arrays;
public class ArraySort {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
selectSort(arr);
System.out.println(Arrays.toString(arr));
}
/* 完成一個選擇排序算法 */
public static boolean selectSort(int[] arr) {
// 1. 參數合法性判斷
if (null == arr || arr.length == 0) {
System.out.println("Input parameter is invalid!");
return false;
}
// 2. 外層循環控制須要進行多少次選擇
for (int i = 0; i < arr.length - 1; i++) {
// 3. 使用一個變量，假設當前數組中極值
int index = i;
// 4. 找出極值下標位置
for (int j = i + 1; j < arr.length; j++) {
if (arr[index] > arr[j]) {
index = j;
}
}
// 5. 交換位置
if (index != i) {
int temp = arr[index];
arr[index] = arr[i];
arr[i] = temp;
}
}
return true;
}
複製代碼
3.2 冒泡排序算法
/* 冒泡排序 */
public static void BubbleSort(int[] arr) {
int length = arr.length;
int temp;
System.out.println("原始順序： " + Arrays.toString(arr));
//i表示第幾趟排序
for (int i = 1; i < length; i++) {
//每次都從最後一個開始，知道第len-1趟排序
for (int j = length - 1; j > i - 1; j--) {
//若是後面的比前面的小，就像泡泡同樣冒上去
if (arr[j] < arr[j - 1]) {
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
System.out.println("第" + i + "趟排序: " + Arrays.toString(arr));
}
}
複製代碼
3.3 二分查找算法
//二分法查找
public class HalfSearch {
public static void main(String[] args) {
int[] arr = {1, 3, 5, 7, 9, 11, 13, 13, 13, 19};
int i = halfSearch(arr, 13);
System.out.println(i);
}
/** * 二分法查找 * @param arr 通過排序的數組，默認爲升序 * @param find 須要查詢的數據 * @return 返回值爲 int類型，找到數據的下標位置，若是沒有找到返回 -1 */
public static int halfSearch(int[] arr, int find) {
if (null == arr || arr.length == 0) {
System.out.println("Input param is invalid");
return -1;
}
int maxIndex = arr.length - 1;
int minIndex = 0;
int midIndex = (maxIndex + minIndex) / 2;
while (minIndex <= maxIndex) {
/* 假如查詢的數據時大於中間數據的，那麼也就是說，查詢的數據在中間數據右側 修改最小值下標 */
if (arr[midIndex] < find) {
minIndex = midIndex + 1;
/* 假如查詢的數據是小於中間數據，證實當前查詢的數據在中間數據的左側 修改最大值下標 */
} else if (arr[midIndex] > find) {
maxIndex = midIndex - 1;
} else {
return midIndex;
}
midIndex = (maxIndex + minIndex) / 2;
}
return -1;
}
}
複製代碼
相關文章
- 1. 算法基礎-數組
- 2. java基礎Day 06 ：數組算法
- 3. 基礎算法——數組
- 4. Java語言基礎方法和數組
- 5. 09.Java數據算法
- 6. 數據結構和算法基礎-java
- 7. Java基礎數據結構和算法
- 8. 基礎算法題——異或和之和（位運算、組合數）
- 9. java算法：算法基礎
- 10. Java基礎——數組
- 更多相關文章...
- • R 基礎運算 - R 語言教程
- • Scala 基礎語法 - Scala教程
- • ☆基於Java Instrument的Agent實現
- • Kotlin學習（一）基本語法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 算法基礎-數組
- 2. java基礎Day 06 ：數組算法
- 3. 基礎算法——數組
- 4. Java語言基礎方法和數組
- 5. 09.Java數據算法
- 6. 數據結構和算法基礎-java
- 7. Java基礎數據結構和算法
- 8. 基礎算法題——異或和之和（位運算、組合數）
- 9. java算法：算法基礎
- 10. Java基礎——數組