1，写一个函数，实现字符串的拼接。

在C语言中，可以使用指针和 malloc() 函数来实现两个字符串的拼接。以下是一个简单的例子：

#include <stdio.h>

#include <stdlib.h>

char* concatenate_strings(char* string1, char* string2) {

// 计算字符串1的长度

int len1 = 0;

while (string1[len1] != '\0') {

len1++;

}

// 计算字符串2的长度

int len2 = 0;

while (string2[len2] != '\0') {

len2++;

}

// 为新字符串分配内存，包括 '\0' 字符的空间

char* result = (char*)malloc((len1 + len2 + 1) * sizeof(char));

if (result == NULL) {

printf("Memory allocation failed\n");

exit(1);

}

// 复制字符串1到结果字符串

for (int i = 0; i < len1; i++) {

result[i] = string1[i];

}

// 复制字符串2到结果字符串

for (int i = 0; i < len2; i++) {

result[i + len1] = string2[i];

}

// 在结果字符串的末尾添加 '\0' 字符

result[len1 + len2] = '\0';

return result;

}

int main() {

char* string1 = "Hello, ";

char* string2 = "World!";

char* result = concatenate_strings(string1, string2);

printf("%s\n", result);

free(result); // 释放内存

return 0;

}

这个程序首先计算两个输入字符串的长度，然后分配足够的内存来保存这两个字符串的拼接结果，包括一个额外的字节来保存终止的空字符。然后，它把两个输入字符串复制到新的内存位置。最后，它在新字符串的末尾添加一个空字符来终止它。在 main() 函数中，我们调用 concatenate_strings() 函数，并打印结果字符串。最后，我们释放了分配给结果的内存。这里我们当然也可以使用c语言自带的库函数进行拼接，不需要写这么麻烦！

2，写一个函数，实现字符串的分割。

该函数使用strtok函数来分割字符串

#include <stdio.h>

#include <string.h>

void split_string(char* str, const char* delimiter) {

char* token = strtok(str, delimiter);

while (token != NULL) {

printf("%s\n", token);

token = strtok(NULL, delimiter);

}

}

int main() {

char str[] = "Hello, World! This is a test string.";

split_string(str, ", ");

return 0;

}

这个函数接受一个字符串和一个分隔符作为输入，然后使用strtok函数来分割字符串。strtok函数会根据指定的分隔符将字符串分割成一系列的子串，并返回指向每个子串的指针。我们可以将这些指针存储在一个数组中，或者直接打印出来。在这个例子中，我们选择打印每个子串。

3，写一个函数，实现字符串的替换。

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

char* str_replace(char* str, char* old_substr, char* new_substr) {

char* result=NULL;

char* ins=NULL;

char* tmp=NULL;

int len_old=0;

int len_new=0;

int len_front=0;

int count=0;

// 检查输入字符串是否为空

if (str == NULL) {

return NULL;

}

// 计算旧子字符串的长度

len_old = strlen(old_substr);

// 如果旧子字符串为空，则返回原始字符串

if (len_old == 0) {

return str;

}

// 计算新子字符串的长度

len_new = strlen(new_substr);

// 初始化一个指向结果字符串的指针

result = NULL;

// 查找第一个匹配的旧子字符串的位置

ins = str;

for (count = 0; (tmp = strstr(ins, old_substr)); ++count) {

ins = tmp + len_old;

}

// 为每个匹配的子字符串创建一个新字符串

while (count--) {

tmp = result = malloc(strlen(str) + (len_new - len_old) * 2 + 1);

while (ins != NULL) {

len_front = ins - str;

tmp = strncpy(tmp, str, len_front) + len_front;

tmp = strcpy(tmp, new_substr) + len_new;

ins = strstr(ins + len_front, old_substr);

}

strcpy(tmp, str + (ins - str));

str = result;

}

return result;

}

这个函数接受三个参数：原始字符串、要替换的旧子字符串和用于替换的新子字符串。它返回一个指向新字符串的指针，该指针指向一个以新子字符串替换旧子字符串后的字符串。如果输入的原始字符串为空，则返回NULL。如果旧子字符串为空，则返回原始字符串。

4，写一个函数，实现字符串的比较。

#include <stdio.h>

#include <string.h>

int compare_strings(char* str1, char* str2) {

int result = strcmp(str1, str2);

if (result == 0) {

printf("The two strings are equal.\n");

} else {

printf("The two strings are not equal.\n");

}

return result;

}

int main() {

char str1[] = "Hello, world!";

char str2[] = "Hello, world!";

int result = compare_strings(str1, str2);

return 0;

}

这个函数使用了C标准库中的strcmp()函数来比较两个字符串。如果两个字符串相等，strcmp()函数返回0，否则返回一个非零值。这个函数根据strcmp()函数的返回值来输出相应的信息，并返回比较结果。在主函数中，我们声明两个字符串，并调用这个函数来比较它们。

5，写一个函数，实现字符串的排序。

#include <stdio.h>

#include <string.h>

void sort_strings(char arr[][100], int n) {

char temp[100];

int i, j;

for (i = 0; i < n-1; i++) {

for (j = i+1; j < n; j++) {

if (strcmp(arr[i], arr[j]) > 0) {

strcpy(temp, arr[i]);

strcpy(arr[i], arr[j]);

strcpy(arr[j], temp);

}

}

}

}

int main() {

char arr[5][100] = {"Apple", "Orange", "Banana", "Mango", "Peach"};

int n = 5;

sort_strings(arr, n);

int i;

for (i = 0; i < n; i++) {

printf("%s\n", arr[i]);

}

return 0;

}

这个函数使用冒泡排序算法对字符串数组进行排序。它接受一个字符串数组和数组的大小作为输入，并在原始数组上进行排序。在排序过程中，如果第i个字符串应该排在第j个字符串之前，则交换它们的位置。最终，函数输出已排序的字符串数组。