基于C语言的算法总结(不定时更新)

这篇博客我准备写一些我见过的算法，虽然现在我见过的还很少，但我相信会越来越多，方便日后自己查阅

好了 开始了

求解最大子序列和的最有效的算法

 1 int MaxSubsequenceSum(const int A[], int N)
 2 {
 3   int ThisSum, MaxSum, j;
 4   // 定义本次循环的和 与 最大和 为0
 5   ThisSum = MaxSum = 0;
 6   // 循环求和
 7   for (j = 0; j < N; j++)
 8   {
 9        ThisSum += A[j];
10        // 判断本次的和与最大和的大小，如果本次和比最大和大，把本次和的值赋值给最大和
11        if (ThisSum > MaxSum)
12         MaxSum = ThisSum;
13        /* 如果本次和小于0，将本次和赋值为0 因为加到小于0了肯定不是最大子序列和了
14         将其赋值为0 从新进行最大子序列和的比较 */
15        else if ( ThisSum < 0)
16        ThisSum = 0;
17   }
18       return MaxSum;
19 }
20 // 这个算法只循环了一次数组就求出了最大子序列和

已知排序好的数组，求某个值的下标---->对分查找

 1 int BinarySearch( const int A[], int X, int N)
 2 {
 3     // 定义最小坐标，中间坐标，最大坐标
 4     int Low, Mid, High;
 5     Low = 0; High = N - 1;
 6     // 循环条件 最小坐标<=最大坐标
 7     while (Low <= High) {
 8         // 中间坐标算出来
 9         Mid = (Low + High) / 2;
10         // 判断中间坐标对应的值是否小于要找到的值
11         if (A[Mid] < X) {
12             /* 如果小于让最小坐标变成中间坐标 + 1
13             (也就是不用考虑中间坐标前面的数了) */
14             Low = Mid + 1;
15         } else if (A[Mid] > X) {
16             /* 如果大于让最大坐标变成中间坐标 - 1
17              (也就是不用考虑中间坐标后面的数了) */
18             High = Mid - 1;
19         } else {
20             // 循环找到坐标
21             return Mid;  // Found
22         }
23     }
24     return -1;   // Not Found
25 }

计算最大公因数(欧几里德算法)

两个整数的最大公因数(Gcd)是同时整除二者的最大整数 例：Gcd(50, 15) = 5

 1 unsigned int Gcd (unsigned int M, unsigned int N)
 2 {
 3     unsigned int Rem;
 4     while ( N > 0) {
 5         Rem = M % N;
 6         M = N;
 7         N = Rem;
 8     }
 9     return M;
10 }
11 // 算法通过连续计算余数直到余数是0为止，最后的非零余数就是最大公因数

高效率的取幂算法

 1 /*
 2  如果N是偶数，我们有 X的N次方 = X的N/2次方 * X的N/2次方
 3  如果N是奇数，我们有 X的N次方 = X的(N - 1)/2次方 * X的(N - 1)/2次方 * X
 4  */
 5 long int Pow (long int x, int N)
 6 {
 7     if (N == 0) {
 8         return 0;
 9     }
10     if (N == 1) {
11         return x;
12     }
13     if (N % 2 == 0) {
14         return Pow(x*x, N/2);
15     } else {
16         return Pow(x*x, N/2) * x;
17     }
18 }
19 // 此算法运用到了递归

数组排序：冒泡排序

 1 void sortArray(int a[], int len)
 2 {
 3     for (int i = 0; i < len-1; i++) {
 4         /*
 5          每趟排序都会确定一个数，所以需要再循环len-i次，但因为每次都是
 6          相邻的两个数比较，为了a[j + 1]不越界，让j循环到len-i-1时停止
 7          */
 8         for (int j = 0; j < len-i-1; j++) {
 9             int tmp;
10             // 如果条件满足，交换a[j]和a[j+1]两个相邻数的值
11             if (a[j] > a[j+1]) {
12                 tmp = a[j];
13                 a[j] = a[j+1];
14                 a[j+1] = tmp;
15             }
16         }
17     }
18 }

数组排序：选择排序

 1 void selectSort(int a[], int len)
 2 {
 3     // 确定需要排序的次数
 4     for (int i = 0; i < len - 1; i++) {
 5         // 每一次都是拿一个元素与后面其他的元素进行比较，找到最小值
 6         for (int j = i + 1; j < len; j++) {
 7             if (a[i] > a[j]) {
 8                 int tmp = a[i];
 9                 a[i] = a[j];
10                 a[j] = tmp;
11             }
12         }
13     }
14 }

-----------------------------------------------未完待续-----------------------------------------------

提示：1、代码由本人手打如有失误请麻烦提醒下，我将及时改正

2、注释代表个人理解有歧义请指教，谢谢