C语言算法

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#define N 10

//冒泡排序
int main(void)
{
	int i = 0, j = 0, temp = 0;
	int a[N] = { 0 };
	for (i = 0; i < N; i++)
	{
		scanf("%d", &a[i]);
	}
	for (i = 0; i < N - 1; i++)//10个数据比较9轮
	{
		for (j = 0; j < N - 1 - i; j++)//每次少比一次，因为每次都把最大值放到最右侧了
		{
			if (a[j] > a[j + 1])
			{
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
	for (i = 0; i < N; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

//插入排序
int main(void)
{
	int i = 0;
	int a[N] = { 0 };
	for (i = 0; i < N; i++)
	{
		scanf("%d", &a[i]);
	}
	for (i = 1; i <= N - 1; i++)
	{
		int temp = a[i];
		int j = 0;
		for (j = i - 1; j >= 0; j--)
		{
			if (a[j] <= temp)
			{
				break;
			}
			a[j + 1] = a[j];
		}
		a[j + 1] = temp;
	}
	for (i = 0; i < N; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

//选择排序
int main(void)
{
	int i = 0;
	int a[N] = { 0 };
	int max = 0;
	int index = 0;
	for (i = 0; i < N; i++)
	{
		scanf("%d", &a[i]);
	}
	for (index = N - 1; index > 0; index--)
	{
		max = 0;
		for (i = 1; i <= index; i++)
		{
			if (a[max] < a[i])
			{
				max = i;
			}
		}
		int temp = a[max];
		a[max] = a[index];
		a[index] = temp;
	}
	for (i = 0; i < N; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

//快速排序
int FirstSort(int a[], int low, int high)
{
	int temp = a[low];//记录基准，一开始的基准是low下标数据
	while (low < high)
	{
		while (low < high && a[high] >= temp)
		{
			high--;
		}
		a[low] = a[high];
		while (low < high && a[low] <= temp)
		{
			low++;
		}
		a[high] = a[low];
	}
	a[low] = temp;
	return low;//返回基准下标
}

void QuickSort(int a[], int low, int high)
{
	if (low < high)
	{
		int pos = FirstSort(a, low, high);
		QuickSort(a, low, pos - 1);//左半部分
		QuickSort(a, pos + 1, high);//右半部分
	}
}

//鸡尾酒排序
void cocktail_sort(int a[], int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int i = 0, temp = 0;
	if (left < right)
	{
		//最大值移动到最右边
		for (i = left; i < right; i++)
		{
			if (a[i] > a[i + 1])
			{
				temp = a[i];
				a[i] = a[i + 1];
				a[i + 1] = temp;
			}
		}
		//最小值移动到最左边
		for (i = right; i > left; i--)
		{
			if (a[i] < a[i - 1])
			{
				temp = a[i];
				a[i] = a[i - 1];
				a[i - 1] = temp;
			}
		}
		cocktail_sort(a, left + 1, right - 1);
	}
}

//统计输入字符的个数
int main(void)
{
	char ch = 0;
	int count1 = 0, count2 = 0, count3 = 0, count4 = 0;
	while ((ch = getchar()) != '\n')
	{
		if (ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z')
		{
			count1++;//英文字母
		}
		else if (ch == ' ')
		{
			count2++;//空格
		}
		else if (ch >= '0' && ch <= '9')
		{
			count3++;
		}
		else
		{
			count4++;//其他字符
		}
	}
	printf("英文字母: %d个\n空格: %d个\n数字: %d个\n其他字符: %d个\n", count1, count2, count3, count4);
	return 0;
}

//折半插入排序
void half_insert_sort(int a[], int length)
{
	int i = 0, j = 0;
	for (i = 1; i < length; i++)//依次插入每一个数据，第一个数据自然有序
	{
		int key = a[i];//记录要插入的数据
		int left = 0;
		int right = i - 1;
		while (left <= right)
		{
			int mid = (left + right) / 2;
			if (key < a[mid])
			{
				right = mid - 1;
			}
			else
			{
				left = mid + 1;
			}
		}
		//把left到i-1之间的数据往后移动
		for (j = i - 1; j >= left; j--)
		{
			a[j + 1] = a[j];
		}
		a[left] = key;//在当前left的位置保存要插入的数据
	}
}

//希尔排序
void shell_sort(int a[], int length)
{
	int i = 0, j = 0;
	int step = 0;
	for (step = length / 2; step >= 1; step = step / 2)//最后step=1其实就是最后一轮相当于直接插入排序
	{
		for (i = step; i < length; i++)
		{
			int key = a[i];//要插入的数据
			for (j = i - step; j >= 0 && a[j] > key; j = j - step)
			{
				a[j + step] = a[j];//向后移动
			}
			a[j + step] = key;
		}
	}
}


int main(void)
{
	int a[N] = { 0 };
	for (int i = 0; i < N; i++)
	{
		scanf("%d", &a[i]);
	}
	shell_sort(a, 10);
	for (int i = 0; i < N; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

char* my_strcpy(char* dest, const char* src)
{
	char* original_dest = dest;//记录目标字符串的首地址
	while ((*src) != '\0')
	{
		*dest = *src;
		dest++;
		src++;
	}
	*dest = '\0';
	return original_dest;
}

int main(void)
{
	char destination[20];
	char* source = "World";

	//my_strcpy(destination, source);
	printf("%s\n", my_strcpy(destination, source));

	return 0;
}



//堆排序
void swap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

void re_heap(int a[], int index, int len)
{
	int child = 2 * index + 1;//左节点坐标
	int key = a[index];//当前节点值
	while (child < len)
	{
		if (child + 1 < len && a[child] < a[child + 1])
		{
			//如果右节点存在并且右节点的值比左节点大
			//那么child记录较大节点的坐标
			child++;
		}
		if (a[child] > key)
		{
			//如果子节点的值比根节点的值大
			a[index] = a[child];//改变根节点的值
		}
		else
		{
			break;
		}
		index = child;
		child = 2 * index + 1;
	}
	a[index] = key;//插入记录好的值
}

void heap_sort(int a[], int len)
{
	int i = 0;
	for (i = len / 2; i >= 0; i--)
	{
		re_heap(a, i, len);//对第i个根节点进行大根堆化
	}
	for (i = len - 1; i > 0; i--)
	{
		swap(&a[0], &a[i]);//交换第一个元素和最后一个元素
		re_heap(a, 0, i);//对一个元素进行大堆化，最后一个元素已经选择出来了，所以大堆化的时候就少遍历一个
	}
}


//归并排序
void merge(int a[], int left, int right)
{
	int i = 0, j = 0, k = 0;
	int mid = (left + right) / 2;
	int len = mid - left + 1;//左半部分的长度
	int* temp = (int*)malloc(sizeof(a[0]) * len);//定义一个临时数组
	if (temp == NULL)
		return;
	for (i = 0; i < len; i++)
	{
		//把数组的元素赋值到临时数组中，临时数组是左半部分有序数组
		temp[i] = a[i + left];
	}
	i = 0;//临时数组的第一个元素
	j = mid + 1;//右半部分有序数组的第一个元素
	k = left;
	while (i < len && j <= right)
	{
		if (temp[i] < a[j])
		{
			a[k++] = temp[i++];
		}
		else
		{
			a[k++] = a[j++];
		}
	}
	while (i < len)//如果temp这个数组的元素还没有全部遍历完，那就把temp后面的元素都复制到数组里面去
	{
		a[k++] = temp[i++];
	}
	free(temp);
}

void merge_sort(int a[], int left, int right)
{
	if (left >= right)//如果只有一个元素说明这个序列有序，直接返回
	{
		return;
	}
	int mid = (left + right) / 2;
	merge_sort(a, left, mid);
	merge_sort(a, mid + 1, right);
	merge(a, left, right);
}

int main(void)
{
	int a[N] = { 0 };
	for (int i = 0; i < N; i++)
	{
		scanf("%d", &a[i]);
	}
	merge_sort(a, 0, 9);
	for (int i = 0; i < N; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}


/* 自己实现strlen函数 */
int my_strlen(const char* str)
{
	int length = 0;
	while (str[length] != '\0')
	{
		length++;
	}
	return length;
}


/* 自己实现strcat函数 */
char* my_strcat(char* dest, const char* src)
{
	char* ptr = dest;
	while (*ptr != '\0')
	{
		ptr++;
	}
	while (*src != '\0')
	{
		*ptr = *src;
		ptr++;
		src++;
	}
	*ptr = '\0';
	return dest;//dest指针还是指向字符串的首地址
}

int main(void)
{
	//注意连接后的字符数组要有足够大的空间，不然会栈溢出
	char string[20] = "Hello";
	char string2[] = "World";
	//如果是要修改字符串中的内容，不要传递字符指针，不能对常量区的内容进行修改，要传递字符数组名
	char* new_string = my_strcat(string, string2);
	printf("%s\n", new_string);

	return 0;
}

int main(void)
{
	char* p = "hello";//这里p指针一开始指向的是常量区的内存
	char array[] = "world";//字符数组存储在栈区
	p = array;//p指针现在指向的是栈区的内存
}


//将字符串转化为整数
int my_atoi(const char* str)
{
	int result = 0;
	int sign = 1;//正负号
	int i = 0;
	//处理空格
	while (str[i] == ' ')
	{
		i++;
	}
	//处理正负号
	if (str[i] == '-')
	{
		sign = -1;
		i++;
	}
	else if (str[i] == '+')
	{
		i++;
	}
	//转换数字
	while (str[i] >= '0' && str[i] <= '9')
	{
		result = result * 10 + (str[i] - '0');
		i++;
	}
	return sign * result;
}


//将整数转化为字符串
void reverse(char str[], int length)
{
	int start = 0;//开始下标
	int end = length - 1;
	while (start < end)
	{
		char temp = str[start];
		str[start] = str[end];
		str[end] = temp;
		start++;
		end--;
	}
}

char* my_itoa(int num, char* str, int base)
{
	int i = 0;
	int is_negative = 0;
	//处理负数
	if (num < 0 && base == 10)//base=10表示转化后字符串是10进制字符串
	{
		is_negative = 1;
		num = -num;//将负数转化为正数
	}
	//转化为字符串
	while (num != 0)
	{
		int rem = num % base;
		str[i++] = rem + '0';
		num = num / base;
	}
	//处理负号
	if (is_negative)
	{
		str[i++] = '-';
	}
	str[i] = '\0';//添加字符串结束符
	reverse(str, i);
	return str;
}

int main(void)
{
	int num = 4567;
	char buffer[20];
	my_itoa(num, buffer, 10);

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

	return 0;
}



/* 自己实现一个memmove函数 */

int main(void)
{
    char dest[] = "oldstring";
	const char src[] = "HELLOWORLD";
	
	printf("Before memmove dest = %s, src= %s\n", dest, src);
	memmove(dest, src, 5);
	printf("After memmove dest = %s, src= %s\n", dest, src);
	return 0;
}

int main()
{
	int arr[100] = { 0 };
	
	int a = sizeof(arr);
	arr[2] = 25;
	printf("%d\n", arr[2]);
	return 0;
}