C++博客-天之道-随笔分类-C

栈和堆（转）

hoshelly — Fri, 27 Sep 2013 01:13:00 GMT

摘抄自：http://www.cnblogs.com/vamei

当程序文件运行为进程的时候，进程在内存中得到空间(进程自己的小房间)。每个进程空间按照如下方式分为不同区域:

内存空间

Text区域用来储存指令(instruction)，来告诉程序每一步的操作。Global Data用于存放全局变量，stack用于存放局部变量，heap用于存放动态变量 (dynamic variable. 程序利用malloc系统调用，直接从内存中为dynamic variable开辟空间)。Text和Global data在进程一开始的时候就确定了，并在整个进程中保持固定大小。

Stack(栈)以stack frame为单位。当程序调用函数的时候，比如main()函数中调用inner()函数，stack会向下增长一个stack frame。Stack frame中存储该函数的参数和局部变量，以及该函数的返回地址(return address)。此时，计算机将控制权从main()转移到inner()，inner()函数处于激活(active)状态。位于Stack最下方的frame和Global Data就构成了当前的环境(context)。激活函数可以从中调用需要的变量。典型的编程语言都只允许你使用位于stack最下方的frame ，而不允许你调用其它的frame (这也符合stack结构“先进后出”的特征。但也有一些语言允许你调用stack的其它部分，相当于允许你在运行inner()函数的时候调用main()中声明的局部变量，比如Pascal)。当函数又进一步调用另一个函数的时候，一个新的frame会继续增加到stack下方，控制权转移到新的函数中。当激活函数返回的时候，会从stack中弹出(pop，就是读取并删除)该frame，并根据frame中记录的返回地址，将控制权交给返回地址所指向的指令(比如从inner()函数中返回，继续执行main()中赋值给main2的操作)。

下图是stack在运行过程中的变化，箭头表示stack增长的方向，每个方块代表一个stack frame。开始的时候我们有一个为main()服务的frame，随着调用inner()，我们为inner()增加一个frame。在inner()返回时，我们再次只有main()的frame，直到最后main()返回，其返回地址为空，所以进程结束。

stack变化

在进程运行的过程中，通过调用和返回函数，控制权不断在函数间转移。进程可以在调用函数的时候，原函数的stack frame中保存有在我们离开时的状态，并为新的函数开辟所需的stack frame空间。在调用函数返回时，该函数的stack frame所占据的空间随着stack frame的弹出而清空。进程再次回到原函数的stack frame中保存的状态，并根据返回地址所指向的指令继续执行。上面过程不断继续，stack不断增长或减小，直到main()返回的时候，stack完全清空，进程结束。

当程序中使用malloc的时候，heap(堆)会向上增长，其增长的部分就成为malloc从内存中分配的空间。malloc开辟的空间会一直存在，直到我们用free系统调用来释放，或者进程结束。一个经典的错误是内存泄漏(memory leakage), 就是指我们没有释放不再使用的heap空间，导致heap不断增长，而内存可用空间不断减少。

由于stack和heap的大小则会随着进程的运行增大或者变小，当stack和heap增长到两者相遇时候，也就是内存空间图中的蓝色区域(unused area)完全消失的时候，进程会出现栈溢出(stack overflow)的错误，导致进程终止。在现代计算机中，内核一般都会为进程分配足够多的蓝色区域，如果我们即时清理的话，stack overflow是可以避免的。但是，在进行一些矩阵运算的时候，由于所需的内存很大，依然可能出现stack overflow的情况。一种解决方式是增大内核分配给每个进程的内存空间。如果依然不能解决问题的话，我们就需要增加物理内存。

堆和栈的区别：

2.1申请方式
stack:
由系统自动分配。   例如，声明在函数中一个局部变量   int   b;   系统自动在栈中为b开辟空
间
heap:
需要程序员自己申请，并指明大小，在c中malloc函数
如p1   =   (char   *)malloc(10);
在C++中用new运算符
如p2   =   new   char[10];
但是注意p1、p2本身是在栈中的。


2.2
申请后系统的响应
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢
出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，
会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表
中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的
首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。
另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部
分重新放入空闲链表中。

2.3申请大小的限制
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意
思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有
的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将
提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储
的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小
受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。



2.4申请效率的比较：
栈由系统自动分配，速度较快。但程序员是无法控制的。
堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是
直接在进程的地址空间中保留一块内存，虽然用起来最不方便。但是速度快，也最灵活。


2.5堆和栈中的存储内容
栈：   在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可
执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈
的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地
址，也就是主函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

2.6存取效率的比较

char   s1[]   =   "aaaaaaaaaaaaaaa";
char   *s2   =   "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的；
而bbbbbbbbbbb是在编译时就确定的；
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。

2.7小结：
堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就
走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自
由度小。
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由
度大。   (经典！)

hoshelly 2013-09-27 09:13 发表评论

printf("%.*s\n"，int,str) 的含义

hoshelly — Wed, 05 Dec 2012 14:10:00 GMT

转。
// %.*s 其中的.*表示显示的精度对字符串输出(s)类型来说就是宽度
// 这个*代表的值由后面的参数列表中的整数型(int)值给出

// 例如：
printf("%.*s\n", 1, "abc");        // 输出a
printf("%.*s\n", 2, "abc");        // 输出ab
printf("%.*s\n", 3, "abc");        // 输出abc >3是一样的效果因为输出类型type = s，遇到'\0'会结束

hoshelly 2012-12-05 22:10 发表评论

十进制转二进制（代码）

hoshelly — Sat, 08 Sep 2012 04:41:00 GMT

如下：
#include<stdio.h>

int main()
{
    int M,b;
    int N[100],c=0;
    scanf("%d%d",&b,&M);//输入进制b(2~10),要转化为b进制的正整数M(十进制)
    while(M)
    {
        N[c++]=M%b;
        M=M/b;
    }
    for(int i=c-1;i>=0;i--)
        printf("%d",N[i]);
    printf("\n");
    return 0;
}

hoshelly 2012-09-08 12:41 发表评论

二进制转十进制（代码）

hoshelly — Sat, 08 Sep 2012 04:37:00 GMT

如下：
#include<stdio.h>

#include<string.h>
#include
int main()
{
    char M[100]={0};
    int N=0;
    gets(M);
    int len=strlen(M);
    for(int i=0;i    {
        N+=(M[i]-'0') * pow(2.0,len-i-1);
    }
    printf("%d\n",N);
    return 0;
}

hoshelly 2012-09-08 12:37 发表评论

填充二维数组

hoshelly — Sun, 19 Aug 2012 08:22:00 GMT

编写一程序，用0或1填充一个二维数组，如果i 和j 的最大公因子为1，则设a[i][j]为1；否则设为0。

代码如下：

#include
#define N 10
int Maxcom(int a, int b)
{
    while(a!=b)
    {
        if(a>b)
            a=a-b;
        else if(b>a)
            b=b-a;
    }
    return a;
}
int main()
{
    int a[N][N];
    int i,j,max;
    for(i=0;i<5;i++)
    {
        for(j=0;j<5;j++)
        {
            if(i==1 && j==1)
                a[i][j]=1;
            else if( i>0 && j>0)
            {
                max = Maxcom(i,j);
                if(max == 1)
                    a[i][j]=1;
                else
                    a[i][j]=0;
            }
            else
                a[i][j]=0;
        }
    }
    for(i=0;i<5;i++)
    {
        for(j=0;j<5;j++)
            printf("%d ",a[i][j]);
        printf("\n");
    }
    printf("\n");

    return 0;
}

hoshelly 2012-08-19 16:22 发表评论

关于二维数组

hoshelly — Sun, 19 Aug 2012 07:40:00 GMT

二维数组的乘积计算：

for(i=0;i for(j=0;j for(k=0,c[i][j] = 0.0;k c[i][j] +=a[i][k] * b[k][j];

二维数组的分配：

#include
#include

int **malloc2d(int r, int c) //二维数组分配函数
{
    int i;
    int **t = (int **)malloc(r * sizeof(int *));
    for(i=0;i        t[i] = (int *)malloc(c * sizeof(int));
    return t;
}

int main()
{
    int i,j;
    int **a =malloc2d(3,3);
    for(i=0;i<3;i++)
        for(j=0;j<3;j++)
            a[i][j]=i+j;
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
            printf("%d ",a[i][j]);
        printf("\n");
    }
    return 0;
}

综合计算二维数组相乘的乘积。
代码如下：

#include
#include

int **malloc2d(int r, int c)
{
    int i;
    int **t = (int **)malloc(r * sizeof(int *));
    for(i=0;i        t[i] = (int *)malloc(c * sizeof(int));
    return t;
}

int main()
{
    int i,j,k;
    int **a =malloc2d(3,3);
    int **b =malloc2d(3,3);
    int **c =malloc2d(3,3);
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
        {
            a[i][j]=i+j;
            b[i][j]=i+j;
        }
    }
    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
            printf("%d ",a[i][j]);
        printf("\n");
    }
    printf("\n");
    for(i=0;i<3;i++)
    for(j=0;j<3;j++)
      for(k=0,c[i][j] = 0.0;k<3;k++)
         c[i][j] +=a[i][k] * b[k][j];

    for(i=0;i<3;i++)
    {
        for(j=0;j<3;j++)
            printf("%d ",c[i][j]);
      printf("\n");
    }

    return 0;
}

hoshelly 2012-08-19 15:40 发表评论

库函数qsort()的用法

hoshelly — Sun, 19 Aug 2012 03:11:00 GMT

//整数排序，利用qsort函数
#include
#include
int compare(const void * a,const void * b)
{
    return *(int*)a - *(int*)b;
}
int main()
{
    int a[20],i;
    for(i=0;i<10;i++)
    {
        scanf("%d",&a[i]);
    }
    qsort(a,10,sizeof(int),compare);
    for(i=0;i<10;i++)
        printf("%d ",a[i]);
    return 0;
}

hoshelly 2012-08-19 11:11 发表评论

字符串排序

hoshelly — Sun, 19 Aug 2012 02:49:00 GMT

//字符串排序，利用qsort函数
#include
#include<string.h>
#include
#define Nmax 1000
#define Mmax 10000
char buf[Mmax]; int M=0;
int compare(const void *i, const void *j)
{
    return strcmp(*(char **)i, *(char **)j);
}

int main()
{
    int i, N;
    char *a[Nmax];
    for(N=0; N    {
        a[N]= &buf[M];
        if(scanf("%s", a[N]) == EOF) break;
        M+=strlen(a[N])+1;
    }

    qsort(a,N,sizeof(char*),compare); //四个参数分别代表：待排序的数组首地址，数组中待排序的元素数量，各元素占用的空间，排序函数（确定排序顺序）
    for(i=0;i        printf("%s\n",a[i]);

    return 0;
}

hoshelly 2012-08-19 10:49 发表评论

文件的读写

hoshelly — Mon, 12 Mar 2012 08:53:00 GMT

创建一个后缀名为txt的文件，并向该文件写入一个字符串，保存起来，再打开文件，读出文件中的内容。
代码如下：

#include<stdio.h>
#include<string.h>
int main()
{
    FILE *fp;
    char pathName[20],txt1[100]={'\0'},txt2[20]={'\0'};
    int fileLen;
    printf("Please type the path name of the file\n");
    scanf("%s",pathName);
    fp=fopen(pathName,"w");
    printf("Please input a string to this file\n");
    scanf("%s",txt1);
    fileLen=strlen(txt1);
    fwrite(txt1,fileLen,1,fp);
    fclose(fp);
    printf("The file has been saved\n");
    printf("The content of teh file: %s is\n",pathName);
    fp=fopen(pathName,"r");
    fread(txt2,fileLen,1,fp);
    printf("%s\n",txt2);
    return 0;
}

hoshelly 2012-03-12 16:53 发表评论

贪心算法之最优装船问题

hoshelly — Mon, 12 Mar 2012 06:10:00 GMT

题目：
有一批集装箱要装入一个载质量为C的货船中，每个集装箱的质量由用户自己输入指定，在货船的装载体积不限的前提下，如何装载集装箱才能尽可能多地的将集装箱装入货船中。

每次选取质量最小的箱子装入船（用冒泡排序算法解决），代码如下：

#include<stdio.h>
#include<stdlib.h>
void sort(int w[],int t[],int n)//w[]存放每个集装箱的质量，t[]存放w[]的下标
{
    int i,j,tmp;
    int *w_tmp=(int *)malloc(sizeof(int)*n);//开辟一个临时数组，存放w[]的内容，用于排序
    for(i=0;i<n;i++)
        t[i]=i;//初始化数组t
    for(i=0;i<n;i++)
        w_tmp[i]=w[i];
    for(i=0;i<n-1;i++)
        for(j=0;j<n-i-1;j++)//冒泡排序实现
            if(w_tmp[j]>w_tmp[j+1])
            {
                tmp=w_tmp[j];
                w_tmp[j]=w_tmp[j+1];
                w_tmp[j+1]=tmp;
                tmp=t[j];
                t[j]=t[j+1];
                t[j+1]=tmp;
            }
}

void loading(int x[],int w[],int c,int n)
{
    int i,s=0;
    int *t=(int*)malloc(sizeof(int)*n);//动态开辟一个临时数组，存放w[]的下标
    sort(w,t,n);
    for(i=0;i<n;i++)
        x[i]=0;
    for(i=0;i<n && w[t[i]]<=c;i++){
        x[t[i]]=1; //将第t[i]个集装箱装入货船中
        c=c-w[t[i]]; //变量c中存放货船的剩余载质量
    }
}

int main()
{
    int x[5],w[5],c,i;
    printf("Iput the maximum loading of the sheep\n");
    scanf("%d",&c);
    printf("Iput the weight of Five box\n");
    for(i=0;i<5;i++)
        scanf("%d",&w[i]);
    loading(x,w,c,5);
    printf("The following boxes will be loaded\n");
    for(i=0;i<5;i++)
    {
        if(x[i]==1)   printf("BOX:%d ",i);
    }
    return 0;
}

hoshelly 2012-03-12 14:10 发表评论

字符串的删除

hoshelly — Tue, 31 Jan 2012 17:13:00 GMT

#include<stdio.h>
#include<string.h>
char* strins(char* str1,char* str2,int pos)
{
    int s_len;
    int d_len;
    int i,j;
    pos--;
    s_len=strlen(str1);
    d_len=strlen(str2);
    for(i=s_len+1;i>=pos;i--) /*空出str2的空间*/
        str1[i+d_len]=str1[i];
    for(j=pos;str2[j-pos]!='\0';j++) /*将字符串str2插入str1中的特定位置*/
        str1[j]=str2[j-pos];

    return str1;
}

void main()
{
    char string1[200];
    char string2[100];
    int pos;
    printf("请输入初始字符串:");
    gets(string1);
    printf("请输入插入字符串:");
    gets(string2);
    printf("请输入插入位置:");
    scanf("%d",&pos);
    strins(string1,string2,pos);
    printf("插入后的字符串是%s\n",string1);
}

hoshelly 2012-02-01 01:13 发表评论

递归函数的使用

hoshelly — Sun, 18 Sep 2011 13:03:00 GMT

要求：编写一个递归函数，将一个整数n转换为字符串，例如输入483，应输出字符串“483”。
设计思想：设置一个字符型数组str，用于存放转换后的字符串，因为递归函数中要反复使用它，所以将其设置为全局数组变量。要实现整数n转换成字符串的递归转换，首先要将n的个位数n%10转换为字符，插入到str字符串的最前面，然后将除个位后的高位部分n/10按照相同的方式来转换，直到要转换的数为0结束。

#include<stdio.h>
#include<string.h>
void IntToStr(int n);
char str[80]={0};
void main()
{
    int num;
    printf("input an integer number:");
    scanf("%d",&num);
    IntToStr(num);
    printf("The string is:%s\n",str);
}

void IntToStr(int n)
{
    int i;
    if(n==0)//整数为0时，递归结束
        return;
    for(i=strlen(str)-1;i>=0;i--) //将字符串整个往后移一个字符
        str[i+1]=str[i];
    str[0]=n%10+0x30;  //将该数的个位数转换成字符放在字符数组的第一个元素的位置，+0x30表示十六进制的0，其实可以不加

    IntToStr(n/10);//将该数的商，即除个位外的其他数通过递归转换
}

//递归过程：例如输入n=148,那么第一次递归时，str[0]存放的数是8,n/10=14，得到第二次递归的数是14；
//8原先存储在str[0]，但第二次递归向后移动一个字符，变成存在str[1]内，而4存在str[0]内；
//第三次递归时，同理可知8放在str[2],4放在str[1],而1放在str[0]，这样就将148转换为字符串。

hoshelly 2011-09-18 21:03 发表评论

编写一递归函数求斐波纳契数列的前40项

hoshelly — Sun, 18 Sep 2011 07:27:00 GMT

注：斐波纳契数列的第一项和第二项的值都为1，以后各项的值为其前两项值之和。所以要计算第n项的值F(n)，可以列出递归式F(n)=F(n-1)+F(n-2)，当n=1或n=2时，其值为1；

用C语言代码表示如下：

#include<stdio.h>
long F(int n);
void main()
{
    int i;
    for(i=1;i<=40;i++)
    {
        printf("F(%2d)=%-9ld",i,F(i));
        if(i%4==0)
        printf("\n");
    }
}

long F(int n)//求第n项的值
{
    if(n<=2)
        return (1);
    return(F(n-1)+F(n-2));
}

hoshelly 2011-09-18 15:27 发表评论

冒泡排序与选择排序学习总结

hoshelly — Sat, 17 Sep 2011 08:53:00 GMT

冒泡排序的基本概念：
依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。需要用二重循环排序。
Example:

#include<stdio.h>
int main()
{
    int i,j,temp,tag;
    int a[11]; //数组第0位空出
    for(i=1;i<=10;i++)
    scanf ("%d,",&a[i]);
    for(j=1;j<=10;j++)
    {
       tag=1;
       for (i=1;i<=10-j;i++)
       {
        if (a[i]>a[i+1])
       {
           temp=a[i];
           a[i]=a[i+1];
           a[i+1]=temp;
           tag=0;
       }
       }

       if(1==tag)
       {
         break;
       }
    }
        for(i=0;i<10;i++)
            printf("%5d",a[i]);
            return 0;
}

以下是选择排序法：

每次外循环先将定位元素的小标i值记录到K，认为a[k]是最小值，第一轮比较时，若遇到比a[k]更小的数，则交换两数的下标，由下面的if语句进行交换处理。
这样第一轮就选出了最小的数，第二轮，同理选出次小的数排在最小的数后面。如果是输入10个数，那么进行9轮排序后就可完成整个排序过程。

#include<stdio.h>//选择排序法
void main()
{
    int i,j,t,a[10],k;
    printf("input 10 numbers:\n");
    for(i=0;i<10;i++)
    scanf("%d",&a[i]);

    for(i=0;i<9;i++)//这里也要注意i=0;i<9;
    {
        k=i;
        for(j=i+1;j<10;j++)
            if(a[k]>a[j])
                k=j;

            if(k!=i)//如果k不等于i，改变了，则交换两个数的位置
            {
                t=a[i];
                a[i]=a[k];
                a[k]=t;
            }
    }
    for(i=0;i<10;i++)//最后输出已经排好序的数
        printf("%5d",a[i]);
}

PS：大一刚开始接触这两个排序算法时，感觉有点乱，现在回过头来仔细看，思路清晰了不少。时刻回顾过去的知识，进行整理，再认识，很重要呀。:-D

hoshelly 2011-09-17 16:53 发表评论

欧几里得算法

hoshelly — Fri, 16 Sep 2011 18:00:00 GMT

辗转相除法，又名欧几里得算法，是求最大公约数的算法。

原理及其详细证明

　　设两数为a、b(b　　第一步：令c=gcd(a,b)，则设a=mc，b=nc

　　第二步：根据前提可知r =a-kb=mc-knc=(m-kn)c

　　第三步：根据第二步结果可知c也是r的因数

　　第四步：可以断定m-kn与n互素【否则，可设m-kn=xd，n=yd，(d>1)，则m=kn+xd=kyd+xd=(ky+x)d，则a=mc=(ky+x)dc，b=nc=ycd，故a与b最大公约数成为cd，而非c】

　　从而可知gcd(b,r)=c，继而gcd(a,b)=gcd(b,r)。

　　证毕。

用C表示则：

int gcd(int a,int b)

　　{

　　int temp;

　　if(a　　{

　　temp=a;

　　a=b;

　　b=temp;

　　}

　　while(b!=0)/*利用辗除法，直到b为0为止*/

　　{

　　temp=a%b;

　　a=b;

　　b=temp;

　　}

　　return a;

　　}

hoshelly 2011-09-17 02:00 发表评论

计算两个正整数的最大公约数*

hoshelly — Fri, 16 Sep 2011 10:35:00 GMT

算法分析：因为对于a与b两个数，当a>b时，如果a中含有与b相同的公约数，则a-b也含有与b相同的公约数，反复循环，直到a和b相等为止，这时a或b就是它们的最大公约数。

1 #include<stdio.h>
2 int Maxcommonfactor(int a,int b);
3 void main()
4 {
5     int a,b,c;
6     printf("input two integer number:");
7     scanf("%d%d",&a,&b);
8     c=Maxcommonfactor(a,b);
9     if(c!=-1)
10         printf("The biggest common factor of %d and %d is %d\n",a,b,c);
11     else
12         printf("The biggest common factor of %d and %d isn't exist\n",a,b);
13 }
14 int Maxcommonfactor(int a,int b)
15 {
16     if(a<=0||b<=0)
17         return(-1);
18     while(a!=b)
19     {
20         if(a>b)
21             a=a-b;
22         else if(b>a)
23             b=b-a;
24     }
25     return(a);//返回的值为最大公约数
26 }
27
28

hoshelly 2011-09-16 18:35 发表评论

判断一个数是否为素数

hoshelly — Fri, 16 Sep 2011 06:31:00 GMT

1 #include<stdio.h>
2 #include<math.h>
3 int pdss(int number);//定义一个函数，判断一个数是否为素数
4 int main()
5 {
6     int n;
7     printf("input the integer:\n");
8        scanf("%d",&n);
9     if(pdss(n))//如果是1，输出素数
10        printf("%d 是素数.",n);
11     else
12        printf("%d 不是素数.",n);
13     return 0;
14 }
15
16 int pdss(int number)
17 {
18     int i;
19     if(number<=1)
20         return 0;
21     for(i=2;i<=sqrt(number);i++)//检验一个数为素数时，用其平方根小或等于的数去整除所输入的数，即可判断。为什么？
22         if(number%i==0)
23         return 0;
24         else
25         return 1;
26         return 0;
27 }
28

hoshelly 2011-09-16 14:31 发表评论