数组简单操作排序、查找

选择排序：

选中一个数挨个与后续元素去比较若为升序排序，则arr[x1]>arr[x2] 则两者互换，接着使用当前(arr[x1])与后续元素比较.
array [7，6，9，4，8]
第一轮：7  6  9  4  8
第一次：7 去和 6 比较 互换， 6  7  9  4  8
第二次：6 去和 9 比较 不动， 6  7  9  4  8
第三次：6 去和 4 比较 互换， 4  7  9  6  8
第四次: 4 去和 8 比较 不动。 4  7  9  6  8 // 第一轮完成，4次比较
完成后得出第一个为最小值，4
第二轮：4 | 7  9  6  8
因为4 为最小值，则排除该元素，而后元素做上述流程比较。
第一次: 7 去和 9 比较 不动， 7  9  6  8
第二次：7 去和 6 比较 互换， 6  9  7  8
第三次：6 去和 8 比较 不动， 6  9  7  8
// 第二轮完成，3次比较
完成后得出第一个为最小值，6
第三轮：4  6 | 9  7  8
因为前两轮排序出 4 6 ，则排除其元素，而后元素做上述流程比较
第一次: 9 去和 7 比较 互换， 7  9  8
第二次：7 去和 8 比较 不动， 7  9  8
// 第三轮完成，2次比较
完成后得出第一个为最小值，7
第四轮：4  6  7 | 9  8
因为前三轮排序出 4 6 7，则排除其元素，而后元素做上述流程比较
第一次：9 去和 8 比较  互换， 8  9
// 第四轮完成，1次比较
完成后得出第一个为最小值，8
4  6  7  8  9
至此 最后一个数以无需做也无后续元素与此比较则排序完成。

总结：5个元素，做了 4+3+2+1次比较，(1+n-1)(n-1)/2 = (n^2 - n) / 2 次比较
完成需要4轮

形如： 
  *****
  ****
  ***
  **
  *

code:
int[] arr = {7，6，9，4，8};
for(int i = 0 ; i < arr.length - 1 ; i++) { // arr.length - 1 因为最后一个元素无需比较
for(int j = i+1 ; j< arr.length ; j++) { // j=x+1 是：前边的已经排好序，每次只用去和自身后续元素比较
if(arr[i] > arr[j]) { // 如果大于则去互换；升序排序。 降序则仅作此处改变 
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}

---

冒泡排序：

    原理：相邻元素之间做比较，每轮做完得出最大值。
array [7，6，9，4]
第一轮：
第一次：7 和 6 比较 互换 6 7 9，4 
第二次：7 和 9 不动 6 7 9 4
第三次：9 和 4 比较 互换 7 6 4 9 
7 6 4 | 9 
第二轮：
第一次：7 和 6 比较 互换 6 7 4
第二次：7 和 4 比较 互换 6 4 7
6 4 | 7 9
第三轮：
第一次：6 和 4 比较 互换 4 6 7 9

结论：
N个数比较 n-1 + n-2 .. 1 次  (1 + n - 1)(n-1)/2= ( n^2 - n ) / 2 次比较
完成形如
****
***
**
*
for(int i =0; i < arr.length - 1 ;i++) {

for(int j = 0; j < arr.length - i -1;j++) {
if(arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp; 
}
}
}

---
开发中Arrays.sort();

----查找：
线性查找：
原理：挨着遍历元素若相等则返回该元素角标，否则返回-1

二分查找：
前提必须是已经排好序的序列。返回值：若查询到则返回插入点即当前元素角标否则返回第一个大于当前元素数字的索引(加符号)
原理：分一半查找。
eg.
0  1   2    3   4    5    6
int[] i = { 1, 2, 23, 123, 125, 134, 12312 }; 
key : 123
定义最小值min起始位置0
定义最大值起始位置max arr.length - 1
比较的值位置 为 mid = (min+max) / 2
每次都拿中间这个数去和key比较，
若key 大于 value[mid] 则将mid +1 赋予给 min
若key 小于 value[mid] 则将mid -1 赋予给 max
若key = value[mid] 则返回mid

--若相等则直接返回
1.min = 0 ; max = arr.length - 1 = 6; mid = 3 
123 = arr[3] return min;

--查找 126
1.min = 0 ; max = arr.length - 1= 6; mid = (min+max)/2=3; 
2.126 > 123 则最小的min = mid +1 ; 125 134 12312
3.min = mid + 1 = 4 ；max = 6 (不变)；mid = (4+6)/2 =5
   4.126 < 134 则 最大位置max = mid -1 ;  min = 4  max=4  mid = 4
5.126 > 125 则              min max mid 
0  1   2    3       4                     5    6
int[] i = { 1, 2, 23, 123,     125,                 134, 12312 }; 

min 移到了 max 后 
max   min 
0  1   2    3       4      5    6
int[] i = { 1, 2, 23, 123,     125,   134, 12312 }; 
则此时则找不到。return min 即可。

代码：
int min = 0;
int max = arr.length - 1;
int mid = (min + max) / 2;
while (min <= max) {
if (key > arr[mid]) {
min = mid + 1;
} else if (key < arr[mid]) {
max = mid - 1;
} else {
return mid;
}
mid = (min + max) / 2;

}
return -(min) - 1;