2_0_LeetCode刷题总结（总结篇）_技巧总结

编程总结

每每刷完一道题后，其思想和精妙之处没有地方记录，本篇博客用以记录刷题过程中的遇到的算法和技巧

sscanf 用法

	char str[100];
	int ret;
	//用法一：取指定长度的字符串    注意后面要加大小
	ret = sscanf_s("12345", "%4s", str, sizeof(str));
	printf("用法一\nstr = %s\n", str);
	// str = 1234

	//用法二：格式化时间  
	int year, month, day, hour, minute, second;
	ret = sscanf_s("2013/02/13 14:55:34", "%d/%d/%d %d:%d:%d", &year, &month, &day, &hour, &minute, &second);
	printf("用法二\ntime = %d-%d-%d %d:%d:%d\n", year, month, day, hour, minute, second);
	// time = 2013-2-13 14:55:34

	//用法三：读入字符串  
	ret = sscanf_s("12345", "%s", str, sizeof(str));
	printf("用法三\nstr = %s\n", str);
	// str = 12345

	//用法四：%*d 和 %*s 加了星号 (*) 表示跳过此数据不读入. (也就是不把此数据读入参数中)  
	ret = sscanf_s("12345acc", "%*d%s", str, sizeof(str));
	printf("用法四\nstr = %s\n", str);
	// str = acc

	//用法五：取到指定字符为止的字符串。如在下例中，取遇到'+'为止字符串。  
	ret = sscanf_s("12345+acc", "%[^+]", str, sizeof(str));
	printf("用法五\nstr = %s\n", str);
	// str = 12345

	//用法六：取到指定字符集为止的字符串。如在下例中，取遇到小写字母为止的字符串。  
	ret = sscanf_s("12345+acc121", "%[^a-z]", str, sizeof(str));
	printf("用法六\nstr = %s\n", str);
	// str = 12345+

	//综合测试
	char str1[100] = "123568qwerSDDAE";
	char lowercase[100];
	int num;
	ret = sscanf_s(str1, "%dq%[a-z]", &num, lowercase, sizeof(str1));
	printf("The number is: %d.\n", num);
	printf("The lowercase is: %s.", lowercase);
	// The number is: 123568.
	// The lowercase is: wer.

qsort 用法

int类型

int num[100];
int cmp(const void *a, const void *b)
{
	return *(int *)a - *(int *)b;   // 升序排序          注意这里把空类型转换为int类型的指针！
	//return *(int *)b - *(int *)a; // 降序排序
	/*可见：参数列表是两个空指针，现在他要去指向你的数组元素。所以转型为你当前的类型，然后取值。
		升序排列时，若第一个参数指针指向的“值”大于第二个参数指针指向的“值”，则返回正；
		若第一个参数指针指向的“值”等于第二个参数指针指向的“值”，则返回零；
		若第一个参数指针指向的“值”小于第二个参数指针指向的“值”，则返回负。
		降序排列时，则刚好相反。
	*/
}
qsort(num, n, sizeof(num[0]), cmp);

float类型

double in[100];
int cmp(const void *a, const void *b)
{
	return *(double *)a > *(double *)b ? 1 : -1;
	//返回值的问题，显然cmp返回的是一个整型，所以避免double返回小数而被丢失，用一个判断返回值。
}
qsort(in, 100, sizeof(in[0]), cmp);

结构体一级排序

struct In
{
	double data;
	int other;
}s[100];

int cmp(const void *a, const void *b)
{
	return (*(struct In *)a).data > (*(struct In *)b).data ? 1 : -1;      //先转化再进行取值运算
}
qsort(s, 100, sizeof(s[0]), cmp);

结构体二级排序

struct In
{
	int x;   //你可以比喻成：失败次数
	int y;   //你可以比喻成：成功次数
}s[100];

// 按照x从小到大排序，当x相等时按照y从大到小排序。 
// 你可以想象成：失败是主要因素的一个问题，先比较 失败次数少，失败次数相同 再看 成功次数多。
int cmp(const void *a, const void *b)
{
	struct In *c = (struct In *)a;
	struct In *d = (struct In *)b;

	if (c->x != d->x) 
		return c->x - d->x;
	else 
		return d->y - c->y;
}
qsort(s, 100, sizeof(s[0]), cmp);

字符串排序

struct In
{
	int data;
	char str[100];
}s[100];

//按照结构体中字符串str的字典顺序排序
int cmp(const void *a, const void *b)
{
	return strcmp((*(In *)a)->str, (*(In *)b)->str);
}
qsort(s, 100, sizeof(s[0]), cmp);

安全函数使用汇总

#define BUFFER_SIZE  128
int safetyFunction(char *s)
{
    int len = strlen(s);
    if (len <= 1) {
        return len;
    }
    errno_t rc;
    char hashtable1[BUFFER_SIZE]  = {false};
    char hashtable2[BUFFER_SIZE]  = {"@123@1234@12345@"};
    char hashtable3[BUFFER_SIZE]  = {"12345678"};
    // 1. errno_t memcpy_s(void* dest, size_t destMax, const void* src, size_t count)
    rc = memcpy_s(hashtable1, BUFFER_SIZE, hashtable2, BUFFER_SIZE - 1);
    if (rc != EOK) {
        return -1;
    }
    // 2.errno_t memset_s(void* dest, size_t destMax, int c, size_t count)
    rc = memset_s(hashtable1, BUFFER_SIZE, '1', BUFFER_SIZE);
    if (rc != EOK) {
        return -1;
    }
    // 3.errno_t strcpy_s(char* strDest,size_t destMax,const char* strSrc)
    rc = strncpy_s(hashtable1, BUFFER_SIZE, "The Love of the game",  BUFFER_SIZE);
    if (rc != EOK) {
        return -1;
    }
    // 4.errno_t strcat_s(char* strDest,size_t destMax,const char* strSrc)
    rc = strcat_s(hashtable1, BUFFER_SIZE, "Make the choice");
    if (rc != EOK) {
        return -1;
    }

    // 5.char* strtok_s(char* strToken, const char* strDelimit, char** context)
    // 成功：返回被分割出的子字符串首地址（当子字符串长度等于0时返回NULL）
    // 失败：当参数不合法或找到的子字符串长度为0时，返回NULL。
    char *next = NULL; // 保存调用strok_s后的位置信息
    char *token = NULL;
    const char *plim = "@";
    token = strtok_s(hashtable2, plim, &next);
    while (token != NULL) {
        if (token != NULL) {
            printf(" %s\n", token);
            token = strtok_s(NULL, plim, &next);
        }
    }

    // 6.int sprintf_s(char *strDest, size_t destMax, const char *format, ...) -- 将数据格式化输出到目的缓冲区。
    // 成功：操作成功时，返回写入的字符个数
    char buffer[BUFFER_SIZE] = {0};
    char *string    = "Kobe Kobe";
    int  intString  = 20201204;
    int  iRet;
    iRet = sprintf_s(buffer, BUFFER_SIZE, "%s, %d", string, intString);
    printf("iRet = %d, buffer = %s.\n", iRet, buffer);
    iRet = atoi(hashtable3);

    return len;
}

int main()
{
    const char *str = "abcabcd";
    safetyFunction(str);
}

sprintf_s 还可以组合多个不同格式的统一到字符数组里：

数字转字符串

 tmp = atoi(res);
 sprintf_s(result, NUM_9, "%08d", tmp);
 sprintf_s(node[cnt].buf, NUM_9 + 1, "%c%08s", strs[i][0], result);
 int x = 100;
 char str[20];
 sprintf_s(str, 25, "%d", x);
 float y = 20.3;
 char str1[25];
 sprintf_s(str1, 25, "%f", y);
 double z = 20.3;
 char str2[25];
 sprinf_s(str2, 25, "%lf", z);

字符串转数字

const char *buf = "34536";
char buf1[] = "23244";
char buf2[] = "23.46";
int int_num = atoi(buf);
long long long_num = atoll(buf1);
double double_num = atof(buf2);

HASH