算法-排序算法-1

1. 选择排序 o n平方/o1

　　在剩余的数组中选取最小值与数组第一位替换

　　缺点是:无论是基本有序的数组还是乱序的数组,使用的时间是一致的

　　

 public void selectSort(int[] a){
        for (int i = 0; i < a.length; i++) {
            int min = i;
            for (int j = i+1; j < a.length; j++) {
                if (a[min]>a[j]){
                    swap(a,min,j);
                    min = j;
                }
            }
        }
    }

 public void swap(int[] a,int i,int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
 　}

void swap(int[] arr,int i,int j){
    int[i] = int[i] ^ int[j];
    int[j] = int[i] ^ int[j];
    int[i] = int[i]  ^ int[j];  
}

2. 插入排序(稳定性排序) o n平方/o1

每次都跟前面排好序的数组进行比较 后面小于前面就互换

比较适合基本有序的数组 大概比选择排序快1.7倍

public void insertion(int[] a){
    for(int i = 1;i<a.length;i++){
        for(int j = i;j>0&&a[j]<a[j-1];j--){
           swap(a,j,j-1);
        }
    }
}

3.希尔排序

希尔排序是插入排序的进化版,有点像最优子问题一样,先达到大概有序 最后进行一次插入排序

public void shell(int[] a){
  
  // 先确定一个步长h
  int h = a.length/2;

  // 等于1时就是进行一次插入排序 
  while(h>=1){
    for(int i = h;i<a.lenght;i++){
       for(int j = i;j >= h && a[j]<a[j-h];j-=h){
            swap(a,j,j-h);
        }
   }
    h/=2;
  }  
    
}        

 4.冒泡排序(稳定排序) o n平方/o1

　　每一轮都得出一个最大的数放最右边

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

 5. 归并排序(稳定排序) o n*logn/o n

　　遍历分成两个数组,两个数组双指针合并

public void process(int[] arr, int l, int r) {
        if (l == r) {
            return;
        }
        int mid = l + ((r - l) >> 1);
         process(arr,l,mid);
         process(arr,mid+1, r);
         merge(arr,l,mid,r);
    }

    public int merge(int[] arr, int l, int mid, int r) {
        int p1 = l;
        int p2 = mid + 1;
        int ret = 0;
        int i = 0;
        int[] help = new int[r - l + 1];
        while (p1 <= mid && p2 <= r) {
            // 这一步是计算经过几次调换
            ret += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
            // 小值移动到数组的左边
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        // 移动剩余值
        while (p1 <= mid) {
            help[i++] = arr[p1++];
        }
        while (p2 <= r) {
            help[i++] = arr[p2++];
        }
        // 用辅助内存替换原数组的值
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
        return ret;
    }

 6. 快速排序 o n*logn/o logn

　　选取一个数,大于这个数的放右边 小于这个数的放左边 等于这个数的放中间 没进行一次确定一批相同值的位置

public void sort(int[] arr, int l, int r) {
        if (l < r) {
            // 选出随机值
            AlUtils.swap(arr, (int) (l + Math.random() * (r - l + 1)), r);
            // 荷兰国旗一次
            int[] partition = partition(arr, l, r);
            // 左区间
            sort(arr, l, partition[0] - 1);
            // 右区间
            sort(arr, partition[1] + 1, r);
        }
    }

    public int[] partition(int[] arr, int l, int r) {
        int less = l - 1;
        int more = r;
        while (l < more) {
            if (arr[l] < arr[r]) {
                // 目标值是r位置的值
                // l位置的值小于目标值, l位置与less下一个值交换 l跳下一个
                AlUtils.swap(arr, l++, ++less);
            } else if (arr[l] > arr[r]) {
                // l位置的值大于目标值 l位置与more上一个值交换 l不变
                AlUtils.swap(arr, l, --more);
            } else {
                // l位置的值 与目标值一致不变 l跳下一个
                l++;
            }
        }
        // 目标值r位置换到中间位置 r位置的值确定了位置
        AlUtils.swap(arr, more, r);
        int[] result = {less + 1, more};
        return result;
    }

 7. 堆排序 o n*logn/o1

　　父 (i-1)/2

　　左 2*i+1

　　右 2*i +2

　　

 public void heapInsert(int[] arr, int index) {
        while (arr[index] > arr[(index - 1) / 2]) {
            AlUtils.swap(arr, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

    public void heapify(int[] arr, int index, int heapSize) {
        int left = index * 2 + 1;
        while (left < heapSize) {
            int largest = left + 1 < heapSize && arr[left] < arr[left + 1] ? left + 1 : left;
            largest = arr[index] < arr[largest] ? largest : index;
            if (largest == index) {
                break;
            }
            AlUtils.swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

    public void sort(int[] arr) {
        // 先建立大顶堆
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr, i);
        }
        // 第一个值与最后一个值替换 然后heapify
        int heapSize = arr.length;
        AlUtils.swap(arr, 0, --heapSize);
        // 再替换 知道heapsize小于0
        while (heapSize > 0) {
            heapify(arr, 0, heapSize);
            AlUtils.swap(arr, 0, --heapSize);
        }
    }

    public void disLessK(int[] arr,int k){
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        int index = 0;
        for (;index<=Math.min(arr.length,k);index++){
            heap.add(arr[index]);
        }
        int i = 0;
        for (;index<arr.length;i++,index++){
            heap.add(arr[index]);
            arr[i] = heap.poll();
        }
        while (!heap.isEmpty()){
            arr[i++] = heap.poll();
        }
    }

 8. 桶排序(不基于比较的排序)

统计排序: 创建相同长度的数组,每个数在对应的index+1 最后遍历有值的数组 放入数组

基数排序: 以10进制为例,创建10个桶(队列),个位数放入对应的队列取出,按十位放入对应队列取出,按百位放入对应的队列取出 取出放入数组 有序