几种运算方法（辗转相除，二分，冒泡）

一.辗转相除法

         辗转相除法， 又名欧几里德算法（Euclidean algorithm），是求最大公约数的一种方法。 它的具体做法是：用较大数除以较小数，再用出现的余数(第一余数)去除除数，再用出现的余数（第二余数)去除第一余数，如此反复，直到最后余数是0为止。(以上是百度给出的定义)                      

         定义往往比较晦涩难懂，因此我们用实例来说明他到底说明了什么。下面是示例代码:

int main()
{
 int a = 120,b = 64,t = 1;
 while(t != 0)    //120 % 64 = 56-> 64 % 56 = 8-> 56 % 8 = 0->退出循环，输出a。
 {
  t = a % b;      //将两个值的公约数转换为余数的公约数
  a = b;          //我们设公约数为m，a/m = 0,b/m = 0,因此a%b/m = 0(a>b)
  b = t;          //如果实在不能理解，在编译器中调试一下就一目了然了
 }
 printf("%d",a);
 return 0;
}

         由于如果m是a和b的公约数，那么a，b都能被m整除，设a为m的x倍，b为m的y倍，那么a=xm，b=ym，因为x，y都为整数，所以x%y也为整数，因此a%b=(x%y)m，设x%y=t,那么t，a，b就拥有了同一个公约数，a与b的公约数就转换为了b与t的公约数，循环往复就得到t=56%8，此时余数为0，我们就可以输出被除数8了，此时a=8，我们就可以把a打印出来。

二.二分查找法

        二分查找法（Binary Search）算法，也叫折半查找算法。 二分查找针对的是一个有序的数据集合，查找思想有点类似于分治思想。 每次都通过跟区间的中间元素对比，将带查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为0。

        同样我们通过代码来理解，如下:

int main()
{
	int a = 7;
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };  //切记二分查找必须是有序的数列
	int left = 0;           //我们想在arr数组中找出7这个元素，并将下标输出
	int right = sizeof(arr) / sizeof(arr[0])-1;
	int mid = 0;           //我们先设两个值作为数组的左右下标，求中间值mid
	int flag = 0;               //这里设置一个标志，来判断能否找出这个元素
	while (left <= right)
	{
		mid = (left + right) / 2;
		if (arr[mid] < a)
		{
			left = mid;    
			left++;      //此处的right--和left++是防止两者差值为1时的死循环
		}
		else if (arr[mid] > a)
		{
			right = mid;
			right--;            //由于mid不可能为目标元素，(left+right)/2=left,因此成立
		}
		else
		{
			flag++;             //如果经过这个说明存在，flag变为1，将不会进入下面的if语句
			printf("下标为:%d\n", mid);
			break;
		}
	}
		if (flag == 0)
		{
			printf("找不到对应的元素\n");
		}
	return 0;
}

        当有1.5到1.9的一排女生从高到底按升高排成一排，要在其中找到身高1.7的女生，我们的习惯是不是先从中间开始找再依次排查？二分法也是一样的，当我们取中间时，如果中间的值不是我们想要的值，我们就比较中间的数和我们想找的元素谁大谁小，如果中间的元素大，我们在左半部分找，反之我们在右半部分找，一直循环这个步骤直到找出这个值，或者全部找完都没有时退出。(注意：二分查找只有在升序或者降序的情况下能使用)过程如下:

 

三.冒泡排序

        冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的 排序算法 。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。 走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

        冒泡排序之所以称之为冒泡排序，其实它完成排序的方式就像气泡一样，把大的数字浮上来把小的数字沉下去，反之亦然。

int main()
{
    int arr[10] = { 0,2,3,5,4,9,6,8,7,1};
    int sz = sizeof(arr) / sizeof(arr[0]);  //求出数组长度
    int tmp = 0;
    for (int i = 0; i < sz - 1; i++)   //想要实现排序最少执行sz-1次
    {
        int flag = 1;                  //标记函数是否进入下面的循环
        for (int j = 0; j < sz - i - 1; j++)  //这里进行了一次“冒泡”，即两位交换
        {                                     //每一位排序完毕后都可以减少一次比较
            if (arr[j] > arr[j + 1])
            {
                flag = 0;
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
        if (flag == 1)      //如果没有进入上面的循环，说明已经有序，不需要排了，退出。
        {
            break;
        }
    }
    for (int i = 0; i < 10; i++)
    {
        printf("%d", arr[i]);
    }
    return 0;
}

        冒泡排序其实就是将数组中相邻两个元素进行比较，从下标为0处开始，如果前面的大于后面的，那么就交换他们的位置，最后就可以将最大的放到末尾，以此类推，过程如下:

其中被红色涂满的格子代表进行比较并交换的两个元素，我这里吧它叫做“冒泡”一次。

       而冒泡排序法就是多次执行“冒泡”这一动作，从而达成整个数组的排序，不过如果只是多次“冒泡”的话，当数组已经排序完毕时，它仍然会傻不愣登的一个一个比较，因此上面的代码中，我用了一个flag来标记，用来确认函数是否已经排序完毕（如果数组已经排序完毕，那么将不会执行交换，flag也就不等于0，退出循环），如果排序完毕则直接跳出循环，不浪费多余的时间做没有意义的排序，这也算对冒泡排序的一种优化吧。

       好的，我们今天的内容到这里就结束了，我是LoveHutao，感谢大家的观看！