数组中的常见算法

数组中的常见算法

一 . 二分法查找算法

二分查找法，是一种有序的查找方法，查找的数组必须是有序的。基本思想是：目标值通过与中间元素比较，可分为三种情况：
第一种情况：目标值与中间元素相等，查找结束；
第二种情况：目标值比中间元素大，则把后半部分的中间元素与目标值比较；
第二种情况：目标值比中间元素小，则把前半部分的中间元素与目标值比较；
这三步一直循环，直到查找结束。

java代码的实现：

int[] arr3 = new int[]{-99,-54,-2,0,2,33,43,256,999};
boolean isFlag = true; 
int number = 256; 
//int number = 25; 
int head = 0;//首索引位置 
int end = arr3.length - 1;//尾索引位置 
while(head <= end){ 
    int middle = (head + end) / 2; 
    if(arr3[middle] == number){ 
        System.out.println("找到指定的元素，索引为：" + middle); 
        isFlag = false; break; }else if(arr3[middle] > number){ 
        end = middle - 1; 
    }else{//arr3[middle] < number 
        head = middle + 1; 
    } 
} 
if(isFlag){
     System.out.println("未找打指定的元素"); 
 }

二 . 排序算法

1 . 冒泡排序

介绍： 冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

排序思想：

1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步 做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要 比较为止。

public static void main(String[] args) {
    int[] data = { 3, 1, 6, 2, 5 };
    for (int i = data.length - 1; i > 0; i--) {
     for (int j = 0; j < i; j++) {
       if (data[j] > data[j + 1]) {
         int temp = data[j];
         data[j] = data[j + 1];
         data[j + 1] = temp;
       }
     }
    }
    for (int i = 0; i < data.length; i++) {
     System.out.println(data[i]);
    }
  }

2 . 快速排序

介绍： 快速排序通常明显比同为O(nlogn)的其他算法更快，因此常被采用，而且快 排采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可 见掌握快排的重要性。
快速排序（Quick Sort）由图灵奖获得者Tony Hoare发明，被列为20世纪十 大算法之一，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升 级版，交换排序的一种。快速排序的时间复杂度为O(nlog(n))。

排序思想：

1. 从数列中挑出一个元素，称为"基准"（pivot），
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准 值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后， 该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数 列排序。
4. 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好 了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代 （iteration）中，它至少会把一个元素摆到它最后的位置去。

public static void sort(int[] array, int left, int right) {
    if(left > right) {
        return;
    }
    // base中存放基准数
    int base = array[left];
    int i = left, j = right;
    while(i != j) {
        // 顺序很重要，先从右边开始往左找，直到找到比base值小的数
        while(array[j] >= base && i < j) {
            j--;
        }

        // 再从左往右边找，直到找到比base值大的数
        while(array[i] <= base && i < j) {
            i++;
        }

        // 上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
        if(i < j) {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
        }
    }

    // 将基准数放到中间的位置（基准数归位）
    array[left] = array[i];
    array[i] = base;

    // 递归，继续向基准的左右两边执行和上面同样的操作
    // i的索引处为上面已确定好的基准值的位置，无需再处理
    sort(array, left, i - 1);
    sort(array, i + 1, right);
}

3 . 选择排序

选择排序是一种简单直观的排序算法，工作原理为：在未排序的序列中找出最小(大)元素与第一个位置的元素交换位置
注意选择排序与冒泡排序的区别：冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。
然后在剩下的元素中再找最小(大)元素与第二个元素的位置交换，依此类推，直到所有元素排序排序完成。根据上述描述，一共进行n-1趟比较后，就能完成整个排队过程。我们可以知道，第k趟比较需要进行的数组元素的两两比较的次数为n-k次，所以共需要的比较次数为n*(n-1) / 2，因此选择排序算法的时间复杂度与冒泡排序一样，也为O(n^2)。

算法简介：

1. 初始状态：序列为无序状态。
2. 第1次排序：从n个元素中找出最小(大)元素与第1个记录交换
3. 第2次排序：从n-1个元素中找出最小(大)元素与第2个记录交换
4. 第i次排序：从n-i+1个元素中找出最小(大)元素与第i个记录交换
5. 以此类推直到排序完成

public static void main(String[] args) {
    int[] data = { 3, 1, 6, 2, 5 };
    for (int i = 0; i < data.length; i++) {
     int min = i;
     for (int j = i + 1; j < data.length; j++) {
       if (data[j] < data[min]) {
         min = j;
       }
     }
     // 进行位置的交换
     if (min != i) {
       int temp = data[i];
       data[i] = data[min];
       data[min] = temp;
     }
    }
    for (int i = 0; i < data.length; i++) {
     System.out.println(data[i]);
    }
  }

4 . 插入排序

插入排序是一种简单直观的排序算法，工作原理为构建有序序列，对于未排序元素，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间，直到排序完成，如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。理解了插入排序的思想后，我们便能够得到它的时间复杂度。对于n个元素，一共需要进行n-1轮比较，而第k轮比较需要进行k次数组元素的两两比较，因此共需要进行的比较次数为：1 + 2 + … + (n-1)，所以插入排序的时间复杂度同冒泡排序一样，也为O(n^2)。

算法简介：

1. 从第一个元素开始，该元素可认为已排序。
2. 取出下一个元素，在排序好的元素序列中从后往前扫描
3. 如果元素(已排序)大于新元素，将该元素移到下一位置
4. 重复3.直到找到已排序的元素小于或等于新元素的位置
5. 将新元素插入该位置后
6. 重复2-5直到排序完成

public static void insertSort(int[] a) {
        for (int i = 0; i < a.length-1; i++) {
            for (int j = i+1; j > 0; j--) {
                if (a[j] < a[j - 1]) {
                    int temp = a[j - 1];
                    a[j - 1] = a[j];
                    a[j] = temp;
                }else break;
            }
        }
    }