sort

#include <stdio.h>
#include <string.h>

void quick_sort(int* arr,int left,int right){
    if(left>=right) return;
    
    int l=left,r=right,key=arr[left];
    while(l<r){
        while(l<r && key<=arr[r]) r--;
        arr[l]=arr[r];
        while(l<r && key>=arr[l]) l++;
        arr[r]=arr[l];
    }
    arr[l] =key;
    quick_sort(arr,left,l-1);
    quick_sort(arr,l+1,right);
}

void swap(int& a,int& b){
    int tmp=a;
    a=b;
    b=tmp;
}
void bubble_sort(int* arr,int nSize){
    for(int i=0;i<nSize-1;i++){
        bool bsort = true;
        for(int j=0;j<nSize-i-1;j++){
            if(arr[j+1]<arr[j]) {
               swap(arr[j+1],arr[j]); 
               bsort=false;
            }
        }
        if(bsort) break;
    }
}

void print(int* arr,int nSize){
    for(int i=0;i<nSize;i++){
        printf("%d ",arr[i]);
    }
}

void choose_sort(int* arr,int nSize){
    for(int i=0;i<nSize-1;i++){
        int pos = i;
        for(int j=i+1;j<nSize;j++){
            if(arr[pos]>arr[j]){
                pos=j;
            }
        }
        swap(arr[pos],arr[i]);
    }
}

void insert_sort(int* arr,int nSize){
    for(int i=1;i<nSize;i++){
        for(int j=i;j>=1;j--){
            if(arr[j]<arr[j-1]) swap(arr[j],arr[j-1]);
        }
    }
}

void merge_sort(int* arr,int left,int right){
    if(right-left<=0){
        return;
    }
    int lPos = left;
    int rPos = (right-left)/2 + left + 1;
    
    merge_sort(arr,left,rPos-1);
    merge_sort(arr,rPos,right);
    
    int* arrTmp = new int[right-left+1];
    int pos = 0;
    while(lPos <= (right-left)/2 +left && rPos <=right){
        if(arr[lPos] <= arr[rPos]){
            arrTmp[pos++]=arr[lPos++];
        }else{
            arrTmp[pos++]=arr[rPos++];
        }
    }
    while(lPos<=(right-left)/2+left){
        arrTmp[pos++]=arr[lPos++];
    }
    while(rPos<=right){
        arrTmp[pos++] = arr[rPos++];
    }
    memcpy(arr+left,arrTmp,pos*sizeof(int));
    delete[] arrTmp;
}

/// 堆排序

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

void heapify(int tree[], int n, int i){
    if (i >= n){
        return;
    }
    int c1 = 2 * i + 1;
    int c2 = 2 * i + 2;
    int max = i;
    if (c1 < n && tree[c1] > tree[max]){
        max = c1;
    }
    if (c2 < n && tree[c2] > tree[max]){
        max = c2;
    }

    if (max != i){
        swap(tree, max, i);
        heapify(tree, n, max);
    }
}

void build_heap(int tree[], int n){
    int last_node = n - 1;
    int parent = (last_node - 1) / 2;
    for (int i = parent; i >= 0; i--){
        heapify(tree, n, i);
    }
}

void heap_sort(int tree[], int n){
    build_heap(tree, n);
    for (int i = n - 1; i >= 0; i--){
        swap(tree, i, 0);
        heapify(tree, i, 0);
    }
}

int main() {
    int arr[] = {1,3,9,2,6,2,5};

//    quick_sort(arr,0,sizeof(arr)/sizeof(int)-1);
//    bubble_sort(arr,sizeof(arr)/sizeof(int));
//    choose_sort(arr,sizeof(arr)/sizeof(int));
//    insert_sort(arr,sizeof(arr)/sizeof(int));
    
    merge_sort(arr,0,sizeof(arr)/sizeof(int)-1);
    print(arr,sizeof(arr)/sizeof(int));
    return 0;
}