数组
数组是一种线性数据结构，是再内存中是顺序存储的（即数组中每个元素存储地址相邻），我们可以根据第一个元素的地址通过和数组中其他元素的地址偏移（相对位置）的加法运算确定具体的存储地址，从而达到快速存取的目的。
java中如何定义数组
Java中有三种定义方式：
方法一
先声明，然后分配空间，最后再赋值
public class arr{
public static void main(String[] args){
int[] arr; //先声明
arr=new int[5]; //分配空间
for(int i=0;i<5;i++)arr[i]=i*10; //赋值
}
}方法二
声明并分配空间，然后赋值
public class arr{
public static void main(String[] args){
int[] arr=new int[5]; //声明并分配空间
for(int i=0;i<5;i++)arr[i]=i*10; //赋值
}
}方法三
声明并分配空间同时赋值
public class arr{
public static void main(String[] args){
int[] arr={20,68,34,22,34}; //声明并分配空间同时赋值 等同于 int[] arr= new []{20,68,34,22,34};
}
}注：二维数组同理，可以看成是一维数组中的每个元素又是一维数组。
排序
将数据按照特定的顺序排列，目的就是为了方便查找！！！
目前：优秀的排序有很多
现在先介绍冒泡排序 ，插入排序， 选择排序
冒泡排序
比较相邻的元素，如果前一个比后一个大，交换之。
第一趟排序第1个和第2个一对，比较与交换，随后第2个和第3个一对比较交换，这样直到倒数第2个和最后1个，将最大的数移动到最后一位。
第二趟将第二大的数移动至倒数第二位
…
因此需要n-1趟；
public class BubbleSortMain {
public static void main(String[] args) {
}
private static void bubbleSort(int[] arr) {
if(arr==null || arr.length < 2 ){
return;
}
for (int i = 0; i < arr.length - 1; i++) {//n-1趟
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;
}
}
}
}
}插入排序
插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法 。插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。
Insertion sort
public class InsertionSort{
public static void main(String[] args) {
}
private static void insertionSort(int[] arr) {
int temp;
for (int i=1;i<arr.length;i++){
//待排元素小于有序序列的最后一个元素时，向前插入
if (arr[i]<arr[i-1]){
temp = arr[i];
for (int j=i;j>=0;j--){
if (j>0 && arr[j-1]>temp) {
arr[j]=arr[j-1];
}else {
arr[j]=temp;
break;
}
}
}
}
}
}选择排序
选择排序是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。
public class SelectionSort {
public int[] selectionSort (int[] sourceArray) {
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
// 总共要经过 N-1 轮比较
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
// 每轮需要比较的次数 N-i
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
// 记录目前能找到的最小值元素的下标
min = j;
}
}
// 将找到的最小值和i位置所在的值进行交换
if (i != min) {
int tmp = arr[i];
arr[i] = arr[min];
arr[min] = tmp;
}
}
return arr;
}
}查找
目前所有的查找算法，都是依赖于有序数组，在这只介绍折半查找（二分查找）。
折半查找（二分查找）
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
public class Test {
public static void main(String[] args) {
int[] arr = new int[] {-100,1,10,12,24,32,55,60,88};
System.out.println(binarySearch(arr,88));
}
public static int binarySearch(int[] arr, int key) {
int start = 0;
int end = arr.length - 1;
while (start <= end) {
int middle = (start + end) / 2;
if (key > arr[middle]) {
start = middle+1;
} else if(key < arr[middle]) {
end = middle-1;
} else {
return middle;
}
}
return -1;
}
}
