一、動態數組
1、數組的定義：
用於存儲相同數據類型的一組連續的存儲空間
2、數組的特點：
數組的長度一旦定義，則不可改變
訪問數組的元素需要通過下標（索引）訪問，下標從0開始
數組是引用數據內存，內存分布在堆內存中，數組的變量存儲的內存地址
3、動態數組：
由於數組的長度定義后不能改變，所謂“動態數組”是可以增加數組的長度，所以Java實現動態數組是改變數組變量指向不同的內存地址。 本質並沒有將數組的長度改變。
動態數組的本質：將內存空間的改變，以及指向數組內存的地址改變
操作1：給數組添加新元素，可添加在最后面，也可添加到指定位置
/**
*添加元素（添加到末尾）
*/
public static int [] addEle(int [] array,int num){
//目標數組 添加的原始
//int [] array={10,9,3,2,1};
//1、創建臨時數組的變量
int [] tempArray =new int[array.length+1];
//2、將目標數組的元素copy到臨時數組的內存中
for(int i=0;i<array.length;i++){
tempArray[i]=array[i];
}
//3、將添加的元素放入臨時數組中
tempArray[tempArray.length-1]=num;
//4、將目標數組的地址指向臨時數組的地址
array=tempArray;//由於tempArray是局部變量，方法執行完內存自動回收，如果不返回 沒有地址指向tempArray的內存，如果返回並接收，說明這塊內存仍然有用。
return array;
}
/**
* 將元素num 添加到指定index的位置
* @param arr
* @param num
* @param index
* @return
*/
public static int [] addEle(int [] arr , int num ,int index){
// 1、創建臨時數組的大小
int [] tempArray = new int[arr.length+1];
//2、遍歷arr
for(int i = 0 ; i<=arr.length;i++){
// 如果i<index
if(i<index){
tempArray[i] = arr[i];
}else if(i==index){ // 2
tempArray[i] = num;
}else{ // i > index
// i=3 arr[i-1] 10 9 3 2 1 -> 10 9 5 3 0 0
// i =4 array[i-1] 2-> 10 9 5 3 2 0
// i=5 array[4] 1 -> 10 9 5 3 2 1
tempArray[i] = arr[i-1];
}
}
// 賦值
arr = tempArray;
return arr;
}
操作2： 刪除元素 ，刪除指定下標的元素
/**
* 刪除指定下標的元素
* @param arr 目標數組
* @param index 刪除的下標
* @return 刪除之后的數組
*/
public static int [] removeEle(int [] arr, int index){
// 1、創建一個臨時數組 用於存放刪除后的元素
int [] tempArray = new int [arr.length-1];
// 2、遍歷目標數組
for(int i = 0 ;i<arr.length;i++){
if(i<index){
tempArray[i] = arr[i];
}else if(i==index){
continue;
}else {//i>index
tempArray[i-1] = arr[i];
}
}
// 3 將目標數組的地址變換成 新數組的地址
arr=tempArray;
return arr;
}
二、數組的排序
排序：將一組數列（無序的）按照從小到大或者從大到小的順序排列。
1、冒泡排序
從第一個數開始，與它相鄰的數比較，較大（或較小）的數放在后面，最終比較一輪之后，得出最大（或最小）的數放在最后
比較思路：
冒泡排序的規則
* 1、從第一個數開始，將這個數 與它相鄰的數比較 ，如果 這個數大於它相鄰的數
* 則兩個數交換位置
* i=0 相鄰i=1
* 2、依次 從第二個數開始，再將這個數與它相鄰的數比較，如果第二個數大於相鄰的數
* 則繼續交換
* 依次類推， 到倒數第二個截止 ，直到將最大的數放在最后面
* 3、重復以上1,2步驟
/
public static void main(String[] args) {
int [] array = {5,4,3,2,1};
//用於交換的臨時變量
int temp=0;
for(int j =0;j<array.length-1;j++) {
for (int i = 0; i < array.length -j-1; i++) {
// 相鄰的數比較
if (array[i] > array[i + 1]) {
temp = array[i];
array[i] = array[i + 1];
array[i + 1] = temp;
}
}
System.out.println("比較一輪之后：" + Arrays.toString(array));
}
}
2、選擇排序
/**
* 選擇排序： 從一堆數中選擇一個最小數 放在第一個位置，再從一堆數中選擇一個
* 最小數放在第二個位置， 依次 將一堆數的最小數按順序排放。
* 步驟： 1、假設第一個數是最小數，需要定義最小數的下標minIndex=0
* 將這個數與后面的每一個數比較，找到最小數的下標即可
* 2、將第一個數與最小數的下標交換 ，得出最小數在第一位。
* 3、 依次類推， 將已比較的數 忽略，繼續從剩下的元素中找足最小數，放入已比較的數的下一位
* 直到整個數列比較結束
* @param args
*/
public static void main(String[] args) {
int [] array = {3,2,1,5,7,4};
for(int j=0;j<array.length-1;j++) {
// 假設第一個數是最小數
int minIndex = j;
// 為什么i =j+1 因為初始值要略過已比較的下標
for (int i = 1+j; i < array.length; i++) {
if (array[minIndex] > array[i]) {
minIndex = i;
}
}
// 將這個最小數放在 第一位
int temp = 0;
temp = array[j];
array[j] = array[minIndex];
array[minIndex] = temp;
System.out.println("----第一次完成后：" + Arrays.toString(array));
}
System.out.println("最后的排序："+Arrays.toString(array));
}
}
3、插入排序
/**
* 插入排序
* 1、從第一個元素開始，假設第一個元素是已排好序的
* 2、從下一個元素開始，依次比較它前面的所有元素（從后向前掃描）
* 3、 如果這個元素 小於它前面的元素 則兩兩交換 ，
* 如果這個元素 大於它前面的元素，則不交換
* 4、依次重復2,3步驟 ，直到將所有數 比較完成
* 5,4,3,2,1
*
* 4 5 3 2 1 i從1開始
*
* 4 3 5 2 1 i從2開始
* 3 4 5 2 1
*
* 3 4 2 5 1 i從3開始
* 3 2 4 5 1
* 2 3 4 5 1
*
* 2 3 4 1 5 i從4開始
* 2 3 1 4 5
* 2 1 3 4 5
* 1 2 3 4 5
* @param args
*/
public static void main(String[] args) {
int [] array = {5,4,3,2,1};
// 外層循環循環 每一個數的比較次數
for(int j=0;j<array.length-1;j++) {
int temp = 0;
for (int i = 1+j; i > 0; i--) {
if (array[i] < array[i - 1]) {
temp = array[i];
array[i] = array[i - 1];
array[i - 1] = temp;
}
}
System.out.println("每一次完成后的結果："+ Arrays.toString(array));
}
System.out.println("最后一次完成后的結果："+Arrays.toString(array));
}