二分查找和冒泡排序

多个字符从两端移动，向中间汇集

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
多个字符从两端移动，向中间汇集
********************
w******************!
we****************t!
wel**************it!
welc************bit!
welco********** bit!
welcom********o bit!
welcome******to bit!
welcome **** to bit！
welcome c**e to bit！
welcome come to bit！
//int main()
//{
//
//	//先列出最开始和最后的结果
//	 char arr1[] = "welcome come to bit!";
//	 char arr2[] = "********************";
//	int left = 0;
//	int right = strlen(arr1) - 1;
//	printf("%s\n", arr2);
//	while (left <= right)
//	{
//		Sleep(1000);
//		arr2[left] = arr1[left];
//		arr2[right] = arr1[right];
//		left++;
//		right--;
//		printf("%s\n", arr2);
//	}
//return 0;
//}

二分查找

//二分查找
int main()
{

	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int left = 0;
	int right = sizeof(arr) / sizeof(arr[0]) - 1;
	int key = 7;
	int mid = 0;
	int find = 0;
	while (left <= right)
	{
		mid = (left + right) / 2;
		if (arr[mid] > key)
		{
			right = mid - 1;
		}
		else if (arr[mid] < key)
		
			{
				left = mid - 1;
			}
		else
		{
			find = 1;
			break;
		}
	}
	if (1 == find)
	{
		printf("找到了，下标是%d\n",mid);
	}
	else
		printf("找不到了");
	return 0;
}

冒泡排序

冒泡排序就是一种排序算法，本质就是通过比较2个相邻元素的大小，把较大的元素逐渐交换到数组的最末尾。

1.从数组的第一个元素开始，与相邻元素比较

2.前一个元素大于第二个元素，将2个元素进行交换

3.进行第二步的2个元素（此时第二个数是较大的数），用第二个元素和第三个元素比较，重复执行第二步

3 1 7 5 8 9 0 2 4 6

1 3 7 5 8 9 0 2 4 6

1 3 7 5 8 9 0 2 4 6

1 3 5 7 8 9 0 2 4 6

1 3 5 7 8 9 0 2 4 6

1 3 5 7 8 9 0 2 4 6

 1 3 5 7 8 0 9 2 4 6

1 3 5 7 8 0 2 9 4 6

1 3 5 7 8 0 2 4 9 6

//冒泡排序

void bubble_sort(int arr[], int sz)
{
	int i = 0;
	
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 0;
		int j = 0;
		for (j = 0; j < sz - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	if (flag == 1)
		break;
     }
}

int main()
{

	int arr[] = { 3,1,7,5,8,9,0,2,4,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}