• 冒泡排序

不多说就是两趟循环，第一趟从头到尾，第二趟从尾到i找到最大或者最小放到i处完成内部一次循环

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

• 插入排序

插入排序认为我之前都是拍好的顺序，只要插入到之前拍好的序列中即可。

    public void insertSort(int[] a) {
        for (int i = 1; i < a.length; i++) {
            if (a[i] < a[i - 1]) {
                //记录需要插入的值
                int index = i - 1;
                int temp = a[i];
                //遍历之前已经拍好的序列，后移比temp大的值，为该值留出空间。
                while (index >= 0 && temp < a[index]) {
                    a[index + 1] = a[index];
                    index--;
                }
                a[index + 1] = temp;
            }
        }

    }

• 快速排序
  主要是那个partition函数，一次快速排序都是在该函数中进行的，作用是把比该数大的放在该数后面，比该数小的数放在该数后面，并返回该数的最后位置。

    public void quickSort(int[] arr, int low, int high){
        if(low<high){
            int index = partition(arr, low, high);
            quickSort(arr, low, index-1);
            quickSort(arr, index+1, high);
        }
    }

    public int  partition(int[] arr, int x, int y){
        int temp = arr[x];
        while(x<y){
            while(x<y && temp<arr[y]){
                y--;
            }
            change(arr,x,y);
            while(x<y && temp>arr[x]){
                x++;
            }
            //交换两个数
            change(arr,x,y);
        }
        return x;
    }
    public void change(int[] arr, int i, int j ){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

• 堆排序
  在堆排序中，是利用一个数组来存放一个堆的。如果是按照数组从0开始排序，则对于序号为i的节点，其左节点序号为i*2+1，右节点的序号为i*2+2，对堆的操作就是利用该规则。
  其中主要函数为heapAdjust：其作用是，左右子树都是大顶堆或者小顶堆，顶部为需要调整的节点，调整该节点。利用while循环从头向下调整。

堆排序有两步
1. 建堆过程
从最后一个非叶子节点开始利用 heapAdjust函数进行排序。
2. 排序过程
把建立好的堆，将第一个与堆最后一个替换，缩小堆，利用heapAdjust调整堆，最后得到拍好序的数组。

    public void heapSort(int[] arr){
        buildHeap(arr);
        for(int i =  arr.length-1;i>0;i--){
            change(arr,0,i);
            heapAdjust(arr,0,i);
        }
    }

    public void buildHeap(int[] arr){
        int index = arr.length/2;
        for(int i = index;i>=0;i--){
            heapAdjust(arr, i, arr.length);
        }
    }

    public void heapAdjust(int[] arr, int index, int length){
        int large = 0;
        while((index*2+1) < length){
            if(arr[index] > arr[2*index+2] && arr[index]> arr[index*2+1]){
                break;
            }
            large = arr[index] < arr[index*2+1] ? (index*2+1) : index;
            //判断是否存在右子树
            if(index*2+2 < length)
                large = arr[large] < arr[index*2+2] ? (index*2+2):large;
            change(arr,index,large);
            index = large;
        }
    }

    public void change(int[] arr, int i, int j ){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }