排序算法

排序算法整理

最近去鹅肠面试，被排序算法难住了，准备突击一下

1. Bubble Sort

难度 1

冒泡排序，从第一个开始和后面元素比较如果有较小的就交换元素，然后第2个元素和后面元素开始交换。。。直到最后一个元素。 时间复杂度 O(n2)

public Integer[] sort(Integer[] arr) {
        int len = arr.length;
        for (int i = 0; i < len; i++) {
            for (int j = i + 1; j < len; j++) {
                if (arr[i] > arr[j]){
                    swap(arr,i,j);
                }
            }
        }
        return new Integer[0];
    }

2. Insert Sort

难度2

插入排序，将待排序数组从第一个元素开始看成一个有序数组，然后第二个元素和第一个元素比较，之后第一个元素和第二个元素便是一个有序数组，拿第三个元素再和前两个元素比较排序直到最后一个元素。时间复杂度O(n2)

 public Integer[] sort(Integer[] arr) {
        int in, out;
        for (out = 1; out < arr.length; out++) {

            int temp = arr[out];
            in = out;
            while (in > 0 && arr[in - 1] >= temp) {
                arr[in] = arr[in - 1];
                --in;
            }
            arr[in] = temp;
        }
        return arr;
    }

3. Select Sort

难度1

选择排序，选择一个最小和第一个比较交换，再次选择一个最小值和第二个元素比较交换，直到最后一个元素。时间复杂度O(n2)

 int min;
        for (int i = 0; i < arr.length; i++) {
            min = i;
            for (int j = i; j < arr.length; j++) {
                if (arr[min] > arr[j]){
                    min = j;
                }
            }
            swap(arr,min,i);
        }
        return arr;

4. Merge Sort

难度3

归并排序，先将数组切割，然后进行合并排序。时间复杂度O(n*logn)

   public Integer[] sort(Integer[] arr) {

        Integer[] newArr = new Integer[arr.length];
        recMergeSort(newArr, 0, arr.length - 1, arr);
        return newArr;
    }

    private Integer[] recMergeSort(Integer[] newArr, int min, int max, Integer[] arr) {

        if (min == max)
            return newArr;
        else {
            int mid = (min + max) / 2;
            recMergeSort(newArr, min, mid, arr);
            recMergeSort(newArr, mid +1, max, arr);
            merge(newArr, min, mid + 1, max, arr);
        }
        return newArr;
    }

    private void merge(Integer[] newArr, int min, int i, int max, Integer[] arr) {
        int j = 0;
        int minV = min;
        int mid = i - 1;
        int n = max - minV + 1;
        while (min <= mid && i <= max) {
            if (arr[min] < arr[i]) {
                newArr[j++] = arr[min++];

            } else {
                newArr[j++] = arr[i++];
            }
        }

        while (min <= mid) {
            newArr[j++] = arr[min++];
        }
        while (i <= max) {
            newArr[j++] = arr[i++];
        }
        for (j = 0; j < n; j++) {
            arr[minV + j] = newArr[j];
        }
    }

5. Shell Sort

希尔排序，基于插入排序，相当于插入排序的优化，通过位移来减少插入次数

 public Integer[] sort(Integer[] arr) {
        int in, out;
        for (out = 1; out < arr.length; out++) {

            int temp = arr[out];
            in = out;
            while (in > 0 && arr[in - 1] >= temp) {
                arr[in] = arr[in - 1];
                --in;
            }
            arr[in] = temp;
        }

        return arr;
    }

6. Quick Sort

快排，基于划分算法找出一个标量，将比标量小的元素放在左边，大的元素放在右边。时间复杂度Nlog(n)

   public Integer[] sort(Integer[] arr) {
        recQuickSort(0, arr.length - 1, arr);
        return arr;
    }
	// 递归至最后一个元素排序
    private void recQuickSort(int left, int right, Integer[] arr) {
        if (right - left <= 0)
            return;
        else {
            int p = position(left, right, arr[right], arr);
            recQuickSort(left, p - 1, arr);
            recQuickSort(p + 1, right, arr);
        }
    }
    // 根据 pivot划分数组
    private int position(int left, int right, int pivot, Integer[] arr) {
        int leftPtr = left - 1;
        int rightPtr = right;
        while (true) {
            while (arr[++leftPtr] < pivot)
            ；
            while (rightPtr > 0 && arr[--rightPtr] > pivot) 
            ；
            if (leftPtr >= rightPtr) {
                break;
            } else {
                swap(arr, leftPtr, rightPtr);
            }
        }
        swap(arr, leftPtr, right);
        return leftPtr;
    }

7. 基数排序

待定

8. 堆排序

待定

​