memcpy与memmove函数

memcpy()与memmove()是C语言中的函数，其声明在头文件string.h中，具体声明如下：

void* __cdecl memcpy(
    _Out_writes_bytes_all_(_Size) void* 	  _Dst,
    _In_reads_bytes_(_Size)       void const* _Src,
    _In_                          size_t      _Size
    );
    
_VCRTIMP void* __cdecl memmove(
    _Out_writes_bytes_all_opt_(_Size) void*       _Dst,
    _In_reads_bytes_opt_(_Size)       void const* _Src,
    _In_                              size_t      _Size
    );

说明
memcpy将计数字节从src复制到目标;wmemcpy复制计数宽字符（两个字节）。 如果源和目标重叠，则memcpy的行为是不确定的。 使用memmove处理重叠区域。

参考
https://docs.microsoft.com/zh-cn/cpp/c-runtime-library/reference/memcpy-wmemcpy?view=vs-2019

在C/C++一些笔试中较常见要求不用标准库函数，实现mommove函数的功能，这里进行一下自我总结：
函数原型

void *memcpy(void *dst, const void *src, size_t size);
void *memmove(void *dst, const void *src, size_t size);

函数实现

void* memcpy(void* dst, const void* src, size_t size)
{
    char *dst_t = (char*)dst;
    char *src_t = (char*)src;
 
    while(size--) {
        *dst_t++ = *src_t++;
    }
    return dst;
}

由于memcpy是不去处理覆盖的情况的，所以已经不推荐使用了，而memmove对于src<dst<src+size的情况需要从后往前移动，才能正确处理覆盖的情况。

void* memmove(void* dst, const void* src, size_t size)
{
    char* dst_t = (char*)dst;	// 指向首地址
    char* src_t = (char*)src;

    if(dst_t > src_t && (src_t + size>s_dst)) {  // 从后往前移动
        dst_t = dst_t + size - 1;
        src_t = src_t + size - 1;
        while(size--) {
            *dst_t-- = *src_t--;
        }
    }else {
        while(size--) {
            *dst_t++ = *src_t++;
        }
    }
    return dst;
}

<----------------------------正文分割线---------------------------->
随机插入几个简单算法
1、二分查找

int BinarySearch(int s[], int n, int key)
{
    int low=0, high=n-1;
    int mid;
    while(low <= high)
    {
        mid = (low + high) / 2;
        if(s[mid] == key)  return mid;
        else if(s[mid] > key)   high = mid - 1;
        else low = mid + 1
    }
    return -1;
}

2、选择排序

void Select_Sort(int arr[],int sz)
{
    int i = 0;
    int j = 0;
    int temp = 0;
    int minIndex = 0;
    for (i = 0; i < sz; ++i)
    {
        minIndex = i;
        for (j = i+1; j < sz; ++j)
        {
            if (arr[minIndex]>arr[j])
                minIndex = j;//更新最小值的下标
        }
        if (arr[i]>arr[minIndex])
        {
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

时间复杂度 $O(n^2)$，空间复杂度 $O(1)$。
3、快速排序

//递归实现快速排序
#include <cstdio>
#include<cstdlib>

void quickSort(int* arr,int low,int high);
int Partition(int* arr,int low,int high);

int main(int argc,char* argv[])
{
    int i,a[]={4,2,6,9,1,3,5};
    int length = sizeof(a)/sizeof(a[0]);
    quickSort(a,0,length-1);
    printf("After sorted:  ");
    for(i=0;i<length;i++)
        printf("%d ",a[i]);
}

void quickSort(int* arr,int low,int high)
{
    if(low<high)
    {
        int pivotloc = Partition(arr,low,high);
        quickSort(arr,low,pivotloc-1);
        quickSort(arr,pivotloc+1,high);
    }
}

int Partition(int* arr,int low,int high)
{
    int pivotkey = arr[low];
    while(low<high)
    {
        while(low<high && arr[high] >= pivotkey)
            --high;	// 从后往前扫
        arr[low] = arr[high];
        while(low<high && arr[low] <= pivotkey)
            ++low;	// 从前往后扫
        arr[high] = arr[low];
    }
    arr[low] = pivotkey;
    return low;
}

时间复杂度 $O(log\ n)$，空间复杂度 $O(log\ n)$。