左神算法初级班第二节

随机快排

partition: 已知数组arr中的数num，现要求把小于等于num的数放左边，大于等于num的数放右面，要求额外时间复杂度O(N),额外空间复杂度O(1)
解法：在数组左侧和右侧分别划一个小于区域和一个大于区域，遍历数组，遇到小于num的数cur，就和小于区域相邻位置的数交换，小于区域扩一个位置，cur跳下一位，而遇到大于num的数，则交换完后cur保持原位，继续考察交换 过来的数与num的大小关系，cur走到大于区域，流程结束。

int *partition(int *arr, int l, int r, int num) {

    int less = l - 1;
    int more = r + 1;
    int temp = l;
    while (temp < more) {
        if (arr[temp] < num)
            swap(arr, ++less, temp++);
        else if (arr[temp] > num)
            swap(arr, --more, temp);
        else
            temp++;
    }
    int new[]={less+1,more};
    int *pt;
    pt=new;
    return pt;

随机快排
长期期望复杂度：O(N*logN) 额外空间复杂度：O(logN)

#include <stdio.h>
#include<stdlib.h>

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

int *partition_1(int*arr, int l,int r){
    int less=l-1;
    int more=r;
    while(l<more){
        if(arr[l]<arr[r])
            swap(arr,++less,l++);
        else if (arr[l]>arr[r])
            swap(arr,--more,l);
        else
            l++;
    }
    swap(arr,more,r);
    int res[]={less-1,more};
    int*pt;
    pt=res;
    return pt;
}


void quickSort(int *arr, int l,int r){
    if(l<r){
        swap(arr, l + (int)(rand()%(r-l)), r);//随机选取一个数放到最后
        int *p;
        p=partition_1(arr,l,r);
        quickSort(arr,l,p[0]-1);
        quickSort(arr,p[1]+1,r);

    }
}

堆排序

满二叉树： 所有非叶节点的叶节点都齐。
完全二叉树：满二叉树是完全二叉树，非满二叉树中的叶节点从左往右没
有空缺，也叫完全二叉树，堆就是完全二叉树。
堆结构： 完全二叉树就是堆结构。
大根堆： 堆的每一个父节点都大于其子节点
把一个数组抽象成一个堆结构：i位置的数，他的父位置在(i-1)/2,他的左 孩子在2i+1,他的右孩子在2i+2.
堆排序：

void heapInsert(int*arr, int index){
    while(arr[index]>arr[(index-1)/2]){
        swap(arr,index,(index-1)/2);//index与其父位置的数比较，比父位置大就交换
        index=(index-1)/2;//从index往上跑
    }
}

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

void heapSort(int *arr,int len){//len是数组长度
    for(int i=0;i<len;i++)
        heapInsert(arr,i);//将数组变为大根堆
    int heapSize= len;
    swap(arr,0,--heapSize);
    while(heapSize>0){
        heapify(arr,0,heapSize);//每次找到堆顶是最大值，放到最末
       
        swap(arr,0,--heapSize);
    }
}