数据结构-排序

冒泡排序

一次循环后将找到最大值放到后面，多次循环就可以将数组排序

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

            }
        }
    }

选择排序

首先定义了两个空间。初始化为数组的第一个元素。找到后面数组的最小值，取出数组的值和位置赋与给两个空间，在将第一个元素的值赋给数组最小值，将空间存储的最小值赋给第一个元素。以此类推

public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int index = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    min = arr[j];
                    index = j;
                }
            }
            arr[index] = arr[i];
            arr[i] = min;
        }
    }

插入排序

将数组分为两个部分，一个是排好序的，一个是待排序，将待排序部分每次取一个值放到有序部分排好序。

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

希尔排序

是将数组进行分组步长每次取上次步长的一半（第一次为数组长度的一半）排好序后，最后通过步长为1对数组进行排序。

 public static void ShellStap(int[] arr) {
        for(int gap=arr.length/2;gap>0;gap/=2) {
            for(int i=gap;i<arr.length;i++) {
                for(int j=i-gap;j>=0;j-=gap) {
                    if(arr[j]>arr[j+gap]) {
                        int temp=arr[j];
                        arr[j]=arr[j+gap];
                        arr[j+gap]=temp;
                    }
                }
            }
        }
    }

基数排序

桶是个二维数组，桶记录器是一维数组，首先通过定义一个桶和桶记录器，找到数组中的最大数，判断最大数的位数，通过for循环，先将数组的值赋给桶，桶会按照个位，十位，百位的顺序将数据传回给原数组，每次操作后都需要将桶记录器清空。

public static void sort(int[] arr) {
        int[][] buff = new int[10][arr.length];
        int[] element = new int[10];
        int max = arr[0];
        for (int h = 0; h < arr.length; h++) {
            if (arr[h] > max) {
                max = arr[h];
            }
        }
        int maxLength = (max + "").length();
        int n = 1;

        for (int z = 0; z < maxLength; z++) {
            for (int i = 0; i < arr.length; i++) {
                int ele = arr[i] / n % 10;
                int count = element[ele];
                buff[ele][count] = arr[i];
                element[ele] = element[ele] + 1;
            }
            int index = 0;
            for (int k = 0; k < element.length; k++) {
                if (element[k] != 0) {
                    for (int l = 0; l < element[k]; l++) {
                        arr[index] = buff[k][l];
                        index++;
                    }

                }
                element[k] = 0;

            }
            n = n * 10;
        }
    }

 堆排序

首先判断parent是否存在子节点，若不存在则直接跳过；存在则进行下一步操作。

将child指向左子树，看是否右子树存在，存在的话，比较左右子树的值，将值大的赋与child

将parent的值与child的值进行比较，若parent<child 此时将二则的值调换位置，并将parent指向child，同时child指向自己的左子树，继续第二步操作。

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr = new int[] { 23, 4, 56, 12, 6, 9 };
        for (int p = arr.length - 1; p >= 0; p--) {
            sort(arr, p);
        }
    }

    public static void sort(int[] arr, int parent) {
        int child = 2 * parent + 1;
        while (child < arr.length) {
            int rchild = child + 1;
            if (rchild < arr.length && arr[rchild] > arr[child]) {
                child++;
            }
            if (arr[parent] < arr[child]) {
                int temp = arr[parent];
                arr[parent] = arr[child];
                arr[child] = temp;
                parent = child;
                child = 2 * child + 1;
            } else {
                break;
            }
        }
    }