八大插入算法（有注释）

直接插入排序

//直接插入排序
void InsertSortingDirectly(int* nums,int numsSize){
    int j=0;
    for(int i=1;i<=numsSize-1;i++){
        //定义一个中间变量保存当前要插入的值
        int temp=nums[i];
        //在前面已排好序的序列中，找到合适的位置插入
        for(j=i-1;j>=0;j--){
            if(nums[j]>temp){
                //让该元素往后移
                nums[j+1]=nums[j];
            }else{
                break;
            }
        }
        nums[j+1]=temp;
        }
}

折半插入排序

//折半插入排序
void BinaryInsertionSort(int* nums,int numsSize){
    for(int i=1;i<numsSize-1;i++){
        int temp=nums[i];
        int left=0;
        int right=i-1;
        //二分查找的过程，其实也就是在前面已排好序的序列中运用二分查找的方法找到相应位置插入
        while(left<=right){
            int mid=(left+right)/2;
            if(nums[mid]>temp){
                left=mid-1;
            }else if(nums[mid]<temp){
                right=mid+1;
            }
        }
        //已经找到了相应位置，就把这个位置之后的元素（包括这个位置）依次向后移动。
        for(int j=i-1;j>=left;j--){
            nums[j+1]=nums[j];
        }
        nums[left]=temp;
    }
}

冒泡排序

//冒泡排序
void BubbleSort(int* nums,int numsSize){
    //数组下标=Size-1，然后因为他要与后面的元素相比，所以只能再Size-1的前一个结束比较，
    //不能到达Size-1个元素
    for(int i=0;i<nums-1;i++){z
        //一趟过后确定一个元素有序，所以i趟过后，就需要少比较i个元素
        for(int j=0;j<numsSize-i-1;j++){
            //如果相邻元素中前面大于后面就要进行交换
            if(nums[j]>nums[j+1]){
                int temp=nums[j+1];
                nums[j+1]=nums[j];
                nums[j]=temp;
            }
        }
    }
}

快速排序

//快速排序
//划分操作
int huafen(int*nums,int left,int right){
    //以最左边的元素为基准元素
    int mid=nums[left];
    while(left<right){
        //从右边开始寻找比基准元素小（或等于）的元素
        while(nums[right]>=mid&&left<right){
            right--;
        }
        nums[left]=nums[right];
        while(nums[left]<=mid&&left<right){
            left++;
        }
        nums[right]=nums[left];
    }
    nums[left]=mid;
    return left;
}

//递归排序
void Qsort(int*nums,int left,int right){
    if(left>=right){
        return;
    }
    int mid=huafen(nums,left,right);
    //左半部分快排
    Qsort(nums,left,mid-1);
    //右半部分快排
    Qsort(nums,mid+1,right);
}

 简单选择排序

//简单选择排序
void SelectSort(int* nums,int numsSize){
    //仅需进行n-1趟
    for(int i=0;i<numsSize-1;i++){
        int min=i;
        //这里是用打擂台的方法，从i+1到n中选出最小值，
        for(int j=i+1;j<numsSize;j++){
            if(nums[min]>nums[j]){
                min=j;
            }
        }
        //如果最小值变了那么久进行换位置，把最小的放在第一个
        if(min!=i){
            int temp=nums[i];
            nums[i]=nums[min];
            nums[min]=temp;
        }
    }
}

归并排序

堆排序

//交换操作
 void swap(int arr[],int i,int k){
     int temp=arr[i];
     arr[i]=arr[k];
     arr[k]=temp;
 }
//堆调整，调整第i个结点
 void heapify(int heap[],int len,int i){
     if(i>len){
         return;
     }
	 //找左右孩子（这里默认第一个结点是0，如果默认第一个结点是1的话自己改一下关系就可以了）
     int left=2*i+1;
     int right=2*i+2;
	 //比较最大结点
     int max=i;
     if(left<len && heap[left]>heap[max]){
         max=left;
     }else if(right<len && heap[right]>heap[max]){
         max=right;
     }
	 //如果最大值不是上面的结点，则就交换，然后继续向下调整
     if(max!=i){
         swap(heap,max,i);
         heapify(heap,len,max);
     }
 }
//  建堆
void build_heap(int heap[],int len){
	//从最后一个结点的父结点开始调整堆
    int last_node=len-1;
    int partent=(last_node-1)/2;
    for(int i=partent;i>=0;i--){
        heapify(heap,len,i);
    }
}
// 堆排序
void heap_sort(int heap[],int len){
    build_heap(heap,len);
    for(int i=len-1;i>0;i--){
        swap(heap,i,0);
        heapify(heap,i,0);
    }
}