排序、ArrrayList集合

数组的排序：一般都是升序排列

两种排序方式：

　　--选择排序：数组的每个元素都进行比较。

　　--冒泡排序：数组中相邻元素进行比较。

选择排序

 1     public static void selectSort(int[] arr){
 2         for(int i = 0; i < arr.length-1; i++){
 3             for(int j = i+1; j < arr.length; j++){
 4                 if(arr[i] > arr[j]){
 5                     int temp = arr[i];
 6                     arr[i] = arr[j];
 7                     arr[j] = temp;
 8                 }
 9             }
10         }
11     }

冒泡排序

 1     public static void bubbleSort(int[] arr){
 2         for(int i = 0; i < arr.length; i++){
 3             for(int j = 0; j < arr.length-i-1; j++){
 4                 if(arr[j] > arr[j+1]){
 5                     int temp = arr[j];
 6                     arr[j] = arr[j+1];
 7                     arr[j+1] = temp;
 8                 }
 9             }
10         }
11     }

折半查找

实现步骤：

　　1：需要的变量定义三个，三个指针

　　2：进行循环折半，可以折半的条件 min <= max

　　3：让被找元素和中间索引元素进行比较

　　　　元素 > 中间索引小指针 = 中间 +1

　　　　元素 < 中间索引大指针 = 中间 -1

　　　　元素 == 中间索引找到，结束，返回中间索引

　　4：循环结束，无法折半

　　　　元素没找到，返回-1

 1     public static int binarySort(int[] arr,int key){
 2         int min = 0;
 3         int max = arr.length -1;
 4         int mid = 0;
 5         while(min <= max){
 6             mid = (min+max)/2;
 7             if(key < arr[mid]){
 8                 max = mid - 1;
 9             }else if(key > arr[mid]){
10                 min = min + 1;
11             }else {
12                 return mid;
13             }
14         }
15         return -1;
16     }

ArrayList集合

　　--内部封装了一个长度可变的数组，当存入的元素超过数组长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素。

创建：

　　--ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>（），注意：存储的数据类型必须是引用数据类型。