排序、查找

排序

冒泡排序

1. 第一次排序：从第一个数开始，与第二个数比较，如果大于第二个数则调换这两个数的位置。然后第二个数和第三个数比较，如果大于第二个数则调换这两个数的位置。依此类推，一直比较到最后一个数。第一次排序下来会将该数组最大的值排到最后。
2. 第二次排序，从第一个数开始，与第二个数比较，如果大于第二个数则调换这两个数的位置。然后第二个数和第三个数比较，如果大于第二个数则调换这两个数的位置。依此类推，一直比较到最后第二个数。第二次排序下来会将该数组第二个大的数排到倒数第二位。
3. 依此类推，排序成功。

java实现代码

class BubbleSort {
    public static void sort(int[] data) {
        for (int i = 0; i < data.length - 1; i++) {
            for (int j = 0; j < data.length - 1 - i; j++) {
                if (data[j] > data[j + 1]) {
                    int tmp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = tmp;
                }
            }
        }
    }
}

选择排序

1. 第一次排序：从第一个数开始，与第二个数比较，如果大于第二个数则调换这两个数的位置。然后第一个数再和第三个数比较，如果大于第三个数则调换这两个数的位置。依此类推，一直比较到最后一个数。第一次排序下来会将该数组最小的值排到第一个。
2. 第二次排序：从第二个数开始，与第三个数比较，如果大于第三个数则调换这两个数的位置。然后第二个数再和第四个数比较，如果大于第四个数则调换这两个数的位置。依此类推，一直比较到最后一个数。第二次排序下来会将该数组第二个小的数排到第二个。
3. 依此类推，排序成功。

class SelectionSort {
    public static void sort(int[] data) {
        for (int x = 0; x < data.length - 1; x++) {
            for (int y = x + 1; y < data.length; y++) {
                if (data[y] < data[x]) {                    
                    int tmp = data[y];
                    data[y] = data[x];
                    data[x] = tmp;
                }
            }
        }
    }
}

插入排序

1. 第一次排序：拿第二个数和第一个数比较，如果第二个数小于第一个数则调换这两个数的位置。第一次排序下来会使得该数组第一个和第二个索引有序。
2. 第二次排序，拿第三个数和第二个数比较，如果第三个数小于第二个数会继续和第一个数比较，如果大于第一个数就插入到第一个数后面。（无序的第一个数和有序的数从最后一个往前依次比较，找到合适的位置就插入。）第二次排序下来会使得该数组第一个、第二个索引和第三个索引有序。
3. 依此类推，排序成功。

class InsertSort {
    public static void sort(int[] data) {
        for (int i = 1; i < data.length; i++) {
            for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
                int tmp = data[j];
                data[j] = data[j-1];
                data[j-1] = tmp;    
            }
        }
    }
}

快速排序

1. 第一次排序：第一个数依次和最后一个数向前比较（第一个数先和最后一个数比较），遇到的第一个比第一个数小的数（位置记为x），就把第x个数和第一个数位置调换。然后将第x个数从第二个数依次向后比较，遇到的第一个比第x个数大的数，就将这两个数的位置进行调换。依此类推，直到比较的数和被比较的数为同一个，第一次排序完成。第一次排序使得第一个数找到了自己的位置，并将数组划分为两组。
2. 第二次排序：以第一次排序的结果中的第一组作为一个数组。按照第一次排序的方式进行排序。
3. 依此类推，排序成功。

class QuickSort {
    public static void sort(int[] data) {
        quickSort(data, 0, data.length - 1);
    }

    public static void swap(int[] arr, int b, int c) {
        int tmp = arr[b];
        arr[b] = arr[c];
        arr[c] = tmp;

    }

    private static void quickSort(int[] data, int i, int j) {
        int pivotIndex = (i + j) / 2;

        swap(data, pivotIndex, j);

        int k = partition(data, i - 1, j, data[j]);
        swap(data, k, j);

        if ((k - i) > 1)
            quickSort(data, i, k - 1);
        if ((j - k) > 1)
            quickSort(data, k + 1, j);

    }

    private static int partition(int[] data, int l, int r, int pivot) {
        do {
            while (data[++l] < pivot)
                ;
            while ((r != 0) && data[--r] > pivot)
                ;
            swap(data, l, r);
        } while (l < r);
        swap(data, l, r);
        return l;
    }
}

归并排序

1. 将数组一半分割，分割出来的部分再一半分割，知道分割出来的部分只有两个元素。
2. 比较每个部分的两个元素的大小，并排序。
3. 开始合并，第一个部分和第二个部分合并并且元素之间排序。第三个部分和第四个部分合并并且元素之间排序。依此类推。
4. 继续合并，按照第三部的规则。依此类推，排序成功。

class MergeSort {
    public static void sort(int[] data) {
        int[] temp = new int[data.length];
        mergeSort(data, temp, 0, data.length - 1);
    }

    private static void mergeSort(int[] data, int[] temp, int l, int r) {
        int mid = (l + r) / 2;
        if (l == r)
            return;
        mergeSort(data, temp, l, mid);
        mergeSort(data, temp, mid + 1, r);

        for (int i = l; i <= r; i++) {
            temp[i] = data[i];
        }
        int i1 = l;
        int i2 = mid + 1;
        for (int cur = l; cur <= r; cur++) {
            if (i1 == mid + 1)
                data[cur] = temp[i2++];
            else if (i2 > r)
                data[cur] = temp[i1++];
            else if (temp[i1] < temp[i2])
                data[cur] = temp[i1++];
            else
                data[cur] = temp[i2++];
        }
    }
}

希尔排序

算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

class ShellSort {
    public static void sort(int[] data) {
        for (int i = data.length / 2; i > 2; i /= 2) {
            for (int j = 0; j < i; j++) {
                insertSort(data, j, i);
            }
        }
        insertSort(data, 0, 1);
    }

    private static void insertSort(int[] data, int start, int inc) {
        for (int i = start + inc; i < data.length; i += inc) {
            for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {
                int tmp = data[j];
                data[j] = data[j - inc];
                data[j - inc] = tmp;
            }
        }
    }
}

基数排序

将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

查找

顺序查找

二分法查找

元素必须是有序的，如果是无序的则要先进行排序操作。