精华内容
下载资源
问答
  • c语言常见算法

    2019-01-08 23:30:41
    总结了C语言常见算法,都是一些平日编程会用到的常见算法
  • C语言常见算法示例

    2011-12-13 16:59:44
    C语言常见算法示例,C语言常见算法示例,C语言常见算法示例
  • C语言常见算法实现

    千次阅读 多人点赞 2010-07-04 11:03:37
    C语言常见算法主要收集一些经常用到的算法,有些笔试面试中经常考到,自己在学习的过程中与大家分享,希望对学习算法和C语言的朋友有帮助。 1,汉诺塔算法的C语言实现  2,八皇后问题的C语言实现 3,费时数列的...

    C语言常见算法主要收集一些经常用到的算法,有些笔试面试中经常考到,自己在学习的过程中与大家分享,希望对学习算法和C语言的朋友有帮助。

    1,汉诺塔算法的C语言实现 

    2,八皇后问题的C语言实现

    3,费时数列的C语言实现

    4,八枚硬币问题的C语言实现 

    5,三色旗解法的C语言实现

    6,巴斯卡三角形算法的C语言实现

    7,背包问题的C语言实现

    8,Eratosthenes筛选求质数的C语言实现

    展开全文
  • C语言算法
  • C语言常见算法(swf)

    2013-03-11 16:56:43
    二级的同学可以下载,非常的实用,不要错过哦。 二级的同学可以下载,非常的实用,不要错过哦。
  • c语言常用算法

    2011-09-14 18:50:28
    c语言常用算法c语言常用算法c语言常用算法c语言常用算法c语言常用算法
  • C语言经典算法

    2016-08-28 22:19:16
    常见经典的C语言基础算法模仿和学习
  • 今天,承接上一篇C语言经典算法(一),我继续给大家带来C语言经典算法,欢迎大家与小编多多交流。六、99乘法口诀表具体实现代码如下,算法关键在于使用两个for循环,外循环控制换行,内循环控制每一行的具体输出规则...

    C语言作为多数工科学校编程入门的教学工具语言,是很多朋友开启编程世界大门的钥匙。今天,承接上一篇C语言经典算法(一),我继续给大家带来C语言经典算法,欢迎大家与小编多多交流。

    六、99乘法口诀表

    具体实现代码如下,算法关键在于使用两个for循环,外循环控制换行,内循环控制每一行的具体输出规则。

    d50c76eac87a

    程序运行结果如下

    d50c76eac87a

    七、寻找“水仙花数”

    所谓“水仙花数”是指一个三位数,其各位数字立方和等于该数本身。比如,407是一个“水仙花数”,因为407=4的三次方+0的三次方+7的三次方。这个算法的关键是提取三位数的每一位数。

    d50c76eac87a

    运行结果如下

    d50c76eac87a

    八、分解质因数

    比如,把60分解质因数,就是指把60拆解成 60=2x2x3x5的结构。

    代码如下,把168拆解质因数。

    main()

    {

    int exa=168,i;

    printf("%d=",exa);

    for(i=2;i

    {

    while(exa!=i)

    {

    if(exa%i==0)

    { printf("%d*",i);

    exa=exa/i;

    }

    else

    break;

    }

    }

    printf("%d",exa);

    printf("");

    }

    运行结果如下

    d50c76eac87a

    九、a和b最大公约数

    求解两个数a和b的最大公约数,也叫最大公因数,是指两个或多个整数共有约数中最大的一个,比如,12和4的最大公约数是4,32和12的最大公约数是4。求解两个数的最大公约数,比较常见的算法是碾转相除法。代码如下。

    main()

    {

    int a,b,num1,num2,temp;

    printf("请输入两个正整数");

    scanf("%d %d",&num1,&num2);

    if(num1

    { temp=num1;

    num1=num2;

    num2=temp;

    } //将较大数存储在num1里面

    a=num1;b=num2;

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

    {

    temp=a%b;

    a=b;

    b=temp;

    }

    printf("最大公约数是%d",a);

    }

    运行测试结果:

    d50c76eac87a

    十、判断回文数

    回文数,是指左右对称的一类数,比如123454321,688886。编程实现判断,可以使用字符数组存储各位。然后分别从首位判断是否符合对称条件。

    main()

    {

    int i,j;

    char s[16];

    printf("请输入整数");

    scanf("%s",s);

    for(i=0,j=strlen(s)-1;i

    if(s[i]!=s[j])

    break;

    printf("%s是回文数!",s);

    else

    printf("%s不是回文数!",s);

    }

    下面是测试样例:

    d50c76eac87a

    d50c76eac87a

    d50c76eac87a

    d50c76eac87a

    展开全文
  • c语言常见排序算法

    千次阅读 多人点赞 2017-06-01 17:50:17
    排序算法 冒泡排序 快速排序 选择排序

    此处假设需要排序的为一个int型数组,定义如下:

    int array[10] = {5, 9, 0, 1, 3, 6, 8, 7, 2, 4};
    

    一、冒泡排序

    算法步骤:

    • 首先,把10个数里最小的个数放到下标为0的位置上(array[0])

    • 通过将下标为0的数(array[0])与剩下其余9个数进行对比交换(将较少者放置在下标为0的位置上),就可以得到这10个数最小的那个

    • 10个数最小的那位确定后,接下来就要找剩下9个数最小的那个。

    • 因为已经确定出一个最小的数,所以就不要动array[0],直接从array[1]开始,与剩下的8个数对比交换,找出9个数中最小的那位放到下标为1(array[1])的位置上

    • 继续按照这个思路就可以将这十个数变成有序的(从小到大)的数组

    代码:

    #include <stdio.h>  
      
    void swap(int *a, int *b)  
    {  
        int c;  
        
        c = *a;  
        *a = *b;  
        *b =  c;  
    }  
    
    /*冒泡排序*/
    void sort(int* array, int cnt)
    {
        int i, j;  
    
        //排序,从array[0]开始排,从小到大  
        for (i=0; i<cnt; i++)  
        {  
            for (j=i+1; j<cnt; j++)  
            {  
                if (array[i] > array[j])  
                {  
                    swap(&array[i], &array[j]);  
                }  
            }  
        }    
    }
    
    int main()  
    {  
        int i;
        int array[10] = {5, 9, 0, 1, 3, 6, 8, 7, 2, 4};
        
        sort(array, sizeof(array)/sizeof(array[0]));
    
        //将十个数输出  
        for (i=0; i<sizeof(array)/sizeof(array[0]); i++) {
            printf("%d\n", array[i]);  
        }
    
        return 0;  
    }  
    
    

    二、快速排序

    快速排序(Quicksort)是对冒泡排序的一种改进。
      快速排序由C. A. R. Hoare在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
      
    算法步骤:
      设要排序的数组是A[0]……A[N-1],首先任意选取一个数据(通常选用数组的第一个数)作为关键数据,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一趟快速排序。值得注意的是,快速排序不是一种稳定的排序算法,也就是说,多个相同的值的相对位置也许会在算法结束时产生变动。
    一趟快速排序的算法是:
    1. 设置两个变量i、j,排序开始的时候:i=0,j=N-1;
    2. 以第一个数组元素作为关键数据,赋值给key,即key=A[0];
    3. 从j开始向前搜索,即由后开始向前搜索(j–),找到第一个小于key的值A[j],将A[j]和A[i]互换;
    4. 从i开始向后搜索,即由前开始向后搜索(i++),找到第一个大于key的A[i],将A[i]和A[j]互换;
    5. 重复第3、4步,直到i=j; (3,4步中,没找到符合条件的值,即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值,使得j=j-1,i=i+1,直至找到为止。找到符合条件的值,进行交换的时候i, j指针位置不变。另外,i==j这一过程一定正好是i+或j-完成的时候,此时令循环结束)。

    代码:

    void quickSort(int *a, int left, int right)
    {
        /*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
        if (left >= right) { 
            return;
        }
        
        int i = left;
        int j = right;
        int key = a[left];
         
        /*控制在当组内寻找一遍*/
        while (i < j) {                              
        
            /*而寻找结束的条件就是,1,找到一个小于或者大于key的数(大于或小于取决于你想升
            序还是降序)2,没有符合条件1的,并且i与j的大小没有反转*/ 
            while ((i<j) && (key<=a[j]))  {
                j--;    /*向前寻找*/
            }
             
            /*找到一个这样的数后就把它赋给前面的被拿走的i的值(如果第一次循环且key是
            a[left],那么就是给key)*/
            a[i] = a[j];
             
            /*这是i在当组内向前寻找,同上,不过注意与key的大小关系停止循环和上面相反,
            因为排序思想是把数往两边扔,所以左右两边的数大小与key的关系相反*/
            while ((i<j) && (key>=a[i])) {
                i++;
            }
             
            a[j] = a[i];
        }
        /*当在当组内找完一遍以后就把中间数key回归*/ 
        a[i] = key; 
       
        /*最后用同样的方式对分出来的左边的小组进行同上的做法*/
        quickSort(a, left, i-1);
        
        /*用同样的方式对分出来的右边的小组进行同上的做法*/
        /*当然最后可能会出现很多分左右,直到每一组的i = j 为止*/
        quickSort(a, i+1, right);
    }
    

    三、选择排序

    选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。

    代码:

    // 选择排序   从小到大
    void selectionSort(int *a, int count) 
    {
        int i, j, min;
    
        for (i=0; i<count-1; i++) {
            min = i;    // 查找最小值
            for (j=i+1; j<count; j++) {
                if (a[min] > a[j]) {
                    min = j;
                }
            }
    
            if (min != i) {
                swap(&a[min], &a[i]);
            }
        }
    }
    
    展开全文
  • 常见算法c语言矩阵算法问题

    万次阅读 2012-04-11 17:52:45
    矩阵:数学上,一个m×n矩阵乃一m行n列的矩形阵列。矩阵由数组成,或更一般的,由某环中元素组成。 0.矩阵N*N相乘 #include int main(void) { int i,j,k;... double a[3][3],b[3][3],c[3][3];...j<3

    矩阵:数学上,一个m×n矩阵乃一mn列的矩形阵列。矩阵由数组成,或更一般的,由某环中元素组成。

    0.矩阵N*N相乘

    #include<stdio.h>
    int main(void)
    {
            int i,j,k;
            double a[3][3],b[3][3],c[3][3];
    
            for(i=0;i<3;i++){
                    for(j=0;j<3;j++){
                            printf("Enter the number in a[%d][%d]\n",i,j);
                            scanf("%lf",&a[i][j]);
                    }
            }
    
            for(i=0;i<3;i++){
                    for(j=0;j<3;j++){
                            printf("Enter the number in b[%d][%d]\n",i,j);
                            scanf("%lf",&b[i][j]);
                    }
            }
    
            for(i=0;i<3;i++){
                    for(j=0;j<3;j++){
                            c[i][j]=0;
                            for(k=0;k<3;k++){
                                    c[i][j]=a[i][k]*b[k][j]+c[i][j];
                            }
                    }
            }
    
            for(i=0;i<3;i++){
                    for(j=0;j<3;j++){
                            printf("    %lf",c[i][j]);
                    }
                    printf("\n");
            }
    
            return 0;
    }


    1,求矩阵转置问题

    /*
    根据主函数,编写一下两个函数
    1:求数组a[4][4]主对角线上元素的和 ----区分主对角线和次对角线的区别
    2:实现对数组a[4][4]的矩阵转置处理
    */
    #include<stdio.h>
    void convert(int *p)     //数组转置
    {
    	int i,j,t;
    	for(i=0;i<4;i++)
    		for(j=0;j<4;j++)
    		{
    			t=*(p+4*i+j);
    			*(p+4*i+j)=*(p+4*j+i);
    			*(p+4*j+i)=t;
    		}
    }
    
    int total(int a[][4],int n)       //主对角线上元素的和
    {
    	int i,sum=0;
    	for(i=0;i<4;++i)
    		if(a[i][i]!=0)
    			sum+=a[i][i];
    	return sum;
    }
    int total1(int a[][4],int n)     //次对角线上元素之和
    {
    	int i,j,sum=0;
    	for(i=0;i<4;i++)
    		for(j=0;j<4;j++)
    		{
    			if((i+j)==3) sum+=a[i][j];     //此时仅当i+j=n-1的时候才是次对角线上的点
    		}
    		return sum;
    }
    
    void main()
    {
    	static int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    	int *p,i,sum,sum1;
    	sum=total(a,4);
    	sum1=total1(a,4);
    	printf("主对角线之和:%d\n",sum);
    	printf("次对角线之和:%d\n",sum1);
    	p=*a;
    	convert(p);
    	printf("转置后的数组是:\n");
    	for(i=0;i<4;++i)
    		printf("%d %d %d %d \n",a[i][0],a[i][1],a[i][2],a[i][3]);
    
    }

    2,求矩阵中最大值的问题

    /*
    有一个3*4的矩阵,要求编程序求出其中值最大的那个元素的值,以及所在的行号和列号
    */
    #include<stdio.h>
    void main()
    {
    	int a[3][4],i,j;
    	int colum,row;
    	printf("please input the array:\n");
    	for(i=0;i<3;i++)
    		for(j=0;j<4;j++)
    			scanf("%d",a[i][j]);
    	printf("\n");
    	int max=a[0][0];    //设定最大值是第一个数
    	for(i=0;i<3;i++)
    		for(j=0;j<4;j++)
    			if(a[i][j]>max)
    			{
    				max=a[i][j];
    				colum=j;
    				row=i;
    			}
    	printf("max=%d,colum=%d,row=%d",max,colum,row);
    
    
    }

    3,找出m*n矩阵的鞍点

    #include<stdio.h>
    #include<stdlib.h>
    #define M 3
    #define N 4
    void main()
    {
    	int a[M][N],i,j,k;
    	int max,t;
    	for(i=0;i<M;i++)
    		for(j=0;j<N;j++)
    			scanf("%d",&a[i][j]);
    	for(i=0;i<M;i++)
    	{
    		max=0;                        //此时假设每一行的最大值是第一个数即a[i][0]
    		for(j=i+1;j<N;j++)            //找出列中的最大值
    		{
    			if(a[i][j]>a[i][max])
    				max=j;
    		}
    		for(t=1,k=0;k<M&&t;k++)      //判断是否在列中是不是最小值
    		{
    			if(a[k][max]<a[i][max])  //如果还存在数比a[k][max]的值还小,则置t=0,
    				t=0;                 //t是一个标识,t=0  表示不存在,
    		}
    	}
    	if(t) printf("yes,%d\n",a[i][max]);
    	else  printf("no");
    }
    4,矩阵的周边之和问题

    /*
    编写函数实现计算任意N*4整型矩阵上的周边元素之和
    假设输入的数值
    1  2  3  4
    5  6  7  8
    9  10 11 12
    13 14 15 16
    */
    #include<stdio.h>
    #define N 3
    int fun(int a[][4],int n)
    {
    	int i,sum=0;
    	for(i=0;i<4;i++)
    		sum+=a[0][i]+a[n-1][i];   //第一行和最后一行的和,此时的i代表的是列数
    	for(i=1;i<n-1;i++)
    		sum+=a[i][0]+a[i][3];       //第一列的的第二行开始到 n-1行的     和最后一列的的第二行开始到 n-1行的,此时的i代表的是行数
    	return sum;
    }
    void main()
    {
    	int i,j;
    	int a[N][4];
    	for(i=0;i<N;i++)
    		for(j=0;j<4;j++)
    			scanf("%d",&a[i][j]);
    	int s=fun(a,N);
    	printf("矩阵N*4周边的元素之和为:%d",s);
    	printf("\n");
    }

    5.判断一个N*N的矩阵是否为对称矩阵,将原矩阵输出,判断结果输出

    #include<stdio.h>   
    #define N 10
    void main()  
    {  
        int a[N][N],i,j,k,n;
        scanf("%d",&n);
        for(i=0;i<n;i++)  
           for(j=0;j<n;j++)
              scanf("%d",&a[i][j]);
        for(i=0;i<n;i++)  
        {
             for(j=i+1;j<n;j++)
              {
                 if(a[i][j]==a[j][i])    k=1;
                 else   k=0;
              }
       }
       if(k=0)    printf("bushi");
       else       printf("shi\n");
       for(i=0;i<n;i++)  
          for(j=0;j<n;j++)
             printf("%d",a[i][j]);
    }
    
    6,求一个4*3的矩阵各行元素的最大值,将原矩阵和求出的最大值全部输出

    #include<stdio.h>
    void main()  
    {  
        int a[4][3],s[4],i,j,k;  
        for(i=0;i<4;i++)  
             for(j=0;j<3;j++)
                scanf("%d",*(a+i)+j);  
      
        for(i=0;i<4;i++)  
         { 
           *(s+i)= *(*(a+i));  
             for(j=1;j<3;j++)  
               if(*(s+i) < *(*(a+i)+j))  
                  *(s+i)= *(*(a+i)+j);  
          }  
      
        for(i=0;i<4;i++)  
         {
            printf("Row=%d Max=%d",i,s[i] );  
            printf("\n");  
         }  
    }
    

    7,求一个3*5的矩阵各列元素的最大值,将原矩阵和求出的最大值全部输出

    #include<stdio.h>
    void main()  
    {  
     int a[3][5],s[3],i,j,k;  
     for(i=0;i<3;i++)  
     for(j=0;j<5;j++)
      scanf("%d",*(a+i)+j);  
      
     for(i=0;i<3;i++)  
     { *(s+i)= *(*(a+j));  
     for(j=1;j<5;j++)  
     if(*(s+i) < *(*(a+i)+j))  
     *(s+i)= *(*(a+i)+j);  
     }  
      
     for(i=0;i<3;i++)  
     {
      printf("Line=%d Max=%d",j,s[j] );  
     printf("\n");  
     }  
    

    8,求一个3*4的矩阵各列元素的平均值;将原矩阵和求出的平均值全部输出

    #include<stdio.h>
    void main()  
    {  
     int a[4][3],s[4],i,j,k;  
     for(i=0;i<4;i++)  
      for(j=0;j<3;j++)
       scanf("%d",*(a+i)+j);
      
      for(i=0;i<4;i++)
      {
       k=0;
       for(j=0;j<3;j++)
        k+=a[i][j];
       printf("第%d行的平均值是%d",i+1,k);
       printf("\n");
      }
    }
    

    9,求一个4*3的矩阵各行元素的平均值;将原矩阵和求出的平均值全部输出

    #include<stdio.h>
    void main()  
    {  
     int a[4][3],s[4],i,j,k;  
     for(i=0;i<4;i++)  
      for(j=0;j<3;j++)
       scanf("%d",*(a+i)+j);
      
      for(i=0;i<4;i++)
      {
       k=0;
       for(j=0;j<3;j++)
        k+=a[i][j];
       printf("第%d行的平均值是%d",i+1,k);
       printf("\n");
      }
    }
    



    展开全文
  • C语言排序算法.pdf

    2019-12-24 14:55:15
    C语言排序算法
  • C语言常见的排序算法进行了比较,对复杂度进行了分析
  • c语言常见算法程序

    2011-07-31 12:13:53
    C语言中常用的算法程序以及解释方便查找运用
  • C常见编程算法实例 C常见编程算法实例 C常见编程算法实例
  • C语言常用算法源代码

    2009-03-03 21:59:39
    C语言常用算法源代码:c语言常见各种算法源代码
  • c语言常用算法整理

    万次阅读 多人点赞 2019-02-26 10:10:57
    这里整理c语言常用算法,主要有: 交换算法 查找最小值算法 冒泡排序 选择排序 插入排序 shell排序 (希尔排序) 归并排序 快速排序 二分查找算法 查找重复算法 代码如下: //交换 void swap(int *a, int *b){ int ...
  • C语言中,有 5 种常用的算法描述方法:自然语言、流程图、N-S 图、伪代码和程序设计语言。1. 自然语言描述算法上一讲《算法是什么》中给出的解决问题的算法 a、算法 b 和算法 c 都是用自然语言来表示算法的(见上...
  • 常见排序算法的实现 (插入排序、shell排序、堆排序、冒泡排序、快速排序、归并排序)
  • 此书涵盖了C语言各种常见算法,经典算法,数据处理算法,图形输出算法。。。。。
  • c语言经典算法100例

    2011-11-07 18:52:18
    C语言经典算法100例,包含了常见算法
  • c语言常见的排序算法

    2019-05-09 20:43:21
    常见的排序算法 *排序算法有很多,所以在特定情景中使用哪一种算法很重要。为了选择合适的算法,可以 按照建议的 顺序考虑以下标准:①执行时间 ②存储空间 ③编程工作 对于数据量较小的情形,程序执行时间和...
  • C语言作为常见计算机编程程序,在计算计发展中有着重要作用。C语言不仅能实现不同数据类型的数据查找,同时也能实现不同而类型数据的排序,能使计算机更好的运行。在这种情况下,有必要对C语言排序算法进行分析...
  • 二级C语言上机考试常见算法
  • 3.交换法排序 #include<stdio.h> //头文件 int main(){//主函数 int i, j, n; int a[999]; int iTemp; //输入 printf("请输入需要排序的元素的个数:\n"); scanf("%d", &... i.
  • 这是博主很久之前学C语言的时候遇到的一个有关算法的问题,当时作为小白的博主做了很久才解决。 题目的大概意思是这样的: 有n个人,从1开始数数,数到三出局,问剩下那个人是谁 初见这道题的时候还是一头雾水的,但...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,313
精华内容 18,925
关键字:

c语言常见算法

c语言 订阅