C语言基础 - 20230511

一.练习

三个文件：main.c head.h test.c
1> 通过指针指向字符串，实现字符串逆置 void MyStrRev(char *p) //p要逆序的字符串
3> 字符串连接 char *MyStrcat(char *dest,const char *src)//dest：连接到dest字符串中，src字符串不变
4> 字符串比较函数int MyStrcmp(const char *s1,const char *s2) s1存储第一个字符串 s2存储第二个字符串
5> 字符串拷贝char *MyStrcpy(char *dest,const char *sec) dest：拷贝后的字符串 src源字符串
6> 字符串长度long Mystrlen(const char *s1) s1存储字符串
7> 使用递归实现斐波那契 FibonaciRec(n-1)+FibonaciRec(n-2)
8> 实现单词的逆置例如：char str[]=“hello my student”，输出结果是“student my hello”
思路：先整体对字符串逆置，在对每一个单词逆置
9> 指针指向一维数组，实现冒泡排序
10> 指针指向一维数组，实现简单选择排序

head.h

#ifndef N
#define N

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

void myStrRev(char *p);
char *myStrCat(char *dest, const char *src);
int myStrCmp(const char *s1, const char *s2);
char *myStrCpy(char *dest, const char *src);
long myStrLen(const char *s1);
int fib(int n);
char *wordReverse(char *str);
void bubbleSort(int *p, int len);
void selectSort(int *p, int len);
void swap(int *a, int *b);

#endif

main.c

#include "head.h"

int main(int argc, const char *argv[])
{
	{
		//1.
		char str[] = "abcde";
		myStrRev(str);
		printf("1 = %s\n", str);
	}

	{
		//2.
		char str1[20] = "abcd";
		char str2[] = "1234";
		myStrCat(str1, str2);
		printf("2 = %s\n", str1);
	}
	{
		//3.
		char str1[] = "aaa";
		char str2[] = "aaaa";
		printf("3 = %d\n", myStrCmp(str1, str2));
	}
	{
		//4.
		char str1[20] = "abcd";
		char str2[] = "12345";
		printf("4 = %s\n", myStrCpy(str1, str2));
	}
	{
		//5.
		char str[] = "abcd";
		printf("5 = %ld\n", myStrLen(str));
	}
	{
		//6.
		printf("6 = %d \n", fib(6));
	}
	{
		//7.
		char str[] = "hello  my student";
		printf("7 = %s \n", wordReverse(str));
	}
	{
		//8.
		int arr[] = {10,4,2,3,1,8};
		bubbleSort(arr, 6);
		for (int i=0; i<6; i++) {
			printf("%d ", arr[i]);
		}
		printf("\n");
	}
	{
		//9.
		int arr[] = {10,4,2,3,1,8};
		selectSort(arr, 6);
		for (int i=0; i<6; i++) {
			printf("%d ", arr[i]);
		}
		printf("\n");
	}
	return 0;
}

test.c

#include "head.h"

//1.
void myStrRev(char *p) {
	char len = strlen(p);

	char *start = p;
	char *end = p+len-1;

	while(start<end) {
		char temp = *start;
		*start = *end;
		*end = temp;
		start++;
		end--;
	}
}

//2.
char *myStrCat(char *dest, const char *src) {
	char *p = dest;
	dest += strlen(dest);
	while(*src) {
		*dest = *src;
		dest++;
		src++;
	}
	*dest = '\0';
	dest = p;
	return p;
}

//3.
int myStrCmp(const char *s1, const char *s2) {
	while (*s1 == *s2 && *s1 != '\0' && *s2 != '\0') {
		s1++; 
		s2++;
	}
	return *s1-*s2;
}

//4. 
char *myStrCpy(char *dest, const char *src) {	
	char *p = dest;
	while(*src) {
		*dest = *src;
		dest++;
		src++;
	}
	*dest = '\0';
	dest = p;
	return p;
}

//5. 
long myStrLen(const char *s1) {
	int count = 0;
	while(*s1) {
		count++;
		s1++;
	}
	return count;
}

//6. 
int fib(int n) {
	if (n == 1 || n == 2) {
		return 1;
	} 
	return fib(n-1)+fib(n-2);
}

//7.
char *wordReverse(char *str) {
	myStrRev(str);

	int preIndex = -1; //记录前一个空格的下标
	for (int i=0; i<strlen(str)+1; i++) {
		char curValue = *(str+i);
		//如果当前值是空格或者\0，
		//并且和上一个空格下标相差超过1，则判断两个空格之间是单词。
		if ((curValue == ' ' || curValue == '\0')) {
			if ((i-preIndex)>1) {
				char *start = str+preIndex+1;
				char *end = str+i-1;
				while(start<end) {
					char temp = *start;
					*start = *end;
					*end = temp;
					start++;
					end--;
				}
			}
			preIndex = i;
		}
	}
	return str;
}

//8.
void bubbleSort(int *p, int len) {
	for (int i=0; i<len-1; i++) {
		for (int j=0; j<len-i-1; j++) {
			if (*(p+j) > *(p+j+1)) {
				swap(p+j, p+j+1);
			}
		}
	}
}

//9.
void selectSort(int *p, int len) {
	for (int i=0; i<len-1; i++) {
		int minIndex = i;
		for (int j=i; j<len; j++) {
			if ((*(p+j)) < (*(p+minIndex))) {
				minIndex = j;
			}
		}
		if (minIndex != i) {
			swap(p+i, p+minIndex);
		}
	}
}


void swap(int *a, int *b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}

结果展示