常见排序和查找算法的实现

• 冒泡排序的实现

  冒泡排序的原理是依次比较两个相邻的数，小的放在前面，大的放在后面。

  每一趟比较，会把最大的数放到最后面，然后排除，继续比较其他的数。

  对于一个 长度为length的数组：

  1.总共需要比较length-1趟 (例如数组{1,2,3}需要比较两趟，第一趟排除3，第二趟排除2)。

  2.每一趟比较的次数为length - 1 - 当前趟数 i，因为每一趟会排除一个最大值，下次就不需要比较。

void sort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length - 1 - i; j++) {
            if (array[j] > array[j + 1]) {

                //数值互换
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

• 选择排序的实现

  把第一个元素和后面所有的元素进行比较，一趟结束，最小的值出现在第一个，然后继续比较其他的数。

  对于一个 长度为length的数组：

  1.总共需要比较length-1趟 (例如数组{1,2,3}需要比较两趟，第一趟排除1，第二趟排除2)。

  2.根据每一趟可以得到当前最小值所在位置n，然后依次和(n+1)至(length-1)比较

void sort(int[] array) {
    for (int x = 0; x < array.length - 1; x++) {
        for (int y = x + 1; y < array.length; y++) {
            if(array[x]>array[y]){

                //数值互换
                int temp = array[x];
                array[x] = array[y];
                array[y] = temp;
            }
        }
    }
}

• 插入排序的实现

  第一次比较前两个数，小的放在前面，大的在后面，然后得到一个2个数有序列，然后把后面的一个数与该

  数列比较，插入合适的位置，得到三个数的有序列，依次循环至最后一个数，就保证有序了。

  1.总共需要比较length-1趟 (例如数组{1,2,3}比较两趟，第一趟得有序列{1,2}，第二趟得到有序列{1,2,3})。

  2.每次把后面一个数和前面的序列每一个数比较，小于就移动，大于就停下。

void sort(int[] array) {
    for (int x = 1; x < array.length; x++) {
        for (int y = x; (y > 0) && (array[y] < array[y - 1]); y--) {
            int temp = array[y];
            array[y] = array[y - 1];
            array[y - 1] = temp;
        }
    }
}

• 二分查找的实现（有序数组）

  每次都和中间的元素比较，比较后可以减少一半的元素。

  1.定义最大最小索引，计算出中间值的索引。

  2.把查找值与中间值比较，大于则在右边找，小于在左边。

  3.重新调整索引，然后计算比较，最后找到查找值相等的位置。

void int search(int[] array, int value) {
    int max = array.length - 1;
    int min = 0;
    int mid = (max + min) / 2;

    while (value != array[mid]) {
        if (value > array[mid]) {
            min = mid + 1;
        }

        if (value < array[mid]) {
            max = mid - 1;
        }

        //元素不存在判断
        if (min > max) {
            return -1;
        }
        mid = (max + min) / 2;
    }
    return mid;
}