排序&&单链表反转

//insertsort
void InsertSort(int a[],int n){
    int j;
    for(int i = 2;i <= n;i ++){
        if(a[i] < a[i-1]){
            a[0] = a[i];
            for(j = i - 1;a[j] > a[0];j--){
                if(a[j+1] < a[j]){
                    a[j+1] = a[j];
                }
            }
            a[j+1] = a[0];
        }
    }
}
//下届
void lowerBound(int *a, int left, int right, int v){
    int mid;
    while(left < right){
        mid = (left + right) / 2;
        if(v <= a[mid]) right = mid;
        else left = mid + 1;
    }
    return left;
}

//上界
void upperBound(int *a, int left, int right, int v){
    int mid;
    while(left < right){
        
        mid = (left + right) / 2;
        if(v >= a[mid]) left = mid + 1;
        else right = mid;
    }
}



void BubbleSort(int a[], int n){
    for(int i = 0;i < n -1 ;i ++){
        for(int j = n-1;j > ilj--){
            if(a[j] < a[j-1]){
                swap(a[j],a[j-1]);
                flag = true;
            }
        }
        if(!flag) break;
    }
}



int Partition(int a[], int low, int high){
    int pivot = a[low];
    while(low < high){
        
        while(low < high && a[high] <= pivot) high --;
        a[low] = a[high];
        while(low < high && a[low] >= pivot) low ++;
        a[high] = a[low];
    }
    a[low] = pivot;
    return low;
}


void QuickSort(int a[], int low, int high){
    int position = Partition(a,low,high);
    QuickSort(a,low,position-1);
    QuickSort(a,position+1,high)
}



void SelectSort(int a[], int n){
    for(int i = 0;i < n-1;i++){
        min = i;
        for(int j = i+1;j < n;j++){
            if(a[j] < a[min]){
                min = j;
            }
        }
        if(min != i) swap(a[i],a[min]);
    }
}

int b[Max];
void Merge(int *a, int low, int mid, int high){
    for(int i = low, i <= high;i ++)
        b[i] = a[i];
    int k = low, r = mid+1;
    while(k <= mid && r <= high){
        if(b[k] < b[r]){
            a[k] = b[k++];
        }
        else{
            a[k++] = b[r++];
        }
    }
    while( k <= mid) a[k] = b[k++];
    while( r <= high) a[k++] = b[r++];
}

void MergeSort(int *a, int low,int high){
    if(low < high){
        int mid = (low + high) / 2;
        MergeSort(a,low,mid);
        MergeSort(a,mid+1,high);
        Merge(a,low,mid,high)
    }
}


void BuildMaxHeap(int a[], int len){
    for(int i = len/2;i > 0;i --)
        AjustDown(a,i,len);
}

void AjustDown(int a[], int k, int len){
    a[0] = a[k];
    
    for(int i = 2 * k;i <= len;i *= 2){
        if(i < len && a[i] < a[i+1]) i ++;
        if(a[0] > a[i]) break;
        else{
            a[k] = a[i];
            k = i;
        }
    }
    a[k] = a[0];
}

void HeapSort(int a[], int len){
    BuildMapHeap(a,len);
    for(int i = len ;i > 0;i--){
        swap(a[i],a[1]);
        AjustDown(a,1,i-1);
    }
}

ListNode* ReverseList(ListNode *head){
    ListNode *pNode = head;
    ListNode *pPrev = NULL;
    
    while(pNode != NULL){
        ListNode *pNext = pNode->next;
        pNode->next = pPrev;
        pPrev = pNode;
        pNode = pNext;
    }
    return pPrev;
}