算法每天一练

快排

• 原理

取第一个元素作为参考值进行保存，比参考值大的放入右边，比参考值小的放入左边，依次类推，得到有序的数组

• 代码

package com.company;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
	// write your code here
        int[] arr = {3,5,1,5,2,6,8,9,0,-1,4,6,7,9,0,-6,4,2,2,4,5,1,7};
        quickSort(arr, 0, arr.length - 1);
        Arrays.stream(arr).forEach(v->System.out.println(v));
    }

    private static void quickSort(int[] arr, int min, int max) {
        if (max <= min) {
            return;
        }

        int num = arr[min];
        int left = min;
        int right = max;
        while (right > left) {
            for (int i=right; i>left&&right>left; i--) {
                if (arr[i] < num) {
                    arr[left ++] = arr[i];
                    break;
                }
                right --;
            }

            for (int i=left; i<right&&right>left; i++) {
                if (arr[i] > num) {
                    arr[right --] = arr[i];
                    break;
                }
                left ++;
            }
        }
        arr[left] = num;
        quickSort(arr, min, left - 1);
        quickSort(arr, left + 1, max);
    }
}

 堆排序

• 原理

先弄一个大堆（父节点比子节点都大）

讲第一个元素和最后一个元素互换，并且把数组看成去掉最后一个元素的新数组，对新数组进行大堆恢复，依次类推，成为有序数组

• 代码

package com.company;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
	// write your code here
        int[] arr = {3,5,1,5,2,6,8,9,0,-1,4,6,7,9,0,-6,4,2,2,4,5,1,7};
        heapSort(arr);
        Arrays.stream(arr).forEach(v->System.out.println(v));
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    private static void adjust(int[] arr, int index, int len) {
        int left = 2 * index + 1;
        int right = 2 * index + 2;
        int largest = index;
        if (left < len && arr[largest] < arr[left]) {
            largest = left;
        }

        if (right < len && arr[largest] < arr[right]) {
            largest = right;
        }

        swap(arr, index, largest);

        if (index != largest) {
            adjust(arr, largest, len);
        }
    }

    private static void maxHeap(int[] arr, int len) {
        int half = len / 2;
        for (int i=half; i>=0; i--) {
            adjust(arr, i, len);
        }
    }

    public static  void heapSort(int[] arr) {
        int len = arr.length;
        maxHeap(arr, len);

        for (int i=len-1; i>=0; i--) {
            swap(arr, i, 0);
            adjust(arr, 0, --len);
        }
    }
}

归并排序

• 原理

先将整个数组分成小数组，然后将这些小数组合并起来让它有序，从而得到最终的结果

• 代码

package com.company;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
	// write your code here
        int b[] = {12,23,435,4,7,4,23,1,3,4,5,6,7,8,9,0,4,3,5,6,7,8,9,0,5,3,4};
        mergeDown2Up(b, 0, b.length - 1);
        Arrays.stream(b).forEach(v -> System.out.println(v));
    }

    private static void mergeDown2Up(int[] b, int start, int end) {
        if (start >= end) {
            return;
        }

        int middle = (start + end) / 2;

        mergeDown2Up(b, start, middle);
        mergeDown2Up(b, middle+1, end);
        merge(b, start, middle, end);
    }

    private static void merge(int[] b, int start, int middle, int end) {
        int i = start;
        int j = middle + 1;
        int k = 0;
        int a[] = new  int[end - start + 1];

        while (i <= middle && j <= end) {
            if (b[i] < b[j]) {
                a[k++] = b[i++];
            } else {
                a[k++] = b[j++];
            }
        }

        while (i<=middle) {
            a[k++] = b[i++];
        }

        while (j <=end) {
            a[k++] = b[j++];
        }

        for (i = 0; i< k; i++) {
            b[start + i] = a[i];
        }
    }
}

桶排序

• 原理

如果数组的所有成员都小于max，则创建大小为max的数组，如果遍历整个数组，将对应索引的次数加1，最后再对数组进行重置

• 代码

package com.company;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
	// write your code here
        int[] array = {1,2,3,4,2,3,4,5,3,2,35,6,23,1,23,13,53,12,42,23};
        tongSort(array);
        Arrays.stream(array).forEach(v -> System.out.println(v));
    }

    public static void tongSort(int[] array) {
        int max = 100;
        int[] tong = new int[100];
        int len = array.length;
        for (int i=0; i<len; i++) {
            tong[array[i]] += 1;
        }

        int k=0;
        for (int i=0; i<100; i++) {
            len = tong[i];
            for (int j=0; j<len; j++) {
                array[k++] = i;
            }
        }
    }
}

基数排序

• 原理

选出最大的值，依次对个十百...进行排序

• 代码

package com.company;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
	// write your code here
        int[] array = {1,23,4,3,2,34,5,67,8,754,23,131};
        radixSort(array);
        Arrays.stream(array).forEach(v -> System.out.println(v));
    }

    private static void radixSort(int[] array) {
        int max = 0;
        int len = array.length;
        for (int i = 0; i< len; i++) {
            if (array[i]>max) {
                max = array[i];
            }
        }

        for (int exp=1; max/exp > 0; exp*=10) {
            countSort(array, exp);
        }
    }

    private static void countSort(int[] array, int exp) {
        int len = array.length;
        int[] output = new int[len];
        int[] bucket = new int[10];
        for(int i=0; i<len; i++) {
            bucket[array[i]/exp%10]++;
        }

        for (int i=1; i<10; i++) {
            bucket[i] += bucket[i-1];
        }

        for (int i=len-1; i>=0; i--) {
            output[bucket[array[i]/exp%10] - 1] = array[i];
            bucket[array[i]/exp%10]--;
        }

        for (int i=0; i<len; i++) {
            array[i] = output[i];
        }
    }
}