Wmicheng
Wmicheng

C语言案例(安徽专升本常考)

案例目录

  • 数学类程序
    • 完数（完全数）
    • 求亲密数
    • 水仙花数（阿姆斯特朗数）
    • 求自守数
    • 求勾股数
    • 求三角形面积
    • 最大公约数
    • 小公倍数
    • 一元二次方程求根
    • 素数（质数、哥德巴赫猜想）
    • 猴子吃桃
    • 斐波那契数列（兔子生崽）
    • 回文数
    • 九九乘法表
    • 百钱买百鸡问题
    • 给5位的正整数求…
    • 三个整数顺序输出
    • 求n个数相同数相加
    • 判断输入整数位数
    • 求阶乘：n！
    • 求π
    • 求一个分数序列的前20项之和
    • 球自由落体
    • 判断无重复三位数
    • 评委打分
    • 输入10个数交换首尾输出
    • 求三位数各个数之和
    • 极坐标转直角坐标
    • 温度转换
    • 分段函数
    • 泰勒级数展开式
    • 有穷级数相加
  • 打印图形类程序
    • 打印棱形
    • 杨辉三角
    • 打印回文塔
  • 字符型类程序
    • 删除字符串某字符
    • 单行统计字符个数
    • 多行统计字符个数
    • 将一行电文译成密码
    • 不使用函数连接字符串
    • 不使用函数比较字符串
    • 不使用函数复制字符串
    • 将两字符串中的字符比较并输出
    • 求一个字符串的长度
    • 字符串排序
    • 统计字符串中出现最多次的小写字母
    • 统计字符串是元音（A E I O U）的个数
    • 数字字符串转整数
  • 时间类程序
    • 输入月份号,输出该月的英文月名
    • 输入某年某月某日在本年中是第几天
  • 数组类程序
    • 求一个3 X 3的整形矩阵对角线元素之和
    • 数组的逆置
    • 输出"魔方阵"
    • 矩阵转置
    • 输入6个整数，按对称矩阵排列
    • 鞍点数(马鞍数)
  • 结构体类程序
    • 编写一个函数print
    • 有10个学生输入……
    • 约瑟夫环问题(三种方法)
  • 链表类程序
    • 删除动态链表中指定节点
    • 动态链表插入结点
    • 链表排序
    • 查找删除节点
    • 按年龄删除节点
  • 排序算法程序
    • 冒泡排序（Bubble Sort）
    • 选择排序（Selection Sort）
    • 插入排序
  • 查找算法程序
    • 查找算法 -- 简介
    • 顺序查找
    • 二分查找（折半查找）

数学类程序

完数（完全数）

问题描述

求某一范围内完数的个数。

如果一个数等于它的因子之和，则称该数为“完数”（或“完全数”)。例如，6的因子为1、2、3，而 6=1+2+3，因此6是“完数”。

问题分析

根据完数的定义，解决本题的关键是计算出所选取的整数i（i的取值范围不固定）的因子（因子就是所有可以整除这个数的数），将各因子累加到变量s (记录所有因子之和），若s等于i，则可确认i为完数，反之则不是完数。

算法设计

对于这类求某一范围（由于本题范围不固定，在编程过程中采用键盘输入的方式）内满足条件的数时，一般釆用遍历的方式，对给定范围内的数值一个一个地去判断是否满足条件，这一过程可利用循环来实现。

本题的关键是求出选取数值i的因子，即从1到i-1范围内能整除i的数，看某一个数j是否为i的因子，可利用语句if(i%j==0)进行判断，求某一个数的所有因子，需要在1到i-1范围内进行遍历，同样釆用循环实现。因此，本题从整体上看可利用两层循环来实现。外层循环控制该数的范围2〜n；内层循环j控制除数的范围为1〜i，通过i对j取余，是否等于0，找到该数的各个因子。

注意每次判断下一个选定数之前，必须将变量s的值重新置为0

下面是完整的代码：

#include 
int main()
{
    int i, j, s, n; /*变量i控制选定数范围，j控制除数范围，s记录累加因子之和*/
    printf("请输入所选范围上限：");
    scanf("%d", &n); /* n的值由键盘输入*/
    for (i = 2; i <= n; i++)
    {
        s = 0; /*保证每次循环时s的初值为0*/
        for (j = 1; j < i; j++)
        {
            if (i % j == 0) /*判断j是否为i的因子*/
                s += j;
        }
        if (s == i) /*判断因子这和是否和原数相等*/
            printf("It's a perfect number:%d\n", i);
    }
    return 0;
}

运行结果：

请输入所选范围上限：10000↙︎
 It's a perfect number:6
 It's a perfect number:28
 It's a perfect number:496
 It's a perfect number:8128

求亲密数

问题描述

如果整数A的全部因子（包括1，不包括A本身）之和等于B；且整数B的全部因子（包括1，不包括B本身）之和等于A，则将整数A和B称为亲密数。求3000以内的全部亲密数。

问题分析

根据问题描述，该问题可以转化为：给定整数A，判断A是否有亲密数。

为解决该问题，首先定义变量a，并为其赋初值为某个整数。则按照亲密数定义，要判断a中存放的整数是否有亲密数，只要计算出该整数的全部因子的累加和，并将该累加和存放到另一个变量b中，此时b中存放的也是一个整数。再计算b中存放整数的全部因子的累加和，将该累加和存放到变量n中。

若n等于a则可判定变量a和b中所存放的整数是亲密数。

算法设计

计算数A的各因子的算法：用A依次对i（i的范围可以是1〜A-1、1〜（A/2-1）中之一） 进行模（“%”，在编程过程中一定注意求模符号两边参加运算的数据必须为整数）运算，若模运算结果等于0，则i为A的一个因子加；否则i就不是A的因子。将所求得的因子累到变量B。

接下来求变量B的因子：算法同上，将B的因子之和累加到变量n。根据亲密数的定义判断变量n是否等于变量A(if(n==a))，若相等，则A和B是一对亲密数，反之则不是。

代码：

#include 
int main()
{
    int a, i, b, n;
    printf("There are following friendly--numbers pair smaller than 3000:\n");
    for (a = 1; a < 3000; a++) /*穷举3000以内的全部整数*/
    {
        for (b = 0, i = 1; i <= a / 2; i++) /*计算数a的各因子，各因子之和存放于b*/
            if (!(a % i))
                b += i;
        for (n = 0, i = 1; i <= b / 2; i++) /*计算b的各因子，各因子之和存于n*/
            if (!(b % i))
                n += i;
        if (n == a && a < b)              /*使每对亲密数只输出一次*/
            printf("%4d--%4d    ", a, b); /*若n=a，则a和b是一对亲密数，输出*/
    }

    return 0;
}

运行结果：

There are following friendly--numbers pair smaller than 3000:
 220-- 284  1184--1210  2620--2924

水仙花数（阿姆斯特朗数）

阿姆斯特朗数也就是俗称的水仙花数，是指一个三位数，其各位数字的立方和等于该数本身。例如：153=13+53+33，所以 153 就是一个水仙花数。求出所有的水仙花数。

算法思想

对于阿姆斯特朗数问题，根据水仙花数的定义，需要分离出个位数、十位数和百位数。然后按其性质进行计算并判断，满足条件则打印输出，否则不打印输出。

因此，阿姆斯特朗数问题可以利用循环语句解决。设循环变量为 i，初值为 100，i 从 100 变化到 1000；依次判断条件是否成立，如果成立则输出，否则不输出。

算法思想具体如下：

  • ① 分离出个位数，算术表达式为：j=i%10。
  • ② 分离出十位数，算术表达式为：k=i/10%10。
  • ③ 分离出百位数，算术表达式为：n=i/100。
  • ④ 判断条件是否成立。若是，执行步骤 ⑤；若不是，执行步骤 ⑥。
  • ⑤ 打印输出结果。
  • ⑥ i 自增 1。
  • ⑦ 转到 ① 执行，直到 i 等于 1000。

其判断的条件为：j*j*j+k*k*k+n*n*n==i。

程序代码

#include 
int main()
{
    int i, j, k, n;
    for (i = 100; i < 1000; i++)
    {
        j = i % 10;
        k = i / 10 % 10;
        n = i / 100;
        if (j * j * j + k * k * k + n * n * n == i)
            printf("%5d\n", i);
    }
    return 0;
}

调试运行结果

所有的阿姆斯特朗数，如下所示：

153
  370
  371
  407

求自守数

自守数是指一个数的平方的尾数等于该数自身的自然数。例如：

52 = 25   252 = 625   762 = 5776   93762 = 87909376

算法思想

用原数字的各个位数字单独去乘原数字 得到一个数值，再对其保留位数求模（求模基数为比原数字大的最小的10^n）然后再乘以这个数字所在位的位权 各位就 1 ，十位就10 ，百位就是 100，

然后把所得各数相加，再对其保留位数求模

得数如果和原数字想等 那这个数就是自守数

求100000以内的自守数。

代码：

#include 
int main()
{
	int number,mul,k,a,b;
	for(number=1;number<=100000;number++)//遍历各数 
	{

		for(a=1,mul=number;mul>0;mul/=10) 
			a*=10;//计算保留位数求模基数 
		mul=0;
		b=1;
		for(k=number;k>0;k/=10)//循环求各位数与原数字乘积再求模再乘位权 
		{
			mul=mul+(number*(k%10))%a*b;
			a/=10;//每次循环，求模数，降位 
			b*=10;//每次循环，位权数，升位
		}
		mul%=b;//所得和 再求模 
	if(number==mul) printf("%d ",mul);//满足条件输出 
	}
}

运行结果：

It exists following automorphic nmbers small than 100000:
 0  1  5  6  25  76  376  625  9376  90625

求勾股数

问题描述

求100以内的所有勾股数。

所谓勾股数，是指能够构成直角三角形三条边的三个正整数（a，b，c）。

问题分析

根据“勾股数”定义，所求三角形三边应满足条件 a2 + b2 = c2。可以在所求范围内利用穷举法找出满足条件的数。

算法分析

采用穷举法求解时，最容易想到的一种方法是利用3个循环语句分别控制变最a、b、c的取值范围，第1层控制变量a，取值范围是1〜100。在a值确定的情况下再确定b值，即第2层控制变量b，为了避免结果有重复现象，b的取值范围是a+1〜100。a、b的值已确定，利用穷举法在b+1〜100范围内一个一个的去比较，看当前c值是否满足条件 a2 + b2 = c2，若满足，则输出当前a、b、c的值，否则继续寻找。

伪代码如下：

//...
for(a=l; a<=100; a++)  /*确定a的取值*/
for(b=a+l; b<=100; b++)  /*确定b的取值*/
for(c=b+l; c<=100; c++)  /*确定c的取值*/
if(a*a+b*b==c*c)
printf ("%d\t%d\t%d\n", a, b, c)  /*判断三个变量是否满足勾股数条件*/
//...

但是上述算法的效率比较低，根据 a2 + b2 = c2 这个条件，在a、b值确定的情况下，没必要再利用循环一个一个去寻找c值。若a、b、c是一组勾股数，则 a2 + b2 的平方根一定等于c，c的平方应该等于a、b的平方和，所以可将的平方根赋给c，再判断c的平方是否等于。根据“勾股数”定义将变量定义为整型，a2 + b2 的平方根不一定为整数， 但变量c的类型为整型，将一个实数赋给一个整型变量时，可将实数强制转换为整型（舍弃小数点之后的部分）然后再赋值，这种情况下得到的c的平方与原来的的值肯定不相等，所以可利用这一条件进行判断。

代码：

#include 
#include 
int main()
{
    int a, b, c, count = 0;
    printf("100以内的勾股数有：\n");
    printf("  a     b    c       a     b    c       a     b    c       a     b    c\n");
    /*求100以内勾股数*/
    for (a = 1; a <= 100; a++)
        for (b = a + 1; b <= 100; b++)
        {
            c = (int)sqrt(a * a + b * b);                                                  /*求c值*/
            if (c * c == a * a + b * b && a + b > c && a + c > b && b + c > a && c <= 100) /*判断c的平方是否等于a2+b2*/
            {
                printf("%4d %4d %4d     ", a, b, c);
                count++;
                if (count % 4 == 0) /*每输出4组解就换行*/
                    printf("\n");
            }
        }

    printf("\n");
    return 0;
}

运行结果：

100以内的勾股数有：
   a    b    c        a    b    c        a    b    c        a    b    c
   3    4    5        5   12   13        6    8   10        7   24   25
   8   15   17        9   12   15        9   40   41       10   24   26
  11   60   61       12   16   20       12   35   37       13   84   85
  14   48   50       15   20   25       15   36   39       16   30   34
  16   63   65       18   24   30       18   80   82       20   21   29
  20   48   52       21   28   35       21   72   75       24   32   40
  24   45   51       24   70   74       25   60   65       27   36   45
  28   45   53       28   96  100       30   40   50       30   72   78
  32   60   68       33   44   55       33   56   65       35   84   91
  36   48   60       36   77   85       39   52   65       39   80   89
  40   42   58       40   75   85       42   56   70       45   60   75
  48   55   73       48   64   80       51   68   85       54   72   90
  57   76   95       60   63   87       60   80  100       65   72   97

求三角形面积

三角形三边分别为 a,b,c，三角形的半周长为p，面积为S

存在公式定理如下：
p = a + b + c 2 p=\frac {a+b+c} {2} p=2a+b+c​

S = p ( p − a ) ( p − b ) ( p − c ) S=\sqrt {p(p-a)(p-b)(p-c)} S=p(p−a)(p−b)(p−c) ​

代码如下

#include 
#include 
int main()
{
	int a=3,b=4,c=5;
	double p=0;
	double S=0;

	p = (a+b+c)/2;
	S = sqrt(p*(p-a)*(p-b)*(p-c));

	printf("S:%lf\n",S);

	return 0;
}

最大公约数

问题描述

求任意两个正整数的最大公约数（GCD）。

问题分析

如果有一个自然数a能被自然数b整除，则称a为b的倍数，b为a的约数。几个自然数公有的约数，叫做这几个自然数的公约数。公约数中最大的一个公约数，称为这几个自然数的最大公约数。

算法设计

用穷举法按从小到大（初值为1，最大值为两个整数当中较小的数）的顺序将所有满足条件的公约数列出，输出其中最大的一个

#include 
int main()
{
    int m, n, temp, i;
    printf("Input m & n:");
    scanf("%d%d", &m, &n);
    if (m < n) /*比较大小，使得m中存储大数，n中存储小数*/
    {          /*交换m和n的值*/
        temp = m;
        m = n;
        n = temp;
    }
    for (i = n; i > 0; i--) /*按照从大到小的顺序寻找满足条件的自然数*/
        if (m % i == 0 && n % i == 0)
        { /*输出满足条件的自然数并结束循环*/
            printf("The GCD of %d and %d is: %d\n", m, n, i);
            break;
        }

    return 0;
}

Input m & n:100 125
The GCD of 125 and 100 is: 25

小公倍数

问题描述

求任意两个正整数的最小公倍数（LCM）。

问题分析

如果有一个自然数a能被自然数b整除，则称a为b的倍数，b为a的约数，对于两个整数来说，指该两数共有倍数中最小的一个。计算最小公倍数时，通常会借助最大公约数来辅助计算。

最小公倍数=两数的乘积/最大公约（因）数，解题时要避免和最大公约（因）数问题混淆。

对于最小公倍数的求解，除了利用最大公约数外，还可根据定义进行算法设计。要求任意两个正整数的最小公倍数即，求出一个最小的能同时被两整数整除的自然数。

算法设计

对于输入的两个正整数m和n每次输入的大小顺序可能不同，为了使程序具有一般性，首先对整数所m和n进行大小排序，规定变量m中存储大数、变量n中存储小数。

输入的两个数，大数m是小数n的倍数，那么大数m即为所求的最小公倍数；若大数m不能被小数n整除则需要寻找一个能同时被两数整除的自然数。从大数m开始依次向后递增直到找到第一个能同时被两数整除的数为止，所以循环变量i的初值为寻找第一个能同时被两整数整除的自然数，并将其输出。需要注意的是，在找到第一个满足条件的i值后，循环没必要继续下去，所以用break来结束循环。

代码

#include 
int main()
{
    int m, n, temp, i;
    printf("Input m & n:");
    scanf("%d%d", &m, &n);
    if (m < n) /*比较大小，使得m中存储大数，n中存储小数*/
    {
        temp = m;
        m = n;
        n = temp;
    }
    for (i = m; i > 0; i++) /*从大数开始寻找满足条件的自然数*/
        if (i % m == 0 && i % n == 0)
        { /*输出满足条件的自然数并结束循环*/
            printf("The LCW of %d and %d is: %d\n", m, n, i);
            break;
        }

    return 0;
}

运行结果：

Input m & n:6 24
The LCW of 24 and 6 is: 24

最大公约数&最小公倍数

辗转相除法

#include
int main()   
{ 
   int m, n, a, b, t, c;
   printf("Input:\n");
   scanf("%d%d", &a, &b);
   m=a;   n=b;
   while(b!=0)  /* 余数不为0，继续相除，直到余数为0 */ 
   { c=a%b; a=b;  b=c;}
   printf("最大公约数:%d\n", a);
   printf("最小公倍数:%d\n", m*n/a);
}

辗转相除法（函数调用方式）

#include  
int gcd(int,int); 
int main()
{
    int m, n;
    printf("input:");
    scanf("%d%d", &m, &n); 
    printf("最大公约数：%d最小公倍数：%d\n", gcd(m, n) , m*n/gcd(m, n));
}
int gcd(int m,int n) {
    int r; 
    while(r = m % n) 
    {
        m = n;
        n = r; 
        }
    return n; 
}

一元二次方程求根

求 a x 2 + b x + c = 0 ax^2+bx+c=0 ax2+bx+c=0的根。

分别考虑 d = b 2 − 4 a c d=b^2-4ac d=b2−4ac大于0，等于0和小于0这三种情况。

1.获取a、b、c的值

2.计算 b 2 − 4 a c b^2 - 4ac b2−4ac的结果并给d

3.如果d < 0, 则方程没有实根

4.如果d == 0，则方程有一个实根b/2a

5.如果d > 0, 则方程有两个实根 x = − b ± b 2 − 4 a c 2 a x=\frac{-b\pm\sqrt{b^2-4ac}}{2a} x=2a−b±b2−4ac ​​

x1 = ( - b + sqrt(d)) /2*a;

x2 = ( - b - sqrt(d)) /2*a;

eg： a=1 b=2 c=1 只有一个根：-1

#include 
#include 
int main()
{
    int a, b, c, d;
    double x1, x2,m;
    scanf("%d%d%d", &a, &b, &c);
    d = b*b - 4*a*c;
    m =  - b/(2*a);
    if(d < 0) {
        printf("方程没有实数根");
    }else if(d == 0) {
        printf("方程有一个实根：%f", m);
    }else if(d > 0) {
        x1 = ( - b + sqrt(d)) /2*a;
        x2 = ( - b - sqrt(d)) /2*a;
        printf("%.2f %.2f", x1, x2);
    }
    return 0;
}

素数（质数、哥德巴赫猜想）

问题描述

素数又称质数。所谓素数是指除了 1 和它本身以外，不能被任何整数整除的数，例如17就是素数，因为它不能被 2~16 的任一整数整除。

问题分析

1,判断n是否能被2~n-1整除

输入的数n不能被2~（n-1）整除，说明是素数

输入的数n能被2~（n-1）整除，说明不是素数

2，判断n是否能被2~ n \sqrt n n ​间的整数整除

输入的数n不能被2~ n \sqrt n n ​整除，说明是素数

输入的数n能被2~ n \sqrt n n ​整除，说明不是素数

算法设计

1.素数是指大于1且只能被1和它本身整除的正整数，2是最小素数，素数有无穷个；

2.如果整数x大于2，那么就判断x对2~(x-1)取余是否为0，如果是，肯定不是素数，如果都不是，则为素数；

1）判断素数

#include 
int main()
{
    int n, i, flag = 0;
    printf("输入一个正整数: ");
    scanf("%d",&n);
    for(i=2; i<=n/2; ++i)
    {
        // 符合该条件不是素数
        if(n%i==0)
        {
            flag=1;
            break;
        }
    }
    if (flag==0)
        printf("%d 是素数",n);
    else
        printf("%d 不是素数",n);  
    return 0;
}

2）判断两个数之间的素数

#include 
int main()
{
    int m, i, h = 0, leap;
    for (m = 100; m <= 1000; m++)
    {
        leap = 1;
        for (i = 2; i * i <= m; i++)
            if (m % i == 0)
            {
                leap = 0;
                break;
            }
        if (leap)
        {
            printf(" %d ", m);
        }
    }
    return 0;
}

3）计算一个数是否可为两个素数之和（哥德巴赫猜想）

#include 

int checkPrime(int n);
int main()
{
    int n, a,b, flag = 0;
    printf("输入大于4的偶数: ");
    scanf("%d", &n);
    for(a= 3; a <= n/2; a++) 
    {
        // 检测判断
        b = n - a;
        if (checkPrime(a)&&checkPrime(b)) 
        {
            printf("%d = %d + %d\n", n, a, b); 
        }
    }
    if (flag == 0) 
    printf("%d 不能分解为两个素数。", n);
    return 0;
}
// 判断素数
int checkPrime(int n)
{
    int i, isPrime = 1; 
    for(i = 2; i <= n/2; i++) 
    {
        if(n % i == 0) 
        {
            isPrime = 0;
            break;
        }  
    }
    return isPrime;
}

猴子吃桃

题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，又多吃了一个。第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，只剩下一个桃子了。求第一天共摘了多少。

分析

  1. 10day 1peach
  2. 9 d a y ( d a y 10 + 1 ) × 2 = ( 1 + 1 ) × 2 = 4 9day (day10+1)\times2 = (1+1)\times2=4 9day(day10+1)×2=(1+1)×2=4
  3. 8 d a y ( d a y 9 + 1 ) × 2 = ( 4 + 1 ) × 2 = 10 8day (day9+1)\times2 = (4+1)\times2=10 8day(day9+1)×2=(4+1)×2=10
#include
int main()
{
	int cnt = 1,i;
	for ( i = 0; i < 9; ++i)
	{
		cnt += 1;
		cnt *= 2;
	}
	printf("第一天共摘%d个", cnt);
	return 0;
}

递归法

#include  

int func(int day)
{

    if(day==10)

        return 1;  //终止条件

    else

        return (func(day+1)+1)*2; //依赖关系

} 

int main()

{ 

    printf("第一天有%d个桃子！",func(1));

    return 0;

}

斐波那契数列（兔子生崽）

题目：古典问题（兔子生崽）：有一对兔子，从出生后第3个月起每个月都生一对兔子，
小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？（输出前40个月即可）
（斐波那契数列）

#include
int main()
{
	int cnt,i;
	int cnt1 = 1, cnt2 = 1;
	printf("第1个月：%d\n", cnt1);
	printf("第2个月：%d\n", cnt2);

	for ( i = 3; i < 41; ++i)
	{
		cnt = cnt1 + cnt2;
		printf("第%d个月：%d\n", i, cnt);
		cnt1 = cnt2;
		cnt2 = cnt;
	}
	return 0;
}

回文数

回文数就是它的数字反向排列所得的自然数与它的本身是相等的，比如，若n=12321,则称它是一个回文数。

void main(){
	int num,s,y=0;
	printf("Please input numbers: ");
	scanf("%d", &num);
	s=num;
	while(s>0){
		y=y*10+s%10;
		s=s/10;
	}
	if(y==num){
		printf("%d是一个回文数!\n", num);
	}else{
		printf("%d不是一个回文数!\n", num);
	}
}

求5位整数中，既是质素又是回文数的个数

#include 
int main()
{
    int i,j,ge,shi,qian,wan,flag,count=0;
    for (i = 10000; i <= 99999; i++)
    {//获取每一个5位数，然后得到它的个位，十位，千位，万位
       	        ge = i%10;
		shi = i/10%10;
		qian = i/1000%10;
		wan = i/10000%10;
        flag = 1;
        if ((ge==wan) && (shi==qian))//把满足条件的数据输出
        {//判断是否为质素 
            for (j = 2; j * j < i; j++)
                if (i % j == 0)
                {
                    flag = 0;
                    break;   
                }
            if (flag){
            	printf("%d\t", i);
                count++;
			}  
        }
    }
    printf("总计%d", count);
    printf("\n");
    return 0;
}

九九乘法表

#include 
int main()
{
    int i, j; // i, j控制行或列
    for (i = 1; i <= 9; i++)
    {
        for (j = 1; j <= 9; j++)
            // %2d 控制宽度为两个字符，且右对齐；如果改为 %-2d 则为左对齐
            // \t为tab缩进
            printf("%d*%d=%2d\t", i, j, i * j);
        printf("\n");
    }
    return 0;
}

运行结果：

1*1= 1  1*2= 2  1*3= 3  1*4= 4  1*5= 5  1*6= 6  1*7= 7  1*8= 8  1*9= 9
2*1= 2  2*2= 4  2*3= 6  2*4= 8  2*5=10  2*6=12  2*7=14  2*8=16  2*9=18
3*1= 3  3*2= 6  3*3= 9  3*4=12  3*5=15  3*6=18  3*7=21  3*8=24  3*9=27
4*1= 4  4*2= 8  4*3=12  4*4=16  4*5=20  4*6=24  4*7=28  4*8=32  4*9=36
5*1= 5  5*2=10  5*3=15  5*4=20  5*5=25  5*6=30  5*7=35  5*8=40  5*9=45
6*1= 6  6*2=12  6*3=18  6*4=24  6*5=30  6*6=36  6*7=42  6*8=48  6*9=54
7*1= 7  7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49  7*8=56  7*9=63
8*1= 8  8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64  8*9=72
9*1= 9  9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81

【代码二】输出右上三角形和左上三角形：

#include 
    int main() {
        int i,j;
        for(i=1;i<=9;i++){
            for(j=1;j<=9;j++){
                if(j<i)
                    //打印八个空格，去掉空格就是左上三角形 
                    printf("        ");
                else
                    printf("%d*%d=%2d  ",i,j,i*j);
            }
            printf("\n");  
        }
        return 0;
    }

运行结果：

1*1= 1  1*2= 2  1*3= 3  1*4= 4  1*5= 5  1*6= 6  1*7= 7  1*8= 8  1*9= 9
        2*2= 4  2*3= 6  2*4= 8  2*5=10  2*6=12  2*7=14  2*8=16  2*9=18
                3*3= 9  3*4=12  3*5=15  3*6=18  3*7=21  3*8=24  3*9=27
                        4*4=16  4*5=20  4*6=24  4*7=28  4*8=32  4*9=36
                                5*5=25  5*6=30  5*7=35  5*8=40  5*9=45
                                        6*6=36  6*7=42  6*8=48  6*9=54
                                                7*7=49  7*8=56  7*9=63
                                                        8*8=64  8*9=72
                                                                9*9=81

去掉八个空格后的运行结果：

1*1= 1  1*2= 2  1*3= 3  1*4= 4  1*5= 5  1*6= 6  1*7= 7  1*8= 8  1*9= 9
2*2= 4  2*3= 6  2*4= 8  2*5=10  2*6=12  2*7=14  2*8=16  2*9=18
3*3= 9  3*4=12  3*5=15  3*6=18  3*7=21  3*8=24  3*9=27
4*4=16  4*5=20  4*6=24  4*7=28  4*8=32  4*9=36
5*5=25  5*6=30  5*7=35  5*8=40  5*9=45
6*6=36  6*7=42  6*8=48  6*9=54
7*7=49  7*8=56  7*9=63
8*8=64  8*9=72
9*9=81

【代码三】输出右下和左下三角形：

#include 
    int main(){
        int i,j,n;
        for(i=1;i<=9;i++){
            // 将下面的for循环注释掉，就输出左下三角形
            for(n=1; n<=9-i; n++)
                printf("        ");
    
            for(j=1;j<=i;j++)
                printf("%d*%d=%2d  ",i,j,i*j);
    
            printf("\n");
        }
        return 0;
    }

运行结果：

1*1= 1
                                                        2*1= 2  2*2= 4
                                                3*1= 3  3*2= 6  3*3= 9
                                        4*1= 4  4*2= 8  4*3=12  4*4=16
                                5*1= 5  5*2=10  5*3=15  5*4=20  5*5=25
                        6*1= 6  6*2=12  6*3=18  6*4=24  6*5=30  6*6=36
                7*1= 7  7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49
        8*1= 8  8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64
9*1= 9  9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81

去掉循环后的运行结果：

1*1= 1
2*1= 2  2*2= 4
3*1= 3  3*2= 6  3*3= 9
4*1= 4  4*2= 8  4*3=12  4*4=16
5*1= 5  5*2=10  5*3=15  5*4=20  5*5=25
6*1= 6  6*2=12  6*3=18  6*4=24  6*5=30  6*6=36
7*1= 7  7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49
8*1= 8  8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64
9*1= 9  9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81

百钱买百鸡问题

题目分析

如果用数学的方法解决百钱买百鸡问题，可将该问题抽象成方程式组。设公鸡 x 只，母鸡 y 只，小鸡 z 只，得到以下方程式组：
A： 5 x + 3 y + 1 3 z = 100 5x+3y+\frac {1}{3z} = 100 5x+3y+3z1​=100
B： x + y + z = 100 x+y+z = 100 x+y+z=100
C： 0 ≤ x ≤ 100 0 \le x \le 100 0≤x≤100
D： 0 ≤ y ≤ 100 0 \le y \le 100 0≤y≤100
E： 0 ≤ z ≤ 100 0 \le z \le100 0≤z≤100

用穷举法的方式来解题，需要 10 1 3 101^3 1013 次猜解

#include 
    int main()
    {
        int i, j, k;
        printf("百元买百鸡的问题所有可能的解如下：\n");
        for( i=0; i <= 100; i++ )
            for( j=0; j <= 100; j++ )
                for( k=0; k <= 100; k++ )
                {
                    if( 5*i+3*j+k/3==100 && k%3==0 && i+j+k==100 )
                    {
                        printf("公鸡 %2d 只，母鸡 %2d 只，小鸡 %2d 只\n", i, j, k);
                    }
                }
        return 0;
    }

运行结果：

百元买百鸡的问题所有可能的解如下：
公鸡  0 只，母鸡 25 只，小鸡 75 只
公鸡  4 只，母鸡 18 只，小鸡 78 只
公鸡  8 只，母鸡 11 只，小鸡 81 只
公鸡 12 只，母鸡  4 只，小鸡 84 只

给5位的正整数求…

要求:

  • ①求出它是几位数;
  • ②分别输出每一位数字;
  • ③按逆序输出各位数字，

例如原数为321,应输出123。

①求出它是几位数;

解题思路： 大于10000就是5位，否则大于1000就是四位，否则大于100是三位…

答案：

#include 
int main()
{
	int num;
	printf("enter num:");
	scanf("%d", &num);
	if (num > 99999 || num < 0) {
		printf("请输入0~99999之间的正数\n");
		return -1;
	}
	if (num >= 10000) {
		printf("5\n");
	}else if (num >= 1000) {
		printf("4\n");
	}else if (num >= 100) {
		printf("3\n");
	}else if (num >= 10) {
		printf("2\n");
	}else {
		printf("1\n");
	}
	return 0;
}

②分别输出每一位数字;

解题思路： 99999除以10000则输出9；9999除以1000则输出9，…

答案：

#include 
int main()
{
	int num;
	printf("enter num:");
	scanf("%d", &num);
	if (num > 99999 || num < 0) {
		printf("请输入0~99999之间的数字\n");
		return -1;
	}
	if (num / 10000 > 0) {//取出万位数字
		printf("%d ", num / 10000);
	}
	if (num%10000 >= 1000) {//取余10000则可以取出低四位的数据，除以1000则得到千位的数字
		printf("%d ", (num % 10000) / 1000);
	}
	if (num%1000 >= 100) {//取余1000则可以取出低三位的数据，除以100则得到百位的数字
		printf("%d ", (num % 1000) / 100);
	}
	if (num%100 >= 10) {//取余100则可以取出低两位的数据，除以10则得到十位的数字
		printf("%d ", (num % 100) / 10);
	}
	if (num%10 >= 0) {//取余10则取出个位数字
		printf("%d ", num % 10);
	}
	printf("\n");
	return 0;
}

③按逆序输出各位数字，例如原数为321,应输出123。

解题思路： 思路与第二题相同，只不过将整个过程逆序即可

答案：

#include 
int main()
{
	int num;
	printf("enter num:");
	scanf("%d", &num);
	if (num > 99999 || num < 0) {
		printf("请输入0~99999之间的数字\n");
		return -1;
	}
	if (num % 10 >= 0) {
		printf("%d ", num % 10);
	}
	if (num % 100 >= 10) {
		printf("%d ", (num % 100) / 10);
	}
	if (num % 1000 >= 100) {
		printf("%d ", (num % 1000) / 100);
	}
	if (num % 10000 >= 1000) {
		printf("%d ", (num % 10000) / 1000);
	}
	if (num / 10000 > 0) {
		printf("%d ", num / 10000);
	}
	printf("\n");
	return 0;
}

三个整数顺序输出

输入三个整数，按由小到大的顺序输出

答案：

#include
int main()
{
    int a,b,c,t=0;
    scanf("%d%d%d",&a,&b,&c);
    if(a>b)
      {t=a;a=b;b=t;}

    if(a>c)
      {t=a;a=c;c=t;}  
  
    if(b>c)
      {t=b;b=c;c=t;}
   
    printf("%d %d %d ",a,b,c);
    return 0;

}

输入4个整数，要求按由小到大的顺序输出。

解题思路： 四个数中先找到最小的，剩下的三个数中找到第二小的，剩下的两个数中找到第三小的。

答案：

#include 
int main()
{
	int a, b, c, d;
	int max_num;
	scanf("%d %d %d %d", &a, &b, &c, &d);
	int tmp;
	//找到最小的数
	if (a > b) {
		tmp = a; a = b; b = tmp; // a>b两个数据交换,则给a存储小的b
	}
	if (a > c) {
		tmp = a; a = c; c = tmp;
	}
	if (a > d) {
		tmp = a; a = d; d = tmp;
	}
	//找到第二小的数，不需要和最小的数比较
	if (b > c) {
		tmp = b; b = c; c = tmp;
	}
	if (b > d) {
		tmp = b; b = d; d = tmp;
	}
	//找到第三小的数据，不需要和第一和第二小比较
	if (c > d) {
		tmp = c; c = d; d = tmp;
	}
	printf("%d %d %d %d\n", a, b, c, d);
	return 0;
}

编写一个C程序,运行时输人a,b,c三个值,输出其中值最大者

代码示例：

#include

int main()
{
	int a, b, c, max;
	printf("请输入三个数：\n");

	scanf("%d%d%d", &a, &b, &c);
	if (a > b)
	{
		max = a;
	}
	else
	{
		max = b;
	}

	if (c > max)
	{
		max = c;
	}
	printf("三个数中最大的数为：%d", max);
	return 0;

}

求n个数相同数相加

S n = a + a a + a a a a a + … + a ⏞ n个a 之值，其中 a 是一个数字， n 表示 a 的位数， n 由键盘输入 Sn=a+aa+aaa\overbrace{aa+…+a}^{\text{n个a}}之值，其中a是一个数字，n表示a的位数，n由键盘输入 Sn=a+aa+aaaaa+…+a ​n个a​之值，其中a是一个数字，n表示a的位数，n由键盘输入

答案解析：

该题目可以将数字拆分为 a * 10^n + 前一个数字，例如:

2 = 2 * 10^0 + 0 : 默认2的前一个数字为0，也就是没有任何值

22 = 2 * 10^1 + 2 ： 22的前一个数字为2

222 = 2*10^2 + 22 ：222的前一个数字为22

以此类推…

所以，在每次循环的时候，需要保存下，上一次结果的值，方便下一次计算

还需要使用到C库当中使用的pow函数，来计算某个数的n次方，在该题目当中使用的是10的n次方，n随着循环的次数，以此递增。

代码示例：

#include 
#include 

int main()
{
	//n为a的个数
	int n,i;
	double a, prev_sum = 0.0, total_sum = 0.0;
	printf("请输入a的值以及n的值: ");
	scanf("%lf %d", &a, &n);
	//循环n次求总和
	for (i = 0; i < n; i++)
	{
		prev_sum += a * pow(10, i); 
		total_sum += prev_sum;
	}
	printf("总和为：%lf\n", total_sum);
	return 0;
}

##士兵报数
题目
按从1至6报数,最末一个士兵报的数为5；6人一组剩余5人
按从1至7报数,最末一个士兵报的数为4；7人一组剩余4人
最后再按从1至11报数,末一个士兵报的数为10；11人一组剩余10人

算法
使用穷举算法用循环把各种可能的情况都给走一遍
然后用if条件把满足要求的结果给筛选出来。

#include  
int main()
{
	int n; //士兵数 
	for(n=1;;n++){
		if(n%5==1 && n%6==5 && n%7==4 && n%11==10 ){
			printf("%d",n); 
			break;
		}
	}
return 0;
}

判断输入整数位数

// 输入一个整数 输出是几位数
#include 
int main()
{
    int n, count = 0;
    scanf("%d", &n);
    if (n == 0)
    {
        count = 1;
        printf("%d", count);
    }
    else
    {
        while (n != 0)
        {
            n /= 10;
            count++;
        }
        printf("%d", count);
    }
	return 0; 
}

求阶乘：n！

求 ∑ n = 1 20 n ! ( 即求 1 ! + 2 ! + 3 ! + 4 ! + … + 20 ! ) 。 求\sum\limits_{n=1}^{20}n! (即求1!+2!+3!+4!+…+20!)。 求n=1∑20​n!(即求1!+2!+3!+4!+…+20!)。

求阶乘sum的和

#include
int main()
{
    int i = 0;
    int ret = 1;
    int sum = 0;
    for (i = 1; i <= 10; i++)
    {
        ret *= i;//ret单个阶乘
        sum += ret;//sum=阶乘和
    }
    printf("阶乘和sum = %d\n", sum);
    return 0;
}

求某个数的阶乘

#include
int main()
{
	int a = 0;
	int i = 0;
	scanf("%d", &a);
	int j = a;
	for (i = 1; i < a; i++)
	{
		j = j * i;
	}
	printf("%d", j);
	return 0;
}

求π

π = 2 × 2 2 1 × 3 × 4 2 3 × 5 × … × ( 2 n ) 2 ( 2 n − 1 ) × ( 2 n + 1 ) … π =2\times \frac {2^2}{1\times3}\times\frac{4^2}{3\times5} \times… \times \frac{(2n)^2}{(2n-1) \times(2n+1)} … π=2×1×322​×3×542​×…×(2n−1)×(2n+1)(2n)2​…

#include 
main()
{
    double s, i = 1, p = 2;
    int n;
    scanf("%d", &n);
    while (i <= n)
    {
        s = (4.0 * i * i) / ((2 * i - 1) * (2 * i + 1));
        p *= s;
        i++;
    }
    printf("%lf", p);
}

求一个分数序列的前20项之和

3 2 , 5 3 , 8 5 , 13 8 , 25 13 ， … \frac{3}{2}, \frac{5}{3} , \frac{8}{5} ,\frac{13}{8}, \frac{25}{13} ，… 23​,35​,58​,813​,1325​，…

答案解析：

从题目当中可以看出来，下一个分式当中的分子为上一个分式中分子和分母的和，分母为上一个分式的分子。通过这个规律不难推出下一个分式的分子和分母，需要注意的是，保存分式的结果不能使用到整数，因为有可能会有小数的存在，所以我们需要选用浮点数double

#include  
//定义循环次数
#define COUNT 20

int main()
{
	//定义第一个分式的分子为a, 值为2; 定义分母为b，值为1
	//定义相加的和为sum，初始值为0
        int i;
	double a = 2, b = 1, sum = 0;
	double temp;

	for (i = 0; i < COUNT; i++)
	{
		sum += a / b;
		//记录前一项分子
		temp = a;
		//前一项分子与分母之和为后一项分子
		a = a + b;
		//前一项分子为后一项分母
		b = temp;
	}
	printf("前%d项之和为:sum=%9.7f\n", COUNT, sum);
	return 0;
}

球自由落体

一个球从100m高度自由落下，每次落地后反弹回原高度的一半，再落下，再反弹。求它在第10次落地时共经过多少米,第10次反弹多高

答案解析：

该题目需要循环10次，在每一循环的时候，需要将下落的高度和回弹的高度加起来。需要注意的点，第10次下落不需要在计算回弹的距离了，所以需要特殊处理下。在计算每次高度的时候，会有小数存在，所以需要选用浮点数

代码示例：

#include 

int main()
{
        int i;
	//总高度
	double total_m = 100.0;
	//小球经历的米数
	double total_sum = 0.0;
	for (i = 0; i < 10; i++)
	{
		total_sum += total_m;
		total_m /= 2;
		total_sum += total_m;
	}
	//不需要计算第10次的反弹高度，所以减去
	total_sum -= total_m;
	printf("小球总共经历%lf米, 第10次反弹%lf米\n", total_sum, total_m);
	return 0;
}

判断无重复三位数

#include  
int main()
{
    int a, b, c, count = 0; 
    for(a = 1; a <= 4; a++) 
       for(b = 1; b <= 4; b++) 
    	  for(c = 1; c <= 4; c++) 
           {
            if(a == b||b == c||c == a) 
       	        continue;
            printf("%d%d%d\n", a, b, c);
            count++; 
           }
    printf("count=%d\n", count); 
}

评委打分

#include
void main()
{
	int sum = 0,i;
	double avg,b;
	int a[10];
	int max,min;
 
	for(i=0;i<10;i++)
	{
		scanf("%d",&a[i]);
		if(i==0)//只有第一次赋值max=min=a[0]
		{
			max = a[0];
			min = a[0];
		}
		if(max<a[i])
			max = a[i];
		if(min>a[i])
			min = a[i];
 
		sum = sum+a[i];
	}
	b = sum-max-min;
	avg = b/8.0;
	printf("平均分为：%.2lf\n",avg);//保留两位小数
}

输入10个数交换首尾输出

#include 
int main()
{
    int i, t, n, maxi = 0, mini = 0, a[10];
    n = 10;
    for(i = 0; i < n; i++) 
    {
        scanf("%d", &a[i]); 
        if(a[i] > a[maxi]) 
        maxi = i;
        else if(a[i] < a[mini]) 
        mini = i;
    }
    printf("最大的数是%d，是第%d个数\n", a[maxi], maxi + 1);//增加功能输出最大数
    printf("最小的数是%d，是第%d个数\n", a[mini], mini + 1);//增加功能输出最小数
    //将寻找的最大最小值与开头结束交换
    t = a[0]; 
    a[0] = a[mini]; 
    a[mini] = t;
    t = a[n - 1];
    a[n - 1] = a[maxi];
    a[maxi] = t;
    printf("输出交换以后的数组：\n");
    for(i = 0; i < n; i++) 
    		printf("%d ", a[i]);
    return 0;
}

求三位数各个数之和

1 + 3 + 4 = 8 1+3+4=8 1+3+4=8

#include  
int main()
{
    int n, s;
    printf("请输入一个三位数:"); 
    scanf("%d", &n); 
    s = n/100 + n % 100/10 + n % 10; 
    printf("s=%d\n", s);
}

极坐标转直角坐标

x = r . c o s θ x=r.cos\theta x=r.cosθ

y = r . s i n θ y=r.sin\theta y=r.sinθ

#include  
#include 
#define PI 3.1415926 
int main()
{
    double r, thet, x, y; 
    printf("input:"); 
    scanf("%lf%lf", &r, &thet); 
    x = r*cos(thet*PI/180); 
    y = r*sin(thet*PI/180); 
    printf("x=%f,y=%f\n", x, y);
}

温度转换

C = 5 9 ( f − 32 ) ( 摄氏温度 ) C=\frac {5} {9}(f-32)(摄氏温度) C=95​(f−32)(摄氏温度)

K = 273.16 + 7 ( 绝对温度 ) K=273.16+7(绝对温度) K=273.16+7(绝对温度)

#include  
int main()
{
    double f, c, k; 
    printf("input:"); 
    scanf("%lf", &f); 
    c = 5*(f - 32) /9; 
    k = 273.16 + c; 
    printf("c=%f,k=%f\n", c, k);
}

分段函数

输入x的值，输出y相应的值

y = { x ( x < 1 ) 2 x − 1 ( 1 < = x < 10 ) 3 x − 11 ( x > = 10 ) y= \begin{cases} x & (x<1) \\ 2x−1 & (1<=x<10) \\ 3x−11 & (x>=10) \end{cases} y=⎩ ⎨ ⎧​x2x−13x−11​(x<1)(1<=x<10)(x>=10)​

解题思路： 根据输入的不同x值进行条件判断，不同的条件采用不同的表达式进行计算即可

答案：

#include 
int main()
{
	int x, y;
	scanf("%d", &x);
	if (x < 1) {
		y = x;
	}
	else if (x >= 1 && x < 10) {
		y = 2 * x - 1;
	}
	else {
		y = 3 * x - 11;
	}
	printf("y = %d\n", y);
	return 0;
}

泰勒级数展开式

e x = 1 + x + x 2 2 ! + x 3 3 ! + … + x n n ! … e^x=1+x+\frac{x^2}{2!} +\frac{x^3}{3!} +…+\frac{x^n}{n!} … ex=1+x+2!x2​+3!x3​+…+n!xn​…

#include 
int main()
{
    int n, i;
    double  x, t = 1, s = 1;
    printf("input n,x");
    scanf("%d%f", &n, &x);
    for(i = 1 ; i <= n; i++) 
    {
        t = t*x/i;
        s += t;
    } 
    printf("s=%f\n", s);
    return 0;
}

有穷级数相加

求 ∑ k = 1 100 k + ∑ k = 1 50 k 2 + ∑ k = 1 10 1 k 求\sum\limits_{k=1}^{100}k +\sum\limits_{k=1}^{50}{k}^2 +\sum\limits_{k=1}^{10}{\frac{1}{k}} 求k=1∑100​k+k=1∑50​k2+k=1∑10​k1​

1. 对于 ∑ k = 1 100 k 而言，指的是求从 1 到 100 的和。每个数字为整数，求和也为整数 1. 对于 \sum\limits_{k=1}^{100}k 而言，指的是求从1到100的和。每个数字为整数，求和也为整数 1.对于k=1∑100​k而言，指的是求从1到100的和。每个数字为整数，求和也为整数
2. 对于 ∑ k = 1 50 k 2 而言，指的是求从 1 2 ⋅ 50 2 的和。每个数字为整数，求和也为整数 2. 对于 \sum\limits_{k=1}^{50}{k}^2而言，指的是求从{{1}^{2·50}}^2的和。每个数字为整数，求和也为整数 2.对于k=1∑50​k2而言，指的是求从12⋅502的和。每个数字为整数，求和也为整数
3. 对于 ∑ k = 1 10 1 k 而言，指的是求从 1 1 到 1 10 的和。每个数字不是整数，求和也不是整数 3. 对于 \sum\limits_{k=1}^{10}{\frac{1}{k}} 而言，指的是求从 \frac{1}{1} 到 \frac{1}{10} 的和。每个数字不是整数，求和也不是整数 3.对于k=1∑10​k1​而言，指的是求从11​到101​的和。每个数字不是整数，求和也不是整数

该题目，最大的求和是从从1到100，所以需要一个循环，从1遍历到100。针对第一种情况，则遍历100次停下来。针对第二种情况，则遍历50次的时候停下来，针对第三种情况，则遍历10遍就停下来。

最后，在遍历每一个数字的时候，针对三种不同的情况求和。最后将三种不同请求的和加起来就是总体的和

代码示例：

#include 

int main()
{
        int k;
	double total_sum = 0, sum1 = 0, sum2 = 0, sum3 = 0.0;
	for (k = 1; k <= 100; k++)
	{
		sum1 += k;
		//遍历50次就不在执行情况2
		if (k <= 50)
		{
			sum2 += k * k;
		}
		//遍历10次就不在执行情况3
		if (k <= 10)
		{
			sum3 += 1.0 / k;
		}
	}
	total_sum = sum1 + sum2 + sum3;
	printf("三种情况求和结果为：%lf\n", total_sum);
	return 0;
}

打印图形类程序

打印棱形

*
  ***
 *****
*******
 *****
  ***
   *

#include
int main()
{
    int space, i, j;
    for (i = 0; i < 4; ++i) //上半棱形
    {
        for (space = 3 - i; space > 0; --space) 
            printf(" ");
        for (j = 0; j <= 2 * i; ++j) 
            printf("*");
        printf("\n");
    }
    for (i = 3; i > 0; --i) //下半棱形
    {
        for (space = 4 - i; space > 0; --space) 
            printf(" ");
        for (j = 2 * (i - 1); j >= 0; --j) 
            printf("*");
        printf("\n");
    }  
    return 0;
}

杨辉三角

题目描述

以下的图形：

1
    1    1
    1    2    1
    1    3    3    1
    1    4    6    4    1
    1    5   10   10    5    1
    1    6   15   20   15    6    1
    1    7   21   35   35   21    7    1
    1    8   28   56   70   56   28    8    1
    1    9   36   84  126  126   84   36    9    1

输入
  输入数据包含多个测试实例，每个测试实例的输入只包含一个正整数n（1＜=n＜=30），表示将要输出的杨辉三角的层数。

输出
  对应于每一个输入，请输出相应层数的杨辉三角，每一层的整数之间用一个空格隔开，每一个杨辉三角后面加一个空行。

样例输入

2 3

样例输出

1
    1    1
    1    2    1
    1    3    3    1
    1    4    6    4    1
    1    5   10   10    5    1
    1    6   15   20   15    6    1
    1    7   21   35   35   21    7    1
    1    8   28   56   70   56   28    8    1
    1    9   36   84  126  126   84   36    9    1

【答案解析】

仔细观察杨辉三角可以得到：

第0列和对角线上的数据全部为1，其余位置上的数据为上一行正对数据与上一行正对前一个数据之和。

比如：a[4][2] = a[3][2] + a[3][1]

代码

#include
int main()
{
	int array[10][10],i,j;
	for (i = 0; i < 10;i++)
	{
		for (j = 0; j <= i; j++)
		{
            // 对角线和第0列上全部为1
			if (i == j || 0 == j)
				array[i][j] = 1;
			else
				array[i][j] = array[i - 1][j] + array[i - 1][j - 1];
		}
	}

    // 打印杨慧三角的前10行
	for (i = 0; i < 10; i++)
	{
		for (j = 0; j <= i; j++)
		{
			printf("%5d", array[i][j]);
		}

		printf("\n");
	}
	return 0;
}

打印回文塔

打印如下回文塔

左对齐回文塔>

*
***
*****
*******
*********

#include
int main(){
    int i, j, n;
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= 2*i - 1; j++) {
            printf("*"); 
        }
        printf("\n");
    }
    return 0;
}

右对齐回文塔

*
      ***
    *****
  *******
*********

#include
int main(){
    int i, j, n;
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= 2*(n - i); j++) {
            printf(" ");
        }
        for (j = 1; j <= 2*i - 1; j++) {
            printf("*"); 
        }
        printf("\n");
    }
    return 0;
}

居中对齐回文塔

*
   ***
  *****
 *******
*********

#include
int main(){
    int i, j, n;
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= n - i; j++) {
            printf(" ");
        }
        for (j = 1; j <= 2*i - 1; j++) {
            printf("*"); 
        }
        printf("\n");
    }
    return 0;
}

数字回文塔

1
   121
  12321
 1234321
123454321

#include
int main(){
    int i, j, n;
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= n - i; j++) {
            printf(" ");
        }
        for (j = 1; j <= i; j++) {
            printf("%d",j); 
        }
       for (j = i-1; j >= 1; j--) {
            printf("%d",j); 
        }
        printf("\n");
    }
    return 0;
}

字母回文塔

A
   ABA
  ABCBA
 ABCDCBA
ABCDEDCBA

#include
int main(){
    int i, j, n;
    scanf("%d", &n);
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= n - i; j++) {
            printf(" ");
        }
        for (j = 1; j <= i; j++) {
            printf("%c",j+64); 
        }
       for (j = i-1; j >= 1; j--) {
            printf("%c",j+64); 
        }
        printf("\n");
    }
    return 0;
}

字符型类程序

删除字符串某字符

#include 
int main()
{
    char s[100], *p, *q,del;
    puts("input:");
    gets(s);
    printf("delete char:");
    scanf("%c",&del);
    for (p = s, q = s; *p != '\0'; p++)
        if (*p != del)
            *q++ = *p;
    *q = *p;
    puts(s);
    return 0;
}

单行统计字符个数

输入一行字符,分别统计出其中英文字母、空格、数字和其他字符的个数

答案解析：

该题可以调用getchar函数，从stdin流中读入一个字符，当输入多个字符时，getchar()再执行时就会直接从缓冲区中读取了。等同于getc(stdin)。所以，我们循环调用getchar，直到将标准输入的内容读到换行符\n为止。同时判断，读取到的字符是英文字母、空格、数字或者其他字符，并计数；

代码示例：

#include 

int main()
{
	char c;
	//定义eng_char为英文字母的个数，初始值为0
	//定义space_char为空格字符的个数，初始值为0
	//定义digit_char为数字字符的个数，初始值为0
	//定义other_char为其他字符的个数，初始值为0
	int eng_char = 0, space_char = 0, digit_char = 0, other_char = 0;
	printf("请输入一行字符：");
	while ((c = getchar()) != '\n')
	{
		if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z')
		{
			eng_char++;
		}
		else if (c == ' ')
		{
			space_char++;
		}
		else if (c >= '0' && c <= '9')
		{
			digit_char++;
		}
		else
		{
			other_char++;
		}
	}

	printf("英文字母数量:%d\n空格数量:%d\n数字数量:%d\n其他字符数量:%d\n", eng_char, space_char, digit_char, other_char);
	return 0;

}

多行统计字符个数

有一篇文章，共有3行文字，每行有80个字符。要求分别统计出其中英文大写字母、小写字母、数字、空格以及其他字符的个数

【答案解析】

获取文章中的3行文本，并对每行文本进行以下操作

  1. 定义保存结果变量：upp、low、digit、space、other
  2. 遍历每行文本中的字符
  3. 如果该字符ch：ch >= ‘a’ && ch <=‘z’，则该字符是小写字母，给low++
  4. 如果该字符ch：ch >= ‘A’ && ch <=‘Z’，则该字符是小写字母，给up++
  5. 如果该字符ch：ch >= ‘0’ && ch <=‘9’，则该字符是小写字母，给digit++
  6. 如果该字符ch：ch == ’ '，则该字符是小写字母，给space++
  7. 否则为其他字符，给other++

输入统计结果

【代码实现】

#include 
int main()
{
    int i,upp = 0, low = 0, digit = 0, space = 0, other = 0;
    char text[3][80];
  

    for (i=0; i<3; i++)
    {
        // 获取一行文本
        printf("please input line %d:\n",i+1);
        gets(text[i]);
  
        // 统计该行文本中小写字母、大写字母、数字、空格、其他字符的个数
        for (int j=0; j<80 && text[i][j]!='\0'; j++)
        {
            if (text[i][j]>='A'&& text[i][j]<='Z')   // 大写字母
                upp++;
            else if (text[i][j]>='a' && text[i][j]<='z')  // 小写字母
                low++;
            else if (text[i][j]>='0' && text[i][j]<='9')  // 数字
                digit++;
            else if (text[i][j]==' ')  // 控制
                space++;
            else
                other++;   // 其他字符
        }
     }
  
     printf("\nupper case: %d\n", upp);
     printf("lower case: %d\n", low);
     printf("digit     : %d\n", digit);
     printf("space     : %d\n", space);
     printf("other     : %d\n", other);
   
    return 0;

}

将一行电文译成密码

按下面规律译成密码

A--->Z   a--->z
B--->Y   b--->Y
C--->X   c--->x
……

即第1个字母编程第26个字母，第i个字母编程第(26-i+1)个字母，非字母字符不变，要求编程序将密码译回原文，并输出密码和原文。

【答案解析】

从题目给的实例中可以看到，编码规则非常简单，就是将从前往后数的第i个字母转化为从后往前数的第i个字母。

那解压时直接反过来转换即可：

即’Z’—>‘A’ ‘z’—>‘a’

‘Y’—>‘B’ ‘y’—>‘b’

‘X’—>‘C’ ‘x’—>‘c’
假设如果当前拿到的是小写字母，转换方式如下：

  1. 先用s[i] - 'a’计算出s[i]是26个字母中从前往后数的第几个
  2. 再用26 - (s[i]- ‘a’) - 1 转换为26个字母中从后往前数的第几个
  3. 在2的结果上加上’a’，即转换为对应从后往前的第几个字母

大写字母转换方式与上述相同，将上述每条中的’a’换为‘A’即可。

【代码实现】

#include
int main()
{
	char s[1024] = {0};
	scanf("%s", s);

	int i,len = strlen(s);
	// 转换
	for (i = 0; i < len; ++i)
	{
		// 如果是小写字母(大写字母出来类似)：
		// 1. 先用s[i] - 'a'计算出s[i]是26个字母中从前往后数的第几个
		// 2. 再用26 - (s[i]- 'a') - 1 转换为26个字母中从后往前数的第几个
		// 3. 在2的结果上加上'a'，即转换为对应从后往前的第几个字母
		if (s[i] >= 'a' && s[i] <= 'z')
			s[i] = 'a' + 26 - (s[i]-'a')-1;
		else if (s[i] >= 'A' && s[i] <= 'Z')
			s[i] = 'A' + 26 - (s[i] - 'A')-1;
	}

	printf("%s", s);
	return 0;
}

不使用函数连接字符串

【答案解析】

直接将s2中的字符逐个拷贝到s1的末尾即可，用户需要保证s1中能存的下s2中的字符

  1. 获取s1末尾的位置
  2. 将s2中的字符逐个拷贝到s1中

【代码实现】

1)字符串方式

#include 
main(){
    int i,j; 
    char s1[20]="abcd";
    char s2[20]="1234";
    for(i = 0; s1[i] != '\0'; ++i); /*移动到s1尾*/
    for(j = 0; s2[j] != '\0'; ++j, ++i)
    {
        s1[i] = s2[j];//将s2接到s1末
    }
    s1[i] = '\0';//拼接完成，手动为s1末添上结束标记
    printf("连接后: %s", s1);
	return 0;
}

2）指针方式

#include 

int main()
{
    char str1[20]="abcd", str2[20]="1234", *p = str1,n = 0;
    while (*p++ != '\0');/*移动指针到str1尾*/
    --p;//回退一个单元，以便覆盖str1末的'\0p;//回退一个单元，以便覆盖str1末的'\0'
    while (str2[n] != '\0')
    {
        *p++ = str2[n];//将str2接到str1末
        ++n;
    };
    *p = '\0';//拼接完成，手动为str1末添上结束标记
    printf("结果为:\n%s\n\n",str1);
    return 0;
}

不使用函数比较字符串

写一函数，实现两个字符串的比较。即自己写一个strcmp函数,函数原型为int strcmp(char * p1 ,char * p2); 设p1指向字符串s1, p2指向字符串s2。要求当s1=s2时,返回值为0;若s1≠s2,返回它们二者第1个不同字符的ASCII码差值(如"BOY"与"BAD" ,第2个字母不同,0与A之差为79- 65=14)。如果s1>s2,则输出正值;如果s1 【答案解析】

使用两个指针指向两个字符串首部，逐个往后进行比较，不相等的时候则将数据进行相减，作为返回值。

【代码实现】

#include
#include

int mystrcmp(char *str1, char *str2)
{
	char *ptr1 = str1;
	char *ptr2 = str2;
	int res;
	while (*ptr1 != '\0' && *ptr2 != '\0') {
		if (*ptr1 != *ptr2) {
			res = *ptr1 - *ptr2;
			break;
		}
		ptr1++;
		ptr2++;
	}
	if (*ptr1 == '\0' || *ptr2 == '\0') {//注意一个字符串到达结尾或者两个都到达结尾的情况
		res = *ptr1 - *ptr2;
	}
	return res;
}
int main()
{
	char buf1[1024] = { 0 };
	char buf2[1024] = { 0 };
	while (1) {
		printf("Please enter two strings:\n");
		gets_s(buf1, 1024);
		gets_s(buf2, 1024);
		printf("mystrcmp:%d", mystrcmp(buf1, buf2));
		printf("\n");
	}
	return 0;
}

不使用函数复制字符串

编写一个程序，将字符数组s2中的全部字符复制到字符数组s1中，不用strcpy函数。复制时，‘\0’也要赋值过去。’\0’之后的字符不复制。

【答案解析】

首先必须保证s1能否放的下s2中的字符，然后将s2中的每个字符逐个搬移到s1中即可。

【代码实现】

#include

int main()
{
	char s1[100] = { 0 };
	char s2[50] = { 0 };
	int index1 = 0, index2 = 0;
	printf("请输入字符串s2：");
	scanf("%s", s2);

	printf("将s2拷贝到s1中, s1现在为: ");
  
    // 将s2[index2]位置字符拷贝到s1[index]位置，
    // 然后以s1[index1]的值作为循环条件判断是否拷贝到s2的末尾
	while (s1[index1++] = s2[index2++]);
	printf("%s\n", s1);
	return 0;
}

将两字符串中的字符比较并输出

编写一个程序，将两个字符串s1和s2比较，如果s1 > s2，输出一个整数；若s1 = s2，输出0；若s1 < s2，输出一个负数。不要用strcpy()函数。两个字符串用gets函数读入。输出的正数或负数的绝对值应是相比较的两个字符串相对应字符的ASCII码的差值。例如，“A"和“C”相比，由于"A” < “C”，应输出负数，同时由于‘A’与‘C’的ASCII码差值为2，因此应输出"-2"。同理：“And”和"Aid"相比较，根据第2个字符比较结果，“n"比"i"大5，因此应输出"5”。

【答案解析】

字符串比较规则：从前往后逐个字符进行比较，相等时继续往后，不相等时返回该位置两个字符差值。

【代码实现】

#include 

int main()
{
	int ret = 0;
	int index = 0;
	char s1[100] = { 0 };
	char s2[100] = { 0 };
	printf("请输入s1:");
	gets(s1);

	printf("请输入s2:");
	gets(s2);

    // 将s1和s2中的字符从前往后逐个进行比较，相等继续往后，
    // 不相等时ret中结果不为0，!ret则为0  循环结束
    // 如果一个走到末尾，一个未走到末尾 ret也不为0， !ret为0，循环结束
    // 如果两个字符串相等，同时达到末尾，循环结束
	while (!(ret = s1[index] - s2[index]) && '\0' != s1[index] && '\0' != s2[index])
	{
		++index;
	}

	printf("%d\n", ret);
	return 0;
}

求一个字符串的长度

写一函数,求一个字符串的长度。在main函数中输入字符串,并输出其长度。

解题思路： 字符串以\0作为结尾，则从第一个字符开始向后移动遇到\0认为字符串结束。

答案：

#include 
int mystrlen(char *str)
{
	int len = 0;
	char *ptr = str;
	while (*ptr != '\0') {
		ptr++;
		len++;
	}
	return len;
}
int main()
{
	char buf[1024];
	printf("Please enter a string: ");
	scanf("%s", buf, 1024);
	printf("string len:%d\n", mystrlen(buf));
	return 0;
}

字符串排序

解题思路： 排序方式与数字比较大致相同，先遍历比较找出最大的字符串，与第一个字符串进行交换，然后剩下的进行比较找出最大的字符串与第二个交换…

#include
#include
void sort(char s[10][32])
{
	int i, j;
	for (i = 0; i < 10; i++){
		for (j = i; j < 10; j++){
			if (strcmp(s[i], s[j])> 0){
				char tmp[32];
				strcpy(tmp, 32, s[i]);
				strcpy(s[i], 32, s[j]);
				strcpy(s[j], 32, tmp);
			}
		}
	}
}
int main()
{
	char str[10][32];
	printf("Please enter ten strings:\n");
	for (int i = 0; i < 10; i++){
		scanf("%s", str[i], 32);
	}
	sort(str);
	printf("\n");
	for (int i = 0; i < 10; i++){
		printf("%s\n", str[i]);
	}
	return 0;
}

用指针数组处理

#include
#include

void change(int n, char* strings[]) {
	char* temp;
	int i, j;
	for (i = 0; i < n; i++) {
		for (j = i + 1; j < n; j++) {
			if (strcmp(strings[i], strings[j])>0) {
				temp = strings[i];
				strings[i] = strings[j];
				strings[j] = temp;
			}
		}
	}
}

int main() {
	int n;
	int i;
	char** p;
	char* strings[] = { "C", "C++", "JAVA", "C#", "GO" };
	n = sizeof(strings) / sizeof(strings[0]);
	printf("排序前的数组为：");
	for (i = 0; i < n; i++) {
		printf("%s ", strings[i]);
	}
	printf("\n");
	change(n, strings);
	printf("排序后的数组为：");
	for (i = 0; i < n; i++) {
		printf("%s ", strings[i]);
	}
	printf("\n");
	return 0;
}

统计字符串中出现最多次的小写字母

#include 
main()
{
    char ch, c[20]={0};
    int i, max=0;
    while ((ch = getchar()) != '\n')//输入字符串 
        if (ch >= 'a' && ch <= 'z')
            c[ch - 'a']++;
    for (i = 0; i < 20; i++)//将出现次数最多的下标赋值给max
        if(c[i] > max)
			max = c[i];
    for (i = 0; i < 20; i++)
        if (max == c[i]){
            printf("出现最多的小写字母：%c 总数：%d", 'a' + i,max);
			break;//如果遇到 aaa bbb 则输出第一个出现最多的小写字母 
		}
    return 0;
}

统计字符串是元音（A E I O U）的个数

输入一个字符串，统计字符串是元音（A E I O U）的个数;通过switch-case来实现

#include 
int main()
{
    char str[20];
    int i, n, j = 0;
    printf("请随意输入一段字符串:");
    gets(str);
    for (i = 0; i < 20;  i++)
    {
        switch (str[i])
        {
        case 'a':case 'o':case 'e':case 'i':case 'u':
		case 'A':case 'O':case 'E':case 'I':case 'U':
            j++;
            break;
        }
    }
	printf("元音数是:%d",j);
	return 0;
}

数字字符串转整数

#include     // 把一个数字字符串转换为一个整数。
int main()
{
    char* numStr = "4562";
    int value=0;
    while( *numStr >= '0' && *numStr <= '9' ){ // 逐个把字符串的字符转换为数字。
        value *= 10;
        value += *numStr - '0';
        numStr++;
    }
    printf("%d\n",value); 
    return 0;
}

时间类程序

##判断年龄大小
输入出生日期和目前日期判断年龄大小

#include 
int main()
{  
    int year, year1, month, month1, day, day1, age;
    printf("请输入您的生日:");
    scanf("%d%d%d", &year, &month, &day);
    printf("请输入当前日期:");
    scanf("%d%d%d", &year1, &month1, &day1);
    if(year1 == year) 
    age = 0;
    else
    {
        age = year1 - year;
        if(month1 < month||(month1 == month&&day1 < day)) 
        age = age - 1;
    }
    printf("您的年龄是:%d", age);
}

输入月份号,输出该月的英文月名

编一程序,输入月份号,输出该月的英文月名。例如，输人3,则输出"March" ,要求用指针数组处理。

解题思路： 首先定义字符串指针数字，数组中每一个元素都存放一个字符串指针，每个指针指向不同字符串的位置。则输入月份数字后，根据下标获取对应月份字符串的地址即可

答案：

#include
int main()
{
	int month;
	char* Month[12] = { "January","February","March","April","May","June",
	"July","August","September","October","November","December" };
	while (1) {
		printf("Please enter the month: ");
		scanf("%d", &month);
		if (month < 1 && month>12) {
			printf("Input error, Month should be greater than 0 and less than 12\n");
		}
		printf("%s\n", Month[month - 1]);
	}
	return 0;
}

输入某年某月某日在本年中是第几天

1.首先明确我国的月份和天数之间的关系：

  • 规定1,3,5,7,8,10,12月每月31天
  • 规定4,6,9,11月每月30天
  • 2月特别(如果是闰年29天，如果是平年28天）

2.看清题目要求什么

1)只求给定年份这一年有多少天(例如2021年这一天有多少天）

思路分析：

那么我们可以直接转化为 判断这一年是闰年还是平年 这一问题

题目举例：从屏幕输入一个年份（要求该年份为从1980年后的某一年），并输出该年总共有多少天，如果输入的年份早于或等于 1980年则提示无效的输入。（闰年为366天，平年为365天，能被4整除但不能被100整除的年份或者能被400整除的年份是闰年。）
2)给定一个准确日期 求这一年的这一个月有多少天？

思路分析：

首先开始判断这一年是否是闰年(立flag），主要用 if else if 来判断月份 将2月份单独挑出来判断

3)输入一个日期 ，求这是这一年的第几天？

思路分析：

先来一个判断是否为闰年，因为求第几天肯定有不同的年份，需要不断将每个月的天数加起来(来一个for循环解决），将每月的天数放在一个数组当中，再将2月单独挑出来修改

#include 
main()
{
    struct date
    {
        int y;
        int m;
        int d;
    };
    struct date dt;
    int i, count, mon[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    printf("请输入年 月 日：");
    scanf("%d%d%d", &dt.y, &dt.m, &dt.d);
    count = dt.d;
    for (i = 0; i < dt.m; i++)//累加天数 
    {
        count += mon[i];
    }
    //判断是否为闰年，闰年+1天数；如果是闰年且月份大于2,总天数应该加一天
    if (dt.m > 2 && (dt.y % 4 == 0 && dt.y % 100 != 0 || dt.y % 400 == 0))
    {
        count += 1;
    }
    printf("这一日是这一年的第%d天\n", count);
	return 0;
}

写一个函数days,实现第上面的计算

#include 

struct Date{
	int year;
	int month;
	int day;
};

int Days(struct Date date)
{
	static int Days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

	int i, days = 0;
	for (i = 1; i < date.month; i++)
		days += Days[i];
	days += date.day;
	//如果包含闰年的二月，天数加1
	if (date.month > 2)
	{
		if (date.year % 400 == 0 || (date.year % 4 == 0 && date.year % 100 != 0)){
			++days;
		}
	}
	return days;
}

int main(){
	struct Date date;
	printf("请输入年 月 日: ");
	scanf("%d%d%d", &date.year, &date.month, &date.day);
	int days = Days(date);
	printf("It's day %d in the year.\n", days);
	return 0;
}

数组类程序

求一个3 X 3的整形矩阵对角线元素之和

【答案解析】

矩阵：即二维数组，矩阵行和列相等的二维数组称为方阵。

1 2 3

4 5 6

7 8 9

左上角到右下角对角线上数字：行下标和列下标相等

右上角到左下角对角线上数字：列下标减1 行下标加一

通过两个循环来取到对角线上的元素，并对其求和即可。

【代码实现】

#include
int main()
{
	int i,array[3][3];
	int sumLT2RB = 0;  // 标记左上角到右下角对角线元素之和
	int sumRT2LB = 0;  // 标记右上角到左下角对角线元素之和
	printf("请输入3行3列的矩阵：\n");
	for (i = 0; i < 3; ++i)
	{
		for (int j = 0; j < 3; ++j)
			scanf("%d", &array[i][j]);
	}

	// 左上角到右下角对角线
	for (i = 0; i < 3; ++i)
		sumLT2RB += array[i][i];

	for (i = 0, j = 2; i < 3; ++i, j--)
		sumRT2LB += array[i][j];

	printf("左上角到右下角对角线元素之和: %d\n", sumLT2RB);
	printf("右上角到左下角对角线元素之和: %d\n", sumRT2LB);
	return 0;
}

数组的逆置

将一个数组中的值按逆序重新存放。例如：原来顺序为8,6,5,4,1。要求改为1,4,5,6,8。

【答案解析】

该题为数组的逆置，具体处理方式如下：

如果begin < end时，则循环进行一下操作

  1. 给定两个下标begin和end，begin放在数组起始的位置，end放在数组最后一个元素的位置
  2. 交换begin和end位置的元素
  3. begin往后移动，end往前移动
#include
int main()
{
	int i,array[5] = {8,6,5,4,1};
	int begin = 0, end = 4;

	printf("逆序之前数组为：");
	for (i = 0; i < 5; ++i)
		printf("%d ", array[i]);
	printf("\n");

	// 逆序：begin在数组最左侧，end在数组最右侧
	// 只要begin < end，将begin和end位置元素进行交换
	// 然后begin往后移动一步，end往前移动一步
	while (begin < end)
	{
		int temp = array[begin];
		array[begin] = array[end];
		array[end] = temp;
		begin++;
		end--;
	}

	printf("逆置之后数组为：");
	for (i = 0; i < 5; ++i)
		printf("%d ", array[i]);
	printf("\n");
	return 0;
}

输出"魔方阵"

所谓魔方阵是指这样的方阵，它的每一行、每一列和对角线之和均相等。例如：

8   1   6
3   5   7
4   9   2

要求输出1~ n 2 n^2 n2的自然数构成的魔方阵。

【答案解析】

| 17 | 24 |  1 |  8 | 15 |
--------------------------
| 23 |  5 |  7 | 14 | 16 |
--------------------------
|  4 |  6 | 13 | 20 | 22 |
--------------------------
| 10 | 12 | 19 | 21 |  3 |
--------------------------
| 11 | 18 | 25 |  2 |  9 |

上述矩阵，可以看到以下规律：

魔方阵的生成方法为：在第 0 行中间置 1 ，对从 2 开始的其余 n 2 − 1 个数依次按下列规则存放： 魔方阵的生成方法为：在第0行中间置1，对从2开始的其余n^2-1个数依次按下列规则存放： 魔方阵的生成方法为：在第0行中间置1，对从2开始的其余n2−1个数依次按下列规则存放：

  1. 将1放在第1行的中间一列。
  2. 从2开始直到n*n止，各数依次按此规律存放：每一个数存放的行比前一个数的行数减1，列数加1。
  3. 如果上一行的行数为1，则下一个数的行数为n(指最下一行）。
  4. 当上一个数的列数为n时，下一个数的列数应该为1。
  5. 如果按上面规律确定的位置有数，或者上一个数是第1行第n列时，则把下一个数放在上一个数的下面。

【代码实现】

#include 
int main()
{
	int a[15][15], n, i, j, k;
	while (1)
	{
		printf("请输入n(1~15):");
		scanf("%d", &n);
		if (n != 0 && n <= 15 && n % 2 != 0)
			break;
		else
		{
			printf("请输入奇数\n");
		}
	}

	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= n; j++)
			a[i][j] = 0;
	}

	j = n / 2 + 1;
	a[1][j] = 1;
	i = 1;
	for (k = 2; k <= n*n; k++)
	{
		i -= 1;
		j += 1;

		if (i<1 && j>n)
		{
			i += 2;
			j -= 1;
		}
		else if (i<1)
		{
			i = n;
		}
		else if (j>n)
		{
			j = 1;
		}

		if (a[i][j] == 0)
		{
			a[i][j] = k;
		}
		else
		{
			i += 2;
			j -= 1;

			a[i][j] = k;
		}
	}

	for (i = 1; i <= n; i++)
	{
		for (j = 1; j <= n; j++)
			printf("%5d", a[i][j]);

		printf("\n");
	}

	return 0;
}

矩阵转置

【答案解析】

进行数组的行列互换，其关键在于数组互换的表达式 ar[i] [j] = ar[j] [i];其次在循环的时候，内层循环不能到达最大列，需要根据此时是第几行的交换来决定循环的次数，否则有可能数组行列交换之后最后又交换回原来的形状了。

Example Input
2 3
1 2 3
4 5 6
Example Output
1 4
2 5
3 6

【代码实现】

#include

int main(){
	int n,m,i,j;
	printf("Example Input\n");
	scanf("%d %d",&n,&m);
	int num[n][m];
	int num1[m][n];
	for(i=0;i<n;i++){
		for(j=0;j<m;j++){
			scanf("%d",&num[i][j]);		//输入
		}
	}
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			num1[i][j]=num[j][i];		//转换
		}
	}
	printf("Example Output\n");
	for(i=0;i<m;i++){
		for(j=0;j<n;j++){
			printf("%d ",num1[i][j]);		//输出
		}
		printf("\n"); 
	}
	return 0;
}

输入6个整数，按对称矩阵排列

#include 
int main()
{
    int n,i,j,k,a[6] = {};
    printf("请输入6个整数\n");
    for ( n = 0; n < 6; n++)
    {
       scanf("%d",&a[n]);
    }
    for (i = 0; i < 6; i++) 
    {                                                                //结果
        for (k = 6 - i; k < 6; k++) //i=0 a[k]=0 a[j]=1 2 3 4 5 6    1 2 3 4 5 6
            printf("%d ", a[k]);    //i=1 a[k]=6 a[j]=1 2 3 4 5      6 1 2 3 4 5
        for (j = 0; j < 6 - i; j++) //i=2 a[k]=5 6 a[j]= 1 2 3 4     5 6 1 2 3 4
            printf("%d ", a[j]);    //            ……                 4 5 6 1 2 3
        printf("\n");               //            ……                 3 4 5 6 1 2
    }                               //i=5 a[k]=2 3 4 5 6 a[j]= 1     2 3 4 5 6 1
    return 0;
}

鞍点数(马鞍数)

请编程找出一个M*N矩阵中的鞍点，即该位置上的元素是该行上的最大值，是该列上的最小值。如果矩阵中没有鞍点，则输出“没有鞍点！”

#include
#define M 3
#define N 3
int main()
{
    int m, n;
    printf("输入行数和列数：");
    scanf("%d %d", &m, &n);
    int i, j, max, maxj, k, flag = 0;
    int a[M][N] = { 0 };
    printf("请输入数组:");
    for (i = 0; i < m; i++) 
    {
        for (j = 0; j < n; j++) 
        scanf("%d", &a[i][j]);
    }
    printf("\n");
    for (i = 0; i < m; i++) 
    {
        max = a[i][0];
        maxj = 0;
        for (j = 0; j < n; j++) 
        {
            if (a[i][j] > max) 
            {
                max = a[i][j];
                maxj = j;
            }
        }
        flag = 1;
        for (k = 0; k < m; k++) 
        {
            if (max > a[k][maxj]) 
            flag = 0;
            continue;
        }
        if (flag) 
        {
            printf("存在鞍点a[%d][%d]=%d", i, maxj, max);
            break;
        }
    }
    if (!flag) 
    printf("没有鞍点");
    printf("\n");
    return 0;
}

结构体类程序

编写一个函数print

编写一个函数print,打印一个学生的成绩数组，该数组中有5个学生的数据记录，每个记录包括num,name,score[3],用主函数输人这些记录,用print函数输出这些记录。

#include 

#define NAMLEN 20
//定义一个student结构体数组，包含5个元素
struct student_t{
	int num;
	char name[NAMLEN];
	int score[3];
} students[5];

void print(struct student_t *stu);

int main(){
        int i;
	for (i = 0; i < 5; i++){
		scanf("%d%s%d%d%d", &students[i].num, students[i].name, &students[i].score[0],
			&students[i].score[1], &students[i].score[2]);
	}
	print(students);
	return 0;
}

void print(struct student_t *stu){
        int i;
	for (i = 0; i < 5; i++){
		printf("%d %s %d %d %d\n", students[i].num, students[i].name, students[i].score[0],
			students[i].score[1], students[i].score[2]);
	}
}

有10个学生输入……

有10个学生,每个学生的数据包括学号、姓名、3门课程的成绩,从键盘输人10个学生数据,要求输出3门课程总平均成绩,以及最高分的学生的数据(包括学号、姓名、3门课程成绩、平均分数)。

#include 

#define NAMLEN 20
#define STUCNT 10

typedef struct student_t{
	int num;
	char name[NAMLEN];
	int score[3];
} student;

int main(){
	student students[STUCNT];
	int i,maxi = 0, maxsum = 0;
	double aver_0 = 0, aver_1 = 0, aver_2 = 0;
	for (i = 0; i < STUCNT; i++){
		scanf("%d%s%d%d%d", &students[i].num, students[i].name, &students[i].score[0], &students[i].score[1], &students[i].score[2]);
		int sum = students[i].score[0] + students[i].score[1] + students[i].score[2];
		if (sum > maxsum){
			maxsum = sum;
			maxi = i;
		}
		aver_0 += students[i].score[0];
		aver_1 += students[i].score[1];
		aver_2 += students[i].score[2];
	}
	aver_0 /= STUCNT;
	aver_1 /= STUCNT;
	aver_2 /= STUCNT;
	printf("%lf %lf %lf\n", aver_0, aver_1, aver_2);
	printf("%d %s %d %d %d %lf\n", students[maxi].num, students[maxi].name, students[maxi].score[0], students[maxi].score[1], students[maxi].score[2],
		(students[maxi].score[0] + students[maxi].score[1] + students[maxi].score[2]) / 3.0);
	return 0;
}

约瑟夫环问题(三种方法)

经典问题约瑟夫环：有n个人围成一圈，第一个人从1开始报数，报m的人将被淘汰出圈，下一个人接着从1开始报。如此反复，直到最后留下一个胜利者

【答案解析】

每个人的编号存放在一个数组 a 中，主函数中决定人数的个数以及报数的上限值 m，设计一个函数实现对应的操作。函数的形参有整型数组 a、整数 n 和 m，n 用来接收传递的人数，m 用来接收报数上限，函数的返回值为空；函数体中输出出列人的顺序。

函数中利用循环访问数组中 n 个元素，每次访问元素，设定内循环连续访问 m 个元素，元素访问的下标为 k，访问到第 m 个元素时，如果元素不是 0，此时输出元素 a[k]，再设定 a[k] 为 0，继续访问后面的元素。

主函数中设定数组 a，从键盘输入 n 和 m，利用循环产生 n 的位置序号存放到数组 a 中，调用函数实现相应的操作。

【代码实现】

#include 
#define NUM 13
typedef struct people
{
	int num;
	struct people *next;
} people;

int main()
{
	int count = NUM;
	people p[NUM];
	people *head;
	head = p; //head 指向p[0]
    //1~13编号
	for (int i = 0; i < NUM; i++)
	{
		head->num = i + 1;
		head->next = &p[i + 1];
		head = head->next;
	}
    //最后一个元素指向第一个元素 ， 形成环
	p[NUM - 1].next = p; 

	int i = 1;
	head = p;
	while (count > 1)
	{
        //跳过已经被淘汰的节点
		if (head->num == 0)
		{
			head = head->next;
			continue;
		}
		if (i == 3)
		{
            //被淘汰的节点，num置为0
			printf("第 %d 位置被淘汰\n", head->num);
			head->num = 0;
			count--;
		}
		head = head->next;
		i++;
		if (i > 3)
		{
			i = 1;
		}
	}
	printf("--------------\n");
	while (head->num == 0)
	{
        //非0节点即为最后留下的
		head = head->next;
		if (head->num != 0)
		{
			printf("留到最后的是 %d \n", head->num);
		}
	}

	return 0;
}

数组方式

#include 
#define N 100
int josef(int a[],int n,int m)
{
    int i,j,k=0;
    for(i=0;i<n;i++)
    {
        j=1;
        while(j<m)
        {
            while(a[k]==0)
            k=(k+1)%n;
            j++;
            k=(k+1)%n;
        }
        while(a[k]==0)
        k=(k+1)%n;
        printf("%d ",a[k]);
        a[k]=0;
    }
    return 0;
}

int main()
{
    int a[100];
    int i,j,m,n;
    printf("input n and m：");
    scanf("%d%d",&n,&m);
    for(i=0;i<n;i++)
        a[i]=i+1;
    printf("\n output：\n");
    josef(a,n,m);
    printf("\n");
    return 0;
}

指针方法

#include 
int main()
{
	int people[128], n;
	printf("Please input how many people: ");
	scanf_s("%d", &n);
	for (int i = 0; i < n; i++) {
		people[i] = i + 1; //对每个人顺序排号
	}
	int remain = n;
	int num_off = 0;
	int *p = NULL;
	while (remain > 1) {
		p = people;
		while (p != people + n) { // 每次从第一个位置开始，直到最后一个位置,报数是一直递增的
			if ((*p) != 0) {//若这个位置人还在
				num_off++; //则报数
				if (num_off == 3) {//否则当前的人即将要报的数字是3
					*p = 0;  //则剔除这个人
					num_off = 0; //并且重新开始计数，下边会++，所以是从1开始报数
					remain--;//剩余人数-1
				}
			}
			p++;
		}
	}
	for (int i = 0; i < n; i++) {
		if (people[i] != 0) {
			printf("Serial number of the remaining person:%d\n", people[i]);
		}
	}

	printf("\n");
	system("pause");
	return 0;
}

链表类程序

删除动态链表中指定节点

写一个函数del,用来删除动态链表中指定的节点

解题思路及答案：

首先创建一个带头的单链表，然后让用户输入需要删除的节点，调用del函数，找到需要删除的节点，把待删除节点的前驱和后继重新链接。

#include 
#include 

typedef struct LNode
{
	int num;
	struct LNode *next;
} LNode;

//创建含有n个值的节点
LNode* creat(int n)
{
	LNode *head, *p;
	head = (LNode *)malloc(sizeof(LNode));
	p = head; //头节点为0 加上头节点共n + 1个节点
	head->num = 0;
	head->next = NULL;
	for (int i = 1; i <= n; i++)
	{
		LNode *newNode = (LNode *)malloc(sizeof(LNode));
		newNode->num = i;
		newNode->next = NULL;
		p->next = newNode;
		p = p->next;
	}
	return head;
}

//删除值为n的节点
void del(int n, LNode *head)
{
	LNode *pre, *current;
	pre = head;
	current = head->next;
	//从第一个有效节点开始查找待删除节点
	printf("delete node %d\n", n);
	while (current != NULL)
	{
        //找到待删除节点，重新链接，释放待删除节点
		if (current->num == n)
		{
			pre->next = current->next;
            free(current);
			break;
		}
        //更新查找位置
		pre = current;
		current = current->next;
	}
}

int main()
{
	LNode *head, *p;
	int n;
	head = creat(10);
	printf("请输入需要删除的节点:1-10\n");
	scanf("%d", &n);
	del(n, head);
	int i = 1;
	p = head->next;
	while (p != NULL)
	{
		printf("p %d.num -> %d\n", i, p->num);
		p = p->next;
		i++;
	}
	return 0;
}

动态链表插入结点

写一个函数insert,用来向一个动态链表插入结点

#include 
#include 

typedef struct LNode
{
	int num;
	struct LNode *next;
} LNode;

void insert(int n, LNode *node)
{
	//创建新节点
	LNode *newNode = (LNode *)malloc(sizeof(LNode));
	newNode->num = n;

	LNode* next = node->next;

	// node ---> newNode  ---> next
	newNode->next = next;
	node->next = newNode;
}

LNode* creat(int n)
{
	LNode *head, *p;
	head = (LNode *)malloc(sizeof(LNode));
	p = head; //头节点为0 加上头节点共11个节点
	head->num = 0;
	head->next = NULL;
	for (int i = 1; i <= n; i++)
	{
		LNode *newNode = (LNode *)malloc(sizeof(LNode));
		newNode->num = i;
		newNode->next = NULL;
		p->next = newNode;
		p = p->next;
	}
	return head;
}

void printNode(LNode* head)
{
	LNode* p = head->next;
	while (p != NULL)
	{
		printf("num -> %d\n", p->num);
		p = p->next;
	}
}

int main()
{
	LNode *head;
	int n;
	head = creat(10);
	printNode(head);
	printf("请输入需要插入的节点:\n");
	scanf("%d", &n);
	insert(n, head);
	printf("链表的新内容：\n");
	printNode(head);
	return 0;
}

链表排序

已有a,b两个链表,每个链表中的结点包括学号、成绩。要求把两个链表合并, 按学号升序排列

解题思路及答案：

首先合并两个链表，然后采用选择排序，给合并之后的链表进行排序。

#include 
typedef struct student
{
    int num;
    double grade;
    struct student *next;
} student;

student *merge(student *a, student *b)
{
    //先合并，后排序
    student *head = a;
    while (a->next != NULL)
    {
        a = a->next;
    }
    a->next = b;
	//选择排序，每次选最小的，放在未排序的链表头部
    student *pre;
    pre = head;
    while (pre->next != NULL)
    {
        a = pre->next;
        while (a != NULL)
        {
            if (pre->num > a->num)
            {
                int num = pre->num;
                double grade = pre->grade;
                pre->num = a->num;
                pre->grade = a->grade;
                a->num = num;
                a->grade = grade;
            }
            a = a->next;
        }
        pre = pre->next;
    }
    return head;
}
int main()
{
    student a[3] = {{1, 79}, {4, 36}, {5, 79}};
    for (int i = 0; i < 2; i++)
    {
        a[i].next = &a[i + 1];
    }

    student b[2] = {{2, 38}, {6, 98}};
    for (int i = 0; i < 1; i++)
    {
        b[i].next = &b[i + 1];
    }
    student *combine = merge(a, b);
    while (combine != NULL)
    {
        printf("%d -> %.2lf\n", combine->num, combine->grade);
        combine = combine->next;
    }

    return 0;
}

查找删除节点

有两个链表a和b,设结点中包含学号、姓名。从a链表中删去与b链表中有相同学号的那些结点。

解题思路及答案：

对于b链表中的每一个节点，都从a链表的表头开始查找，如果可以找到，直接删除，如果找不到，继续从a链表表头找下一个b的节点。

#include 
typedef struct student
{
	int num;
	double grade;
	struct student *next;
} student;
student *del(student *a, student *b)
{
	student *pre, *current, *head;
	head = a;

	while (b != NULL)
	{
		//重置指针指向a链表的头部
		pre = head;
		current = head->next;
		//a 链表的头等于b
		if (pre->num == b->num)
		{
			pre->next = NULL;
			pre = current;
			current = current->next;
			//更新表头
			head = pre;
		}
		else
		{
			while (pre->next != NULL)
			{
				if (current->num == b->num)
				{
					//找到就删除
					pre->next = current->next;
					break;
				}
				else
				{
					//否则继续遍历
					pre = pre->next;
					current = current->next;
				}
			}
		}
		b = b->next;
	}
	return head;
}

void printList(student *root)
{
	printf("----\n");
	int i = 0;
	while (root != NULL)
	{
		printf("student %d -> %d -> %.2lf\n", i, root->num, root->grade);
		root = root->next;
		i++;
	}
}

int main()
{
	student a[3] = { { 1, 79 }, { 4, 36 }, { 5, 79 } };
	for (int i = 0; i < 2; i++)
	{
		a[i].next = &a[i + 1];
	}
	a[2].next = NULL;
	printf("链表a:\n");
	printList(&a[0]);

	student b[2] = { { 5, 38 }, { 4, 98 } };
	for (int i = 0; i < 1; i++)
	{
		b[i].next = &b[i + 1];
	}
	b[1].next = NULL;
	printf("链表b:\n");
	printList(&b[0]);
	student *combine = del(a, b);
	printf("删除之后：\n");
	while (combine != NULL)
	{
		printf("%d -> %.2lf\n", combine->num, combine->grade);
		combine = combine->next;
	}

	return 0;
}

按年龄删除节点

建立一个链表,每个结点包括:学号、姓名、性别、年龄。输入一个年龄，如果链表中的结点所包含的年龄等于此年龄,则将此结点删去

#include 
#include 
typedef struct student
{
	int num;
	char sex[10];
	char name[100];
	int age;
	struct student *next;
} student;

void printList(student *root)
{
	printf("----\n");
	while (root != NULL)
	{
		printf("num:%d, sex: %s, name: %s, age: %d\n", root->num, root->sex, root->name, root->age);
		root = root->next;
	}
}

int main()
{
	student a[] = { { 1, "woman", "apple", 12 }, { 4, "woman", "banbana", 36 }, { 5, "man", "candy", 79 }, { 5, "man", "danny", 36 }, { 4, "man", "enjoy", 98 } };
	for (int i = 0; i < 4; i++)
	{
		a[i].next = &a[i + 1];
	}
	a[4].next = NULL;

	printList(&a[0]);

	int n;
	printf("请输入要删除的年龄：\n");
	scanf("%d", &n);
	student *pre = a, *current = a->next, *head;

	head = a;
	while (current != NULL)
	{
		//如果头结点需要删除，则更新头结点
		if (head->age == n)
		{
			pre->next = NULL;
			pre = current;
			current = current->next;
			head = pre;
		}
		else
		{
			//删除节点，重新链接
			if (current->age == n)
			{
				pre->next = current->next;
			}
			pre = current;
			current = current->next;
		}
	}
	printList(head);

	return 0;
}

排序算法程序

1 、排序算法分类

常见排序算法可以分为两大类：

  • 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
  • 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

C语言案例(安徽专升本常考)_第1张图片
2、 算法复杂度

C语言案例(安徽专升本常考)_第2张图片

3、相关概念

  • 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
  • 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
  • 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
  • 空间复杂度：是指算法在计算机

内执行时所需存储空间的度量，它也是数据规模n的函数。

冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

  • 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
  • 针对所有的元素重复以上的步骤，除了最后一个；
  • 重复步骤1~3，直到排序完成。

1.2 动图演示

C语言案例(安徽专升本常考)_第3张图片

1.3 代码实现

//冒泡排序算法
/*第一轮  排序过程
3  2  4  1    （最初）
2  3  4  2    （比较3和2，交换）
2  3  4  1    （比较3和4，不交换）
2  3  1  4    （比较4和1，交换）
第一轮结束，最大的数字 4 已经在最后面，因此第二轮排序只需要对前面三个数进行比较。

第二轮  排序过程
2  3  1  4 （第一轮排序结果）
2  3  1  4 （比较2和3，不交换）
2  1  3  4 （比较3和1，交换）
第二轮结束，次大的数字 3 已经排在倒数第二个位置，所以第三轮只需要比较前两个元素。

第三轮  排序过程
2  1  3  4  （第二轮排序结果）
1  2  3  4  （比较2和1，交换）   
*/
#include 
int main()
{
    int num[10] = {4, 5, 2, 10, 7, 1, 8, 3, 6, 9};
    int i, j, temp;
    //冒泡排序算法：进行 n-1 轮比较
    for (i = 0; i < 10 - 1; i++)
    {
        //每一轮比较前 n-1-i 个，已经排序好的最后 i 个不用比较
        //对拥有 n 个元素的数组 R[n] 进行 n-1 轮比较。
        for (j = 0; j < 10 - 1 - i; j++)
        {
            if (num[j] > num[j + 1])
            {
                temp = num[j];
                num[j] = num[j + 1];
                num[j + 1] = temp;
            }
        }
    }

    //输出排序后的数组
    for (i = 0; i < 10; i++)
    {
        printf("%d ", num[i]);
    }
    printf("\n");

    return 0;
}
//整个数组从小到大排序:1 2 3 4 5 6 7 8 9 10

选择排序（Selection Sort）

选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

  • 初始状态：无序区为R[1…n]，有序区为空；
  • 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
  • n-1趟结束，数组有序化了。

2.2 动图演示

C语言案例(安徽专升本常考)_第4张图片

2.3 代码实现

//选择排序
#include 
int main()
{
    int i, j, min, temp, a[10] = {9, 8, 7, 4, 5, 6, 3, 2, 1, 10};
    for (i = 0; i < 10 - 1; i++)
    {
        min = i;                     //min:当前最小值下标
        for (j = i + 1; j < 10; j++) //扫描余下的部分
            if (a[min] > a[j])       //若有其它元素更小，就记录其下标
                min = j;
        if (min != i)
        { //保若最小值不在排序区首位，就换到首位
            temp = a[min];
            a[min] = a[i];
            a[i] = temp;
        }
    }
    for (i = 0; i < 10; i++) //输出打印排序后的元素
    {
        printf("%d ", a[i]);
    }
    return 0;
}

插入排序

#include 
#define N 10
void insertsort(int a[]) {
    int i, j, x;
    for(i = 1; i < N - 1; i++) {
        x=a[i];
        for (j=i-1;j>=0;j--) {
            if(a[j] > x) 
            	a[j + 1] = a[j];
            else 
            	break;
        }
        a[j + 1] = x;
    } 
}
int main()
{
    int a[N] = {3, 4, 2, 6, 7, 8, 5, 4, 2, 12}, i;
    insertsort(a);
    for(i = 0; i < N; i++) {
        printf("%5d", a[i]);
    } 
}

2.4 算法分析

表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

查找算法程序

查找算法 – 简介

查找（Searching）就是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素。 查找表（Search Table）：由同一类型的数据元素构成的集合 关键字（Key）：数据元素中某个数据项的值，又称为键值 主键（Primary Key）：可唯一的标识某个数据元素或记录的关键字

查找表按照操作方式可分为：

1.静态查找表（Static Search Table）：

只做查找操作的查找表。它的主要操作是：

①查询某个“特定的”数据元素是否在表中

②检索某个“特定的”数据元素和各种属性

2.动态查找表（Dynamic Search Table）：

在查找中同时进行插入或删除等操作：

①查找时插入数据

②查找时删除数据

顺序查找

说明：顺序查找适合于存储结构为顺序存储或链接存储的线性表。

基本思想： 顺序查找也称为线形查找，属于无序查找算法。从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。

复杂度分析：

查找成功时的平均查找长度为：（假设每个数据元素的概率相等） ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;

当查找不成功时，需要n+1次比较，时间复杂度为O(n);

所以，顺序查找的时间复杂度为O(n)。

//顺序查找C语言实现
//基本思路：用顺序结构存储数据（数组、链表），从前到后依次查询目标值，
//            如果发现则返回查找到的值，否则返回0.
#include

int FindBySeq(int *ListSeq, int ListLength, int KeyData);

int main()
{
    int TestData[5] = { 34, 35, 26, 89, 56 };
    int retData = FindBySeq(TestData, 5, 89);
    printf("retData: %d\n", retData);
    return 0;
}

int FindBySeq(int *ListSeq, int ListLength, int KeyData)
{
    int tmp = 0;
    int length = ListLength;
    for (int i = 0; i < ListLength; i++)
    {
        if (ListSeq[i] == KeyData)
            return i;
    }
    return 0;
}

二分查找（折半查找）

说明：元素必须是有序的，如果是无序的则要先进行排序操作。

基本思想：也称为是折半查找，属于有序查找算法。用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，这样递归进行，直到查找到或查找结束发现表中没有这样的结点。

复杂度分析：最坏情况下，关键词比较次数为log2(n+1)，且期望时间复杂度为O(log2n)；

二分查找的执行过程如下

1.从已经排好序的数组或区间中，取出中间位置的元素，将其与我们的目标值进行比较，判断是否相等，如果相等则返回。

2.如果 nums[mid] 和 target 不相等，则对 nums[mid] 和 target 值进行比较大小，通过比较结果决定是从 mid的左半部分还是右半部分继续搜索。

如果 target > nums[mid] 则右半区间继续进行搜索，即 left = mid + 1; 若target < nums[mid] 则在左半区间继续进行搜索，即 right = mid -1；

动图解析

C语言案例(安徽专升本常考)_第5张图片

//二分查找-C语言实现
//基本思路：将排序好的数据存放到数组里（不能是链表）
//        这只前中后标签，与中间元素比，若小于就将后变为原来的中
//        继续计算中，比较，循环，直至等于中，或循环结束。
#include 

binarySearch(int a[], int n, int key){
    int low = 0;
    int high = n - 1;
    while(low<= high){
        int mid = (low + high)/2;
        int midVal = a[mid];
        if(midVal<key)
            low = mid + 1;
        else if(midVal>key)
            high = mid - 1;
        else
            return mid;
    }
    return -1;
}

int main(){
    int i, val, ret;
    int a[8]={-32, 12, 16, 24, 36, 45, 59, 98};
    for(i=0; i<8; i++)
        printf("%d\t", a[i]);

    printf("\n请输人所要查找的元素：");
    scanf("%d",&val);

    ret = binarySearch(a,8,val);

    if(-1 == ret)
        printf("查找失败 \n");
    else
        printf ("查找成功 \n");

    return 0;
}

你可能感兴趣的:(C语言基础笔记案例,c语言,算法,数据结构)

  • 数据结构奇妙旅程之深入解析快速排序 山间漫步人生路 数据结构排序算法算法
    快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
  • 打印出1-100的奇数 。（C语言） 王多鱼001 C语言c语言算法数据结构
    代码：#includeintmain(){for(inti=1;i<101;i++){if(i%2==1){printf("%d,",i);}}return0;}
  • php 把一个数组分成有n个元素的二维数组的算法 风清扬-独孤九剑 phpphp算法
    一、第一种解法0){$columns_map[$position]++;//这个地方格外注意,$position与$columns比较$position=($position<$columns-1)?++$position:0;$array_length--;}foreach($columns_mapas$val){$newarray[]=array_splice($array,0,$val);}
  • llama.cpp 编译安装@Ubuntu skywalk8163 项目实践人工智能llamaubuntulinux人工智能
    在Kylin和Ubuntu编译llama.cpp，具体参考：llama模型c语言推理@FreeBSD-CSDN博客现在代码并编译：gitclonehttps://github.com/ggerganov/llama.cppcdllama.cppmkdirbuildcdbuildcmake..cmake--build.--configRelease#可选安装makeinstall#或可选添加路径ex
  • 【算法分析与设计】去除重复字母 五敷有你 算法分析与设计javajavascript开发语言算法数据结构
    个人主页：五敷有你系列专栏：算法分析与设计⛺️稳中求进，晒太阳题目给你一个字符串s，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）。示例示例1：输入：s="bcabc"输出："abc"示例2：输入：s="cbacdcbc"输出："acdb"思路贪心+单调栈实现【字符串删除一个字符使其字典序最小的贪心策略】：对于两个长度相同的字符串，
  • 用XMLHttpRequest发送和接收JSON数据 潭池先生 jsonXMLHttpRequest前端
    百度的AI回答了一个案例：varxhr=newXMLHttpRequest();varurl="your_endpoint_url";//替换为你的API端点vardata=JSON.stringify({key1:"value1",key2:"value2"});xhr.open("POST",url,true);xhr.setRequestHeader("Content-Type","appl
  • yarn的安装和使用全网最详细教程 zxj19880502 yarnnpm
    一、yarn的简介：Yarn是facebook发布的一款取代npm的包管理工具。二、yarn的特点：速度超快。Yarn缓存了每个下载过的包，所以再次使用时无需重复下载。同时利用并行下载以最大化资源利用率，因此安装速度更快。超级安全。在执行代码之前，Yarn会通过算法校验每个安装包的完整性。超级可靠。使用详细、简洁的锁文件格式和明确的安装算法，Yarn能够保证在不同系统上无差异的工作。三、yarn的
  • 图论记录之最短路迪杰斯特拉 Just right 算法图论java开发语言
    简述思想这个思想能用一句话来概括，精简到的极致:每次找到一个最短距离的点并更新起点到各个点的最短距离如果要可视化的话，B站搜索Dijksra算法，有视频讲解伪代码写到这里，其实是想整一个动画的，这样效果更好点，但由于种种原因所以就拖一下intdijkstr(){dist[1]=0;其余的点的距离全部初始化为真无穷，不要写成int的最大值迭代n次将不在s中的，且距离最近的点给tsj即先到t，再加上t
  • 大创项目推荐 深度学习 opencv python 公式识别(图像识别 机器视觉) laafeer python
    文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
  • OpenCV 如何使用 XML 和 YAML 文件的文件输入和输出 愚梦者 深度学习人工智能计算机视觉c++opencv
    返回：OpenCV系列文章目录（持续更新中......）上一篇：如何利用OpenCV4.9离散傅里叶变换下一篇:目标本文内容主要介绍：如何使用YAML或XML文件打印和读取文件和OpenCV的文本条目？如何对OpenCV数据结构做同样的事情？如何为您的数据结构执行此操作？使用OpenCV数据结构，例如cv::FileStorage,cv::FileNodeorcv::FileNodeIterato
  • 排序算法太多？常用排序都在这了，一篇文章总结和实现所有面试会考的排序算法（基于Python实现） 宇宙之一粟 不归路之Python#IT面试题收集与总结数据结构与算法算法数据结构排序算法pythonjava
    文章目录排序算法1.常见的排序算法1.1选择排序1.1.1思想1.1.2实现**1.1.3选择排序分析**1.2冒泡排序**1.2.1思想****1.2.2实现****1.2.3冒泡排序分析**1.3插入排序**1.3.1思想****1.3.2实现****1.3.3插入排序分析**1.4归并排序☆☆★**1.4.1思想****1.4.2实现****1.4.3归并排序分析**1.5快速排序☆★★**
  • 【数据结构】实验一 实现顺序表各种基本运算的算法 张鱼·小丸子 数据结构实验c++数据结构
    题目：实现顺序表各种基本运算的算法要求：1、建立一个顺序表，输入n个元素并输出；2、查找线性表中的最大元素并输出；3、在线性表的第i个元素前插入一个正整数x；4、删除线性表中的第j个元素；5、将线性表中的元素按升序排列；6、将线性表中的元素就地逆序（只允许用一个暂存单元）；#include#defineSIZE1000usingnamespacestd;typedefstruct{int*a;//
  • python清华大学出版社答案_Python机器学习及实践 weixin_39805119 python清华大学出版社答案
    第1章机器学习的基础知识1.1何谓机器学习1.1.1传感器和海量数据1.1.2机器学习的重要性1.1.3机器学习的表现1.1.4机器学习的主要任务1.1.5选择合适的算法1.1.6机器学习程序的步骤1.2综合分类1.3推荐系统和深度学习1.3.1推荐系统1.3.2深度学习1.4何为Python1.4.1使用Python软件的由来1.4.2为什么使用Python1.4.3Python设计定位1.4.
  • 边缘计算网关在机械制造企业的应用效果和价值-天拓四方 北京天拓四方科技股份有限公司 边缘计算其他物联网
    随着智能制造行业的飞速发展，数据量的激增和实时性要求的提高，传统的数据处理方式已经难以满足生产需求。而边缘计算网关的出现，为智能制造行业带来了革命性的变化。下面，我们将通过一个具体案例展示边缘计算网关在智能制造行业的应用效果和价值。一、案例背景某大型机械制造企业，拥有多条生产线，涉及众多设备和传感器。在生产过程中，企业需要实时监控设备的运行状态，收集生产数据，以便进行生产优化和决策支持。然而，传统
  • Python dict字符串转json对象，小数精度丢失问题 朝如青丝 暮成雪 jsonpython
    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
  • Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java数据结构开发语言
    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
  • C语言pthread互斥锁(mutex)和可重入锁(递归锁recursive)的演示 嫦娥妹妹等等我 开发语言c语言
    实验理论参考:1一旦共享资源被互斥锁锁定,则其余线程想访问共享资源必须等待，直到锁被释放2使用normal属性的互斥锁,一旦发生重入逻辑,则阻塞,成为死锁需要将属性改为recursive成为可重入的,递归的代码功能:1命令行传参1model=1演示异步未上锁之乱序演示count在数据竞态（RaceCondition）下的错误值2命令行传参2model=2演示使用互斥锁后线程的执行顺序演示count
  • C语言演示多线程编程条件下自旋锁和屏障的使用 嫦娥妹妹等等我 开发语言c语言开源
    主线故事:有4个人玩游戏输了,惩罚:1分别使用4台不同的ATM机给我存钱2必须一块一块的存3存完还得在ATM上看一下我的余额设计模式:1每个人使用一条单独的线程,再准备一个计时线程用来输出时间2存钱涉及到对共享资源的读写,是原子操作需要用锁保护这里使用自旋锁3都存完钱后需要等待在各自的ATM上回显余额这里使用屏障技术4如果在主线程中回显对应他们给我打电话告诉我存完了我自己看一下则不需要使用屏障因为
  • Java回溯知识点（含面试大厂题和源码） 一成码农 java面试开发语言
    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
  • 第七章 索引及执行计划，存储引擎 执笔为剑 #MySQL运维篇编辑器mysql
    第七章索引及执行计划，存储引擎1，索引及执行计划1，作用：提供类似书目录的作用，目的是优化查询2，所用的种类（根据算法）B树索引Hash索引R树FulltextGIS3，B树基于不同的查找算法分类介绍B-tree：在范围查询方面提供了更好的性能（>showengines;#存储引擎作用在表上，不同的表可能有不同的存储引擎mysql>select@@default_storage_engine;#查
  • 生日蜡烛（C语言） blue and ACM c语言java算法
    某君从某年开始每年都举办一次生日party，每次吹与年龄相同的蜡烛。现在他共吹了236根蜡烛。请问，他从多少岁开始过生日party的？答案：26#includeintmain(){intage=0;inttotal=0;for(inti=10;i<100;i++){for(intj=i;j<100;j++){total+=j;if(total==236){age=i;break;}}total=0
  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
  • 优化选址问题 | 基于和声搜索算法求解基站选址问题含Matlab源码 天天酷科研 优化选址问题（LP）matlab和声搜索算法基站选址问题
    目录问题代码问题和声搜索算法（HarmonySearch,HS）是一种模拟音乐创作过程中乐师们凭借自己的记忆，通过反复调整各乐器的音调，直至达到最美和声状态为启发，通过反复调整解向量的各分量来寻求全局最优解的智能优化算法。下面是一个基于和声搜索算法求解基站选址问题的Matlab伪代码框架。请注意，这个框架是一个基本的实现，你可能需要根据你的具体问题和约束条件进行调整和优化。代码%和声搜索算法求解基
  • 【1.1 编程基础之输入输出】09. 字符菱形 青少年编程小助手_Python Openjudge题目解析算法青少年编程电子学会等级考试gesp
    09:字符菱形总时间限制:1000ms内存限制:65536kB描述给定一个字符，用它构造一个对角线长5个字符，倾斜放置的菱形。输入输入只有一行，包含一个字符。输出该字符构成的菱形。样例输入*样例输出*************参考程序（1）C语言#includeintmain(){charc;scanf("%c",&c);printf("%c\n",c);printf("%c%c%c\n",c,c,
  • C语言-数据在内存存储 白榆maple c语言开发语言
    目录一、整数在内存中存储1.整数在内存中的存储2.大小端字节序2.为什么有大小端3.大小端判断二、浮点数在内存中的存储1.V=(−1)^s∗M*2^EIEEE754规定：2.浮点数存的过程3.浮点数取的过程E不全为0或不全为1E全为0E全为1题⽬解析一、整数在内存中存储1.整数在内存中的存储在内存中存储的数据是二进制，整数的2进制表示方法有三种，即原码、反码和补码有符号的整数，三种表示方法均有符号
  • 动态多态的注意事项 Austin_1024 动态多态静态多态虚函数子类重写父类虚函数实现动态多态
    大家好：衷心希望各位点赞。您的问题请留在评论区，我会及时回答。多态的基本概念多态是C++面向对象三大特性之一（多态、继承、封装）多态分为两类：静态多态：函数重载和运算符重载属于静态多态，复用函数名。动态多态：通过派生类和虚函数实现运行时多态。静态多态和动态多态的区别：静态多态的函数地址早绑定——编译阶段确定函数地址。动态多态的函数地址晚绑定——运行阶段确定函数地址。下面通过案例讲解多态：#incl
  • 山东省大数据局副局长禹金涛一行莅临聚合数据走访调研 聚合数据 API大数据人工智能API
    3月19日，山东省大数据局党组成员、副局长禹金涛莅临聚合数据展开考察调研。山东省大数据局数据应用管理与安全处处长杨峰，副处长都海明参加调研，苏州市大数据局副局长汤晶陪同。聚合数据董事长左磊等人接待来访。调研组一行参观了聚合数据展厅，了解了聚合数据的发展历程、数据产品、应用案例、奖项荣誉等情况。并就企业在数据处理和应用方面取得的成绩进行了深入交流。作为最早一批进入大数据行业的企业，聚合数据深耕行业十
  • 【循环神经网络rnn】一篇文章讲透 CX330的烟花 rnn人工智能深度学习算法python机器学习数据结构
    目录引言二、RNN的基本原理代码事例三、RNN的优化方法1长短期记忆网络（LSTM）2门控循环单元（GRU）四、更多优化方法1选择合适的RNN结构2使用并行化技术3优化超参数4使用梯度裁剪5使用混合精度训练6利用分布式训练7使用预训练模型五、RNN的应用场景1自然语言处理2语音识别3时间序列预测六、RNN的未来发展七、结论引言众所周知，CNN与循环神经网络（RNN）或生成对抗网络（GAN）等算法结
  • C/C++中的Static关键字 SuhyOvO C语言C++c语言c++
    Static关键字在C和C++编程中是不可或缺的一部分，它用于定义具有持久存储期的变量和函数，以及类的静态成员。虽然它的使用相对直接，但不恰当的使用可能会导致难以调试的错误和混淆。本文将探讨static关键字的概念、作用以及在C和C++中的具体应用。文章目录第一部分：深入理解Static关键字定义和基本概念在C和C++中static的基本作用第二部分：Static在C语言中的使用静态全局变量静态局
  • 企业案例库 康森爱学习
    目前进度：福州提交了“坤兴海洋”案例内容，已经整理出本案例对外版本（初稿），对内版本是在对外版本基础上，新增推动经验，目前还未整理。漳州分会的案例还未提交，夏艳同意整理。厦门分会案例还未整理，倾向“仁铭创投”遇到问题：下属分会对案例库的兴趣不大，没有直接收益，怎么让下属分会有动力去推动案例库建设。案例来源于下属分会，他们的态度很关键。两条思路：第一，把入选案例库作为一种荣誉，反馈给企业，以此给分会
  • Java开发中，spring mvc 的线程怎么调用？ 小麦麦子 springmvc
    今天逛知乎，看到最近很多人都在问spring mvc 的线程http://www.maiziedu.com/course/java/ 的启动问题，觉得挺有意思的，那哥们儿问的也听仔细，下面的回答也很详尽，分享出来，希望遇对遇到类似问题的Java开发程序猿有所帮助。 问题：     在用spring mvc架构的网站上，设一线程在虚拟机启动时运行，线程里有一全局
  • maven依赖范围 bitcarter maven
    1.test 测试的时候才会依赖，编译和打包不依赖，如junit不被打包 2.compile 只有编译和打包时才会依赖 3.provided 编译和测试的时候依赖，打包不依赖，如：tomcat的一些公用jar包 4.runtime 运行时依赖，编译不依赖 5.默认compile 依赖范围compile是支持传递的，test不支持传递 1.传递的意思是项目A，引用
  • Jaxb org.xml.sax.saxparseexception : premature end of file darrenzhu xmlprematureJAXB
    如果在使用JAXB把xml文件unmarshal成vo(XSD自动生成的vo)时碰到如下错误： org.xml.sax.saxparseexception : premature end of file 很有可能时你直接读取文件为inputstream，然后将inputstream作为构建unmarshal需要的source参数。InputSource inputSource = new In
  • CSS Specificity 周凡杨 html权重Specificitycss
      有时候对于页面元素设置了样式，可为什么页面的显示没有匹配上呢？ because specificity CSS 的选择符是有权重的，当不同的选择符的样式设置有冲突时，浏览器会采用权重高的选择符设置的样式。     规则：   HTML标签的权重是1 Class 的权重是10 Id 的权重是100
  • java与servlet g21121 servlet
    servlet 搞java web开发的人一定不会陌生，而且大家还会时常用到它。 下面是java官方网站上对servlet的介绍： java官网对于servlet的解释 写道 Java Servlet Technology Overview Servlets are the Java platform technology of choice for extending and enha
  • eclipse中安装maven插件 510888780 eclipsemaven
    1.首先去官网下载 Maven： http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-3.2.3-bin.tar.gz 下载完成之后将其解压， 我将解压后的文件夹：apache-maven-3.2.3， 并将它放在 D:\tools目录下， 即 maven 最终的路径是：D:\tools\apache-mave
  • jpa@OneToOne关联关系 布衣凌宇 jpa
    Nruser里的pruserid关联到Pruser的主键id，实现对一个表的增删改，另一个表的数据随之增删改。 Nruser实体类 //***************************************************************** @Entity @Table(name="nruser") @DynamicInsert @Dynam
  • 我的spring学习笔记11-Spring中关于声明式事务的配置 aijuans spring事务配置
    这两天学到事务管理这一块，结合到之前的terasoluna框架，觉得书本上讲的还是简单阿。我就把我从书本上学到的再结合实际的项目以及网上看到的一些内容，对声明式事务管理做个整理吧。我看得Spring in Action第二版中只提到了用TransactionProxyFactoryBean和<tx:advice/>,定义注释驱动这三种，我承认后两种的内容很好，很强大。但是实际的项目当中
  • java 动态代理简单实现 antlove javahandlerproxydynamicservice
    dynamicproxy.service.HelloService package dynamicproxy.service; public interface HelloService { public void sayHello(); }   dynamicproxy.service.impl.HelloServiceImpl package dynamicp
  • JDBC连接数据库 百合不是茶 JDBC编程JAVA操作oracle数据库
             如果我们要想连接oracle公司的数据库，就要首先下载oralce公司的驱动程序，将这个驱动程序的jar包导入到我们工程中;   JDBC链接数据库的代码和固定写法;     1,加载oracle数据库的驱动;     &nb
  • 单例模式中的多线程分析 bijian1013 javathread多线程java多线程
    谈到单例模式，我们立马会想到饿汉式和懒汉式加载，所谓饿汉式就是在创建类时就创建好了实例，懒汉式在获取实例时才去创建实例，即延迟加载。 饿汉式： package com.bijian.study; public class Singleton { private Singleton() { } // 注意这是private 只供内部调用 private static
  • javascript读取和修改原型特别需要注意原型的读写不具有对等性 bijian1013 JavaScriptprototype
            对于从原型对象继承而来的成员，其读和写具有内在的不对等性。比如有一个对象A，假设它的原型对象是B，B的原型对象是null。如果我们需要读取A对象的name属性值，那么JS会优先在A中查找，如果找到了name属性那么就返回；如果A中没有name属性，那么就到原型B中查找name，如果找到了就返回；如果原型B中也没有
  • 【持久化框架MyBatis3六】MyBatis3集成第三方DataSource bit1129 dataSource
    MyBatis内置了数据源的支持，如：   <environments default="development"> <environment id="development"> <transactionManager type="JDBC" /> <data
  • 我程序中用到的urldecode和base64decode,MD5 bitcarter cMD5base64decodeurldecode
    这里是base64decode和urldecode，Md5在附件中。因为我是在后台所以需要解码： string Base64Decode(const char* Data,int DataByte,int& OutByte) { //解码表 const char DecodeTable[] = { 0, 0, 0, 0, 0, 0
  • 腾讯资深运维专家周小军：QQ与微信架构的惊天秘密 ronin47
    社交领域一直是互联网创业的大热门，从PC到移动端，从OICQ、MSN到QQ。到了移动互联网时代，社交领域应用开始彻底爆发，直奔黄金期。腾讯在过去几年里，社交平台更是火到爆，QQ和微信坐拥几亿的粉丝，QQ空间和朋友圈各种刷屏，写心得，晒照片，秀视频，那么谁来为企鹅保驾护航呢？支撑QQ和微信海量数据背后的架构又有哪些惊天内幕呢？本期大讲堂的内容来自今年2月份ChinaUnix对腾讯社交网络运营服务中心
  • java-69-旋转数组的最小元素。把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素 bylijinnan java
    public class MinOfShiftedArray { /** * Q69 旋转数组的最小元素 * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。 * 例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。 */ publ
  • 看博客，应该是有方向的 Cb123456 反省看博客
    看博客，应该是有方向的:  我现在就复习以前的，在补补以前不会的，现在还不会的，同时完善完善项目，也看看别人的博客.  我刚突然想到的:  1.应该看计算机组成原理，数据结构，一些算法，还有关于android,java的。  2.对于我，也快大四了，看一些职业规划的，以及一些学习的经验，看看别人的工作总结的.    为什么要写
  • [开源与商业]做开源项目的人生活上一定要朴素,尽量减少对官方和商业体系的依赖 comsci 开源项目
         为什么这样说呢？  因为科学和技术的发展有时候需要一个平缓和长期的积累过程，但是行政和商业体系本身充满各种不稳定性和不确定性，如果你希望长期从事某个科研项目，但是却又必须依赖于某种行政和商业体系，那其中的过程必定充满各种风险。。。       所以，为避免这种不确定性风险，我
  • 一个 sql优化 （[精华] 一个查询优化的分析调整全过程！很值得一看 ） cwqcwqmax9 sql
    见   http://www.itpub.net/forum.php?mod=viewthread&tid=239011 Web翻页优化实例 提交时间: 2004-6-18 15:37:49      回复    发消息  环境： Linux ve
  • Hibernat and Ibatis dashuaifu Hibernateibatis
    Hibernate  VS  iBATIS 简介 Hibernate 是当前最流行的O/R mapping框架，当前版本是3.05。它出身于sf.net，现在已经成为Jboss的一部分了 iBATIS 是另外一种优秀的O/R mapping框架，当前版本是2.0。目前属于apache的一个子项目了。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mappi
  • 备份MYSQL脚本 dcj3sjt126com mysql
    #!/bin/sh # this shell to backup mysql #[email protected] (QQ:1413161683 DuChengJiu) _dbDir=/var/lib/mysql/ _today=`date +%w` _bakDir=/usr/backup/$_today [ ! -d $_bakDir ] && mkdir -p
  • iOS第三方开源库的吐槽和备忘 dcj3sjt126com ios
    转自 ibireme的博客   做iOS开发总会接触到一些第三方库，这里整理一下，做一些吐槽。   目前比较活跃的社区仍旧是Github，除此以外也有一些不错的库散落在Google Code、SourceForge等地方。由于Github社区太过主流，这里主要介绍一下Github里面流行的iOS库。   首先整理了一份 Github上排名靠
  • html wlwmanifest.xml eoems htmlxml
    所谓优化wp_head()就是把从wp_head中移除不需要元素，同时也可以加快速度。 步骤： 加入到function.php remove_action('wp_head', 'wp_generator'); //wp-generator移除wordpress的版本号，本身blog的版本号没什么意义，但是如果让恶意玩家看到，可能会用官网公布的漏洞攻击blog remov
  • 浅谈Java定时器发展 hacksin java并发timer定时器
    java在jdk1.3中推出了定时器类Timer,而后在jdk1.5后由Dou Lea从新开发出了支持多线程的ScheduleThreadPoolExecutor，从后者的表现来看，可以考虑完全替代Timer了。 Timer与ScheduleThreadPoolExecutor对比： 1.    Timer始于jdk1.3,其原理是利用一个TimerTask数组当作队列
  • 移动端页面侧边导航滑入效果 ini jqueryWebhtml5cssjavascirpt
    效果体验：http://hovertree.com/texiao/mobile/2.htm可以使用移动设备浏览器查看效果。效果使用到jquery-2.1.4.min.js，该版本的jQuery库是用于支持HTML5的浏览器上，不再兼容IE8以前的浏览器，现在移动端浏览器一般都支持HTML5，所以使用该jQuery没问题。HTML文件代码： <!DOCTYPE html> <h
  • AspectJ+Javasist记录日志 kane_xie aspectjjavasist
    在项目中碰到这样一个需求，对一个服务类的每一个方法，在方法开始和结束的时候分别记录一条日志，内容包括方法名，参数名+参数值以及方法执行的时间。   @Override public String get(String key) { // long start = System.currentTimeMillis(); // System.out.println("Be
  • redis学习笔记 MJC410621 redisNoSQL
    1)nosql数据库主要由以下特点：非关系型的、分布式的、开源的、水平可扩展的。 1，处理超大量的数据 2，运行在便宜的PC服务器集群上， 3，击碎了性能瓶颈。 1)对数据高并发读写。 2)对海量数据的高效率存储和访问。 3)对数据的高扩展性和高可用性。 redis支持的类型： Sring 类型 set name lijie get name lijie set na
  • 使用redis实现分布式锁 qifeifei
    在多节点的系统中，如何实现分布式锁机制，其中用redis来实现是很好的方法之一，我们先来看一下jedis包中，有个类名BinaryJedis,它有个方法如下：   public Long setnx(final byte[] key, final byte[] value) { checkIsInMulti(); client.setnx(key, value); ret
  • BI并非万能，中层业务管理报表要另辟蹊径 张老师的菜 大数据BI商业智能信息化
           BI是商业智能的缩写，是可以帮助企业做出明智的业务经营决策的工具，其数据来源于各个业务系统，如ERP、CRM、SCM、进销存、HER、OA等。        BI系统不同于传统的管理信息系统，他号称是一个整体应用的解决方案，是融入管理思想的强大系统：有着系统整体的设计思想，支持对所有
  • 安装rvm后出现rvm not a function 或者ruby -v后提示没安装ruby的问题 wudixiaotie function
    1.在~/.bashrc最后加入 [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"  2.重新启动terminal输入：   rvm use ruby-2.2.1 --default  把当前安装的ruby版本设为默
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他