字符串，数组，结构体的相关题解，qsort的使用，力扣部分题解

1，两数相加

    （1）输入：l1 = [2,4,3], l2 = [5,6,4]

输出：[7,0,8]

解释：342 + 465 = 807.

（2）输入：l1 = [0], l2 = [0]

输出：[0]

（3）输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]

输出：[8,9,9,9,0,0,0,1]

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    int l1[n], l2[m];
    for (int i = 0; i < n; i++){
        scanf("%d", &l1[i]);
    }
    for (int i = 0; i < m; i++){
        scanf("%d", &l2[i]);
    }
    int s = (n > m) ? n + 1 : m + 1;
    int sum[s];
    for (int i = 0; i < s; i++){
        sum[i] = 0;
    }
    for (int i = 0; i < s; i++){
        int digit_sum = sum[i] + ((i < n) ? l1[i] : 0) + ((i < m) ? l2[i] : 0);
        if (digit_sum >= 10){
            sum[i] = digit_sum % 10;
            sum[i + 1] = 1;
        }
        else{
            sum[i] = digit_sum;
        }
    }
    printf("Sum array:\n");
    int start = (sum[s - 1] != 0) ? s - 1 : s - 2;
    for (int i = start; i >= 0; i--){
        printf("%d", sum[i]);
    }
    return 0;
}

 由上先在数组中定义有两个数组，由用户输入字符长度和数组中的内容；

之后定义有第三个数组即需输出的数组先初步判断s数组的字符数（因为有第三种示例的情况存在），随后对数组内的数进行赋值

for (int i = 0; i < s; i++){
        int digit_sum = sum[i] + ((i < n) ? l1[i] : 0) + ((i < m) ? l2[i] : 0);
        if (digit_sum >= 10){
            sum[i] = digit_sum % 10;
            sum[i + 1] = 1;
        }
        else{
            sum[i] = digit_sum;
        }
    }

我们定义有在sum中某个字符代表的数字digit_sum，使用这个数字进行加法，为s中的数字赋值，当s中的数大于等于10时，需要向前进一位，原本位置上的对10取余，得到个位数部分。反之，则直接赋值。最后输出结果。

2，判断子序列

字符串的一个子序列是原始字符串删除一些 (也可以不删除)字符而不改变剩余字符相对位置形成的新字符串。 (例如，"ace”是“abcde”的一个子序列，而"aec”不是)

（1）输入：s ="abc"，t ="ahbgdc'

输出:true

（2）输入: s ="axc"，t ="ahbgdc

输出: false

#include <stdio.h>
#include <stdbool.h>

bool panduan(char * s, char * t) {
    while (*t) {
        s += (*s == *t++);
    }
    return !*s;
}

int main() {
    char s1[20],t1[20];
    fgets(s1,sizeof(s1),stdin);
    fgets(t1,sizeof(t1),stdin);
    printf("%s",panduan(s1, t1) ? "Yes" : "false");

    return 0;

创建一个bool类型的函数，用以判断子链。

*s == *t++：比较 s 和 t 指向的当前字符是否相等。如果相等，这个表达式的值为 1（true），否则为 0（false）。s += (*s == *t++);：根据比较的结果，更新 s 指针的位置。如果当前字符相等，s 的指针向后移动一位，否则保持不变。return !*s;：最终的返回语句。如果在循环中 *s 成为了结束符 \0（即字符串 s 包含了字符串 t），那么 !*s 就为 true，表示函数返回 true；否则返回 false。

3，字符串中的单词反转

     （1）输入: message = "the sky is blue"

输出: "blue is sky the"

（2）输入: message = "  hello world!  "

输出: "world! hello"

解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

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

void turn(char *message) {
    char *start = message;
    char *end = message + strlen(message) - 1;

    while (*start == ' ') {
        start++;
    }

    while (*end == ' ' && end >= start) {
        end--;
    }
    while (start < end) {
        char temp = *start;
        *start = *end;
        *end = temp;

        start++;
        end--;
    }
    start = message;
    while (*start) {
        while (*start == ' ') {
            start++;
        }
        end = start;
        while (*end && *end != ' ') {
            end++;
        }
        char *word_start = start;
        char *word_end = end - 1;
        while (word_start < word_end) {
            char temp = *word_start;
            *word_start = *word_end;
            *word_end = temp;

            word_start++;
            word_end--;
        }
        start = end;
    }
}

int main() {
    char message[100];
    fgets(message,sizeof(message),stdin);
    turn(message);
    printf("%s", message);

    return 0;
}

 定义一个函数用于交换单词的位置：

从前到后检索字符串，空格除去（输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括），并且将所有字符交换位置

第二步

将start的定为message字符串的第一个字母。由前向后检索去掉多余的空格后，将一个单词的终止点定为单词起始点，检索至这个单词结束的位置。然后单独对这个单词进行交换位置。随后进行循环至结束。

4，按总成绩排序，从大到小，如果总成绩一样，按语文成绩排序

姓名 语文  数学

张三  88    98

李四  91    96

王五  90    97

赵六  95    80

#include <stdio.h>
struct Student {
    char name[20];
    int chinese;
    int math;
    int total;
};
void turn(struct Student students[4]){
    for(int i=0;i<4;i++){
        for(int j=i+1;j<4;j++){
            if(students[i].total<students[j].total){
                struct Student temp = students[i];
                students[i] = students[j];
                students[j] = temp;
            }
        }
    }
}
int main() {
    struct Student students[4] = {
        {"张三", 88, 98, 0},
        {"李四", 91, 96, 0},
        {"王五", 90, 97, 0},
        {"赵六", 95, 80, 0}
    };
    for (int i = 0; i < 4; i++) {
        students[i].total = students[i].chinese + students[i].math;
    }
    turn(students);
    for(int i=0;i<4;i++){
        printf("%s\n",students[i].name);
    }
    return 0;
}

声明一个结构体，然后定义一个函数，函数内容为根据成绩交换各位在结构体中的位置。

后在主函数中定义这个数组，之后引用函数。

qsort

使用之前还需要引用函数

int compar (const void* e1, const void* e2);

如果你要比较的数据是整形： 

int cmp_int(const void* e1, const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}

如果你要比较的数据是浮点型

int cmp_float(const void* e1, const void* e2)
{
	return (int)(*(float*)e1 - *(float*)e2);
}

 如果你要比较的是字符串的大小：

int cmp_str_size(const void* e1, const void* e2)
{
	return strcmp((char*)e1,(char*)e2);
}

如果你要比较的是字符串的长度

int cmp_str_len(const void* e1, const void* e2)
{
	return strlen((char*)e1)-strlen((char*)e2);
}

 如果你要比较的数据是结构体变量：

int cmp_by_age(const void*e1, const void*e2)
{
	return (int)(((stu*)e1)->weight - ((stu*)e2)->weight);
}

如果需要逆向输出，只需将e1和e2交换位置

一维数组排序 

int comper(const void*a,const void*b)
{
    return *(int*)a-*(int*)b;
}

 对二维数组进行排序

int comper(const void*a,const void*b)
{
    return((int*)a)[0]-((int*)b)[0];
}

使用实例