精华内容
下载资源
问答
  • C语言算法之将十进制数转换成二进制数

    万次阅读 多人点赞 2018-06-20 14:35:29
    导语:在C语言没有将其他进制的数直接输出为二进制数的工具或方法,输出为八进制数可以用%o,输出为十六进制可以用%x,输出为二进制就要我们自行解决了。下面给大家讲述一下如何编程实现将十进制数转换成二进制数...

    导语:在C语言中没有将其他进制的数直接输出为二进制数的工具或方法,输出为八进制数可以用%o,输出为十六进制可以用%x,输出为二进制就要我们自行解决了。下面给大家讲述一下如何编程实现将十进制数转换成二进制数。

    原文的实现方式太年轻了,是我大一的时候写的。由于太多小伙伴被『溢出』困扰(在溢出的情况下原文的实现就不灵了),补充下面这种最佳的实现方式。

    最佳的方式是利用栈先进后出的特性,计算每一位(0或1)压入栈中,再将所有元素出栈得到的01串就是目标二进制数。以下为C++实现代码,想用C语言实现的可以进行相应的改造,用数组实现一个栈,用字符数组实现字符串。

    #include <iostream>
    #include <stack>
    
    using namespace std;
    
    string transfer(int x) {
        if (x == 0) {
            return "0";
        }
        string ret;
        stack<char> st;
        while (x > 0) {
            if (x % 2 == 1) {
                st.push('1');
            } else {
                st.push('0');
            }
            x /= 2;
        }
        while (!st.empty()) {
            ret.push_back(st.top());
            st.pop();
        }
        return ret;
    }
    
    int main() {
        int x;
        cin >> x;
        cout << transfer(x) << endl;
        return 0;
    }

    下面是大一时候的实现,没有考虑溢出的问题,对于不懂栈的同学可以看一下。

    先将源代码展示给大家:

    #include <stdio.h>
    void main()
    {
        //进制转换函数的声明
        int transfer(int x);
        int x;
        printf("请输入一个十进制数:");
        scanf("%d",&x);
        printf("转换成二进制数是:%d\n",transfer(x));
    }
    int transfer(int x)
    {
        int p=1,y=0,yushu;
        while(1)
        {
            yushu=x%2;
            x/=2;
            y+=yushu*p;
            p*=10;
            if(x<2)
            {
                y+=x*p;
                break;
            }
        }
        return y;
    }

    具体算法体现在函数体内,使用了一个while(1)的死循环,当结果产生后跳出循环。变量yushu是每一次循环内产生的余数,变量x每次循环都会被赋予新的值,这个新的值就是每一次循环内产生的商。当产生的商小于2时即产生了最后的结果(二进制数),然后跳出循环。

    例如:函数自变量若为7,用自变量7除以2,得到第一次循环产生的余数为1,第一次循环产生的商为3;用第一次循环产生的商3除以2,得到第二次循环产生的余数为1,第二次循环产生的商为1。

    变量y的存放也是有一定技巧的,由于每次产生的余数都小于2并且都是最后二进制数中需要按位展现出来的,因此每一次循环产生的余数都要合理地进行存放。第一次产生的余数放在个位,第二次产生的余数放在十位,第三次产生的余数放在百位......依次类推,直至某一次循环产生的商小于2,最后再把小于2的那个商放在最高位。变量p的作用就是控制位数,变量y的初始值定为0,变量p的初始值定为1,每次循环内变量p都自乘10,每次循环内都让变量y加上yushu*p,这样就实现了余数的按位存放。最后将小于2的那个商乘以p加到变量y中,得到最后的二进制数。

    例如:还是以自变量7为例,第一次循环后y的值为1,第二次循环内if语句之前y的值为11,if语句内y的值变为111,111即为7的二进制数。

    注意:变量p的自乘要放在变量y加上yushu*p之后!顺序不能颠倒!

    欢迎大家关注/订阅我的微信公众号Code Art Online,我会在我的公众号分享个人见闻,发现生活趣味;这里不仅有0和1,还有是诗和远方↓↓↓

    展开全文
  • 输入一个排好序的数组的一个旋转,输出旋转数组的最小元素。例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转,该数组的最小值为1。  思路:这道题最直观的解法并不难。从头到尾遍历数组一次,就能找出最小的...
  • 生成前n个自然数的一个随机置换题目要求背景要求的算法注意事项代码实现输出示例 题目要求 背景 假设要生成前n个自然数的一个随机置换,如{4,3,1,5,2}和{3,1,4,2,5}就是一个合法置换; 但{5,4,1,2,1}就不是,因为1...

    题目要求

    背景

    假设要生成前n个自然数的一个随机置换,如{4,3,1,5,2}和{3,1,4,2,5}就是一个合法置换;
    但{5,4,1,2,1}就不是,因为1出现2次而3没有。假设我们有一个随机数生成器RandInt(i,j),它以相同概率生成i到j之间的整数,闭区间,可以取到i与j。
    下面是三个算法。
    (1) 如下填入从A[0]到A[N-1]的数组A:为了填入A[i],生成不同于A[0],A[1],…,A[i-1]之间的随机数时,才将其填入A[i]
    (2) 同算法1,但保留一个称为Used数组的附加数组,当一个随机数Ram最初被放入数组A的时候,Used[Ram]=1.这就是说,
    当用一个随机数填入A[i]时,用Used数组来测试该随机数是否已经被使用。
    (3) 首先填写数组使得A[i]=i+1;然后
    For(i=1;i<N;i++)
      Swap(&A[i],&A[RandInt(0,i)])

    要求的算法

    要求实现以上三个算法的函数:(1对应(1)中的算法,请务必不要弄混)
    void RandomPermutation1(int n);
    void RandomPermutation2(int n);
    void RandomPermutation3(int n);

    在函数中输出为前n个自然数的一个随机置换,用逗号分隔

    注意事项

    1、逗号为英文输入法的逗号;
    2、输入n不为正整数时,输出error
    3、每个函数输出结果之后再输出回车

    代码实现

    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    extern int RandInt(int i, int j)
    {
    	int m;
    	m = i + rand() % (j - i + 1);
    	return m;
    }
    void RandomPermutation1(int n);
    void RandomPermutation2(int n);
    void RandomPermutation3(int n);
    int n;
    int main()
    {
    	srand((unsigned)time(NULL));
    	scanf_s("%d", &n);
    	if (n <= 0) { printf("error");exit(-1); }
    	RandomPermutation1(n);
    	RandomPermutation2(n);
    	RandomPermutation3(n);
    	return 0;
    }
    void RandomPermutation1(int n)
    {
    	int x;
    	int* a = NULL;
    	if (n <= 0) { printf("error");exit(-1); }
    	a = (int*)malloc(sizeof(int) * n);
    	if (NULL == a) { printf("error");exit(-1); }
    	for (int i = 0;i < n;i++)
    	{
    		x = RandInt(1, n);
    		for (int j = 0;j < i;j++)
    		{
    			if (x == a[j])
    			{
    				x = RandInt(1, n);
    				j = -1;
    			}
    		}
    		a[i] = x;
    	}
    	for (int i = 0;i < n;i++)
    	{
    		printf("%d,", a[i]);
    		if (i == n - 1)printf("\n");
    	}
    }
    void RandomPermutation2(int n)
    {
    	int x;
    	if (n <= 0) { printf("error");exit(-1); }
    	int* b = NULL;
    	b = (int*)malloc(sizeof(int) * n);
    	if (NULL == b) { printf("error");exit(-1); }
    	int* used = NULL;
    	used = (int*)malloc(sizeof(int) * n);
    	if (NULL == used) { printf("error");exit(-1); }
    	for (int i = 1;i <= n;++i) used[i] = 0;
    	for (int i = 0;i < n;i++)
    	{
    		x = RandInt(1, n);
    		while (used[x] != 0)
    			x = RandInt(1, n);
    		b[i] = x;
    		used[x] = 1;
    	}
    	for (int i = 0;i < n;i++)
    	{
    		printf("%d,", b[i]);
    		if (i == n - 1)printf("\n");
    	}
    }
    void swap(int& m, int& n)
    {
    	int x = m;
    	m = n;
    	n = x;
    }
    void RandomPermutation3(int n)
    {
    	int* c = NULL;
    	if (n <= 0) { printf("error");exit(-1); }
    	c = (int*)malloc(sizeof(int) * n);
    	if (NULL == c) { printf("error");exit(-1); }
    	for (int i = 0;i < n;i++)
    	{
    		c[i] = i + 1;
    	}
    	for (int i = 1;i < n;i++)
    	{
    		swap(c[i], c[RandInt(0, i)]);
    	}
    	for (int i = 0;i < n;i++)
    	{
    		printf("%d,", c[i]);
    		if (i == n - 1)printf("\n");
    	}
    }
    

    输出示例

    展开全文
  • C语言之基本算法43—总结

    千次阅读 2015-07-15 00:39:50
    C程序的基本算法共涵盖42个例题,包含了枚举、排列、逻辑判断、迭代、递推、字符串操作、矩阵操作、格式输出等内容。 相关的实现方法有的显得很笨拙,但足够说明问题,而且每个程序都经过作者亲测,保证可以运行。之...

    C程序的基本算法共涵盖42个例题,包含了枚举、排列、逻辑判断、迭代、递推、字符串操作、矩阵操作、格式输出等内容。

    相关的实现方法有的显得很笨拙,但足够说明问题,而且每个程序都经过作者亲测,保证可以运行。之所以称之为基本算法,就是为了测试基础知识的掌握,都是从原始的角度进行处理,没有运用过于花哨的处理技巧,作者也是在学习中进步,也希望这些代码对于没有基础或者基础薄弱的朋友带来帮助。

    至此,基本知识就掌握了,我们常常会听说C的强大,因为它是面向过程的,在数学领域具有极好的应用,有必要进行进一步的学习。

    所以作者还会推出至少两个系列的文章,一是函数,二是文件操作,希望在接下来的日子里,朋友们能够共同进步。

    不积跬步无以至千里!共勉!



    二〇一五年七月十五日  夜

    附:

     

    C语言之基本算法32—鞍点

     阅读(353) 评论(0) 编辑 删除


    作者声明:以上文章可以被非商用转载,对于文章中的错误在此免责。

    展开全文
  • 本文偏重于算法原理的理解及C语言编程实现,最终输出的图像完全与OpenCV处理的一模一样,更详细的原理简介,可以参考网上其他文章 一 canny 原理简介 canny 算法是迄今为止最为优秀的边缘检查算法,它主要基于三个...

    本文偏重于算法原理的理解及C语言编程实现,最终输出的图像完全与OpenCV处理的一模一样,更详细的原理简介,可以参考网上其他文章

    一 canny 原理简介

    canny 算法是迄今为止最为优秀的边缘检查算法,它主要基于三个目标:

    1、低错误率。所谓的低错误率就是所有的边缘都应该被找到,并且没有伪边缘。也就是检查到的边缘必须尽可能是真实的边缘。

    2、边缘点应被很好第定位。也就是检查到的边缘点,必须尽可能的定位准确。应该更逼近真实边缘的中心。

    3、单一的边缘点响应。也就是标记出来的边缘必须窄(单点连接而成)。不应该过宽。

    要实现上面三个目标,可以使用一下方式来实现:

    1、使用滞后阀值(双阀值)来处理,可以达到低错误率的要求。

    2、使用非极大值抑制,可以实现边缘的单一响应及很好的定位。

    所以 canny 算法使用了一下步骤:

    二 canny 实现步骤

    1、高斯滤波,一般用5x5的核进行滤波。

    2、sobel 求出梯度幅值,同时求出梯度方向(0°,45°,90°,135°)

    3、非极大值抑制

    4、滞后阀值处理

    三 代码

    本代码基于C 语言实现。因为最后要把算法移植到FPGA进行加速,所以主要用于实现和理解算法逻辑,并非最优代码

    本算法模块,默认输入图像已经被高斯平滑过,所以省去高斯滤波这一块。

     

    #include"include.h"
    
    /*****************************************************************
    void fpga_canny(cv::Mat src, cv::Mat dst, uchar sel,uchar maxVal,uchar minVal)
    功能:
    	Canny 算法
    参数:
    	cv::Mat srcImg
    		输入图像,已经过高斯处理
    	cv::Mat dstImg
    		输出图像
    	uchar sel
    		sobel 输出图像边缘 1=标准sobel,0=双边缘
    	uchar maxVal
    		最大阈值
    	uchar minVal
    		最小阈值
    返回值:
    无
    ****************************************************************/
    
    
    
    void fpga_canny(cv::Mat src, cv::Mat dst, uchar sel, uchar maxVal, uchar minVal)
    {
    
    	unsigned int rows = src.rows;
    	unsigned int cols = src.cols;
    	unsigned int x1, x2, y1, y2, Gout;
    	unsigned int x_abs, y_abs;
    	unsigned int x_abs_dir, y_abs_dir;
    	float tan_225 = 0.4142;
    	float tan_675 = 2.4142;
    	float tmp;
    	unsigned char theta; // 0 = 0 度,1 = 45度,2 = 90度,3 = 135度
    	unsigned char Gx_s;// Gx 符号 0= 正, 1= 负; 
    	unsigned char Gy_s;// Gy 符号 0= 正, 1= 负;
    	unsigned char buff3x3[9];
    	unsigned char value;
    
    	//cv::Mat nonMaxImg = cv::Mat::zeros (src.rows, dst.cols, CV_16UC1);//存放 nonMax
    	cv::Mat nonMaxImg(src.rows, dst.cols, CV_16UC1);//存放 nonMax
    	cv::Mat sobelImg(src.rows, dst.cols, CV_16UC1);//存放 sobel
    	cv::Mat dirImg(src.rows, dst.cols, CV_8UC1);//存放梯度方向
    
    
    	cv::Mat sobelImg_show;
    	cv::Mat nonMaxImg_show;
    	 
    	
    	// sobel 求梯度
    	for (unsigned int y = 2; y< rows -1; y++)
    	{
    
    		for (unsigned int x = 2; x < cols -1 ; x++)
    		{
    			x1 = src.at<unsigned char>(y - 1, x - 1)
    				+ src.at<unsigned char>(y, x - 1) * 2
    				+ src.at<unsigned char>(y + 1, x - 1);
    
    			x2 = src.at<unsigned char>(y - 1, x + 1)
    				+ src.at<unsigned char>(y, x + 1) * 2
    				+ src.at<unsigned char>(y + 1, x + 1);
    
    			y1 = src.at<unsigned char>(y - 1, x - 1)
    				+ src.at<unsigned char>(y - 1, x) * 2
    				+ src.at<unsigned char>(y - 1, x + 1);
    
    			y2 = src.at<unsigned char>(y + 1, x - 1)
    				+ src.at<unsigned char>(y + 1, x) * 2
    				+ src.at<unsigned char>(y + 1, x + 1);
    
    			if (x1 > x2)
    			{
    				if (sel)
    				{
    					x_abs = 0;
    				}
    				else
    				{
    					x_abs = x1 - x2;
    				}
    
    				Gx_s = 1;
    				x_abs_dir = x1 - x2;
    				
    
    
    			}
    			else
    			{
    				x_abs = x2 - x1;
    
    				Gx_s = 0;
    				x_abs_dir = x2 - x1;
    				
    			}
    
    
    
    			if (y1 > y2)
    			{
    				if (sel)
    				{
    					y_abs = 0;
    				}
    				else
    				{
    					y_abs = y1 - y2;
    				}
    
    				Gy_s = 1;
    				y_abs_dir = y1 - y2;
    			}
    			else
    			{
    				y_abs = y2 - y1;
    
    				Gy_s = 0;
    				y_abs_dir = y2 - y1;
    			}
    
    			Gout = x_abs + y_abs;
    			if (Gout > 255)
    			{
    				//Gout = 255;
    			}
    
    
    			sobelImg.at<unsigned short>(y, x) = Gout;
    
    			// 求梯度方向
    			tmp = (float)y_abs_dir / (float)x_abs_dir;
    
    			if (tmp < tan_225)
    			{
    				theta = 0;
    			}
    			else if (tmp > tan_675)
    			{
    				theta = 2;
    			}
    			else
    			{
    				if (Gy_s == Gx_s)
    				{
    					theta = 1;
    				}
    				else
    				{
    					theta = 3;
    				}
    
    			}
    
    			dirImg.at<unsigned char>(y, x) = theta;
    
    
    		}
    
    	}
    
    
    	sobelImg.convertTo(nonMaxImg_show, CV_8UC1);
    	cv::imshow("fpga_canny_sobel", sobelImg);
    	cv::imwrite("fpga_canny_sobel.bmp", sobelImg);
    
    
    	//非极大值抑制
    	for (unsigned int y = 2; y< rows -1; y++)
    	{
    		for (unsigned int x = 2; x < cols -1; x++)
    		{
    			theta = dirImg.at<unsigned char>(y, x);
    
    			switch (theta)
    			{
    			case 0:
    				if ((sobelImg.at<unsigned short>(y, x - 1) < sobelImg.at<unsigned short>(y, x)) && (sobelImg.at<unsigned short>(y, x) >= sobelImg.at<unsigned short>(y, x + 1)))
    				{
    					nonMaxImg.at<unsigned short>(y, x) = sobelImg.at<unsigned short>(y, x);
    					
    				}
    				else
    				{
    					nonMaxImg.at<unsigned short>(y, x) = 0;
    					
    				}
    			
    					
    				break;
    			case 3:
    
    				if ((sobelImg.at<unsigned short>(y + 1, x - 1) < sobelImg.at<unsigned short>(y, x)) && (sobelImg.at<unsigned short>(y, x) > sobelImg.at<unsigned short>(y - 1, x + 1)))
    				{
    					nonMaxImg.at<unsigned short>(y, x) = sobelImg.at<unsigned short>(y, x);
    				}
    				else
    				{
    					nonMaxImg.at<unsigned short>(y, x) = 0;
    				}
    
    
    				break;
    			case 2:
    				if ((sobelImg.at<unsigned short>(y - 1, x) < sobelImg.at<unsigned short>(y, x)) && (sobelImg.at<unsigned short>(y, x) >= sobelImg.at<unsigned short>(y + 1, x)))
    				{
    					nonMaxImg.at<unsigned short>(y, x) = sobelImg.at<unsigned short>(y, x);
    				}
    				else
    				{
    					nonMaxImg.at<unsigned short>(y, x) = 0;
    				}
    
    				break;
    			case 1:
    
    				if ((sobelImg.at<unsigned short>(y - 1, x - 1) < sobelImg.at<unsigned short>(y, x)) && (sobelImg.at<unsigned short>(y, x) > sobelImg.at<unsigned short>(y + 1, x + 1)))
    				{
    					nonMaxImg.at<unsigned short>(y, x) = sobelImg.at<unsigned short>(y, x);
    				}
    				else
    				{
    					nonMaxImg.at<unsigned short>(y, x) = 0;
    				}
    
    				break;
    			}
    				 
    
    		}
    
    	}
    
    
    	//unsigned int dis_y,dis_x;
    	//dis_y = 216;
    	//dis_x = 398;
    	//printf("-----------src------------\r\n");
    	//printf("%x,%x %x \r\n", src.at<uchar>(dis_y - 1, dis_x - 1), src.at<uchar>(dis_y - 1, dis_x), src.at<uchar>(dis_y - 1, dis_x + 1));
    	//printf("%x,%x %x \r\n", src.at<uchar>(dis_y, dis_x - 1), src.at<uchar>(dis_y, dis_x), src.at<uchar>(dis_y, dis_x + 1));
    	//printf("%x,%x %x \r\n", src.at<uchar>(dis_y + 1, dis_x - 1), src.at<uchar>(dis_y + 1, dis_x), src.at<uchar>(dis_y + 1, dis_x + 1));
    
    	//printf("-----------sobelImg------------\r\n");
    	//printf("%x,%x %x \r\n", sobelImg.at<unsigned short>(dis_y - 1, dis_x - 1), sobelImg.at<unsigned short>(dis_y - 1, dis_x), sobelImg.at<unsigned short>(dis_y - 1, dis_x + 1));
    	//printf("%x,%x %x \r\n", sobelImg.at<unsigned short>(dis_y    , dis_x - 1), sobelImg.at<unsigned short>(dis_y    , dis_x), sobelImg.at<unsigned short>(dis_y    , dis_x + 1));
    	//printf("%x,%x %x \r\n", sobelImg.at<unsigned short>(dis_y + 1, dis_x - 1), sobelImg.at<unsigned short>(dis_y + 1, dis_x), sobelImg.at<unsigned short>(dis_y + 1, dis_x + 1));
    	//
    	//printf("-----------dirImg------------\r\n");
    	//printf("%x,%x %x \r\n", dirImg.at<uchar>(dis_y - 1, dis_x - 1), dirImg.at<uchar>(dis_y - 1, dis_x), dirImg.at<uchar>(dis_y - 1, dis_x + 1));
    	//printf("%x,%x %x \r\n", dirImg.at<uchar>(dis_y, dis_x - 1), dirImg.at<uchar>(dis_y, dis_x), dirImg.at<uchar>(dis_y, dis_x + 1));
    	//printf("%x,%x %x \r\n", dirImg.at<uchar>(dis_y + 1, dis_x - 1), dirImg.at<uchar>(dis_y + 1, dis_x), dirImg.at<uchar>(dis_y + 1, dis_x + 1));
    
    	//printf("-----------nonMaxImg------------\r\n");
    	//printf("%x,%x %x \r\n", nonMaxImg.at<unsigned short>(dis_y - 1, dis_x - 1), nonMaxImg.at<unsigned short>(dis_y - 1, dis_x), nonMaxImg.at<unsigned short>(dis_y - 1, dis_x + 1));
    	//printf("%x,%x %x \r\n", nonMaxImg.at<unsigned short>(dis_y    , dis_x - 1), nonMaxImg.at<unsigned short>(dis_y    , dis_x), nonMaxImg.at<unsigned short>(dis_y    , dis_x + 1));
    	//printf("%x,%x %x \r\n", nonMaxImg.at<unsigned short>(dis_y + 1, dis_x - 1), nonMaxImg.at<unsigned short>(dis_y + 1, dis_x), nonMaxImg.at<unsigned short>(dis_y + 1, dis_x + 1));
    
    
    
    
    
    	
    	nonMaxImg.convertTo(nonMaxImg_show, CV_8UC1);
    	cv::imshow("nonMaxImg", nonMaxImg_show);
    	cv::imwrite("fpga_canny_nonMaxImg.bmp", nonMaxImg_show);
    
    
    
    	//边缘标记, 这里最优的办法应该用栈的操作来实现。这里只是为了便于理解
    	cv::Mat flgImg(src.rows, src.cols, CV_8UC1);//存放标记 0=不是是边缘,1=可能是边缘,2=是边缘
    	uchar *stack[65536];// 存放 边缘点的地址
    	uchar **p_stack_top;
    	uchar **p_stack_bottom;
    	unsigned short *p_nonMax;//指向非极大值处理后的图像
    	uchar *p_flgImg;
    
    	memset(&stack[0], 0,sizeof(stack));
    	p_stack_top = &stack[0];
    	p_stack_bottom = &stack[0];
    
    	p_nonMax = (unsigned short*)nonMaxImg.data;
    	p_flgImg = flgImg.data ;
    
    
    	for (unsigned int y = 2; y< rows - 1; y++)
    	{
    		for (unsigned int x = 2; x < cols - 1; x++)
    		{
    
    			if (*(p_nonMax + y*cols + x) <= minVal)					// 当前像素小于极大值
    			{
    				*(p_flgImg + y*cols + x) = 0;						// 不是边缘点
    			}
    			else if (*(p_nonMax + y*cols + x) > maxVal				// 当前像素大于极大值
    					&& (*(p_nonMax + (y - 1)*cols + x) <= maxVal)	//上一个像素不是边缘点
    					&& (*(p_nonMax + y*cols + x -1) <= maxVal)		// 前一个像素不是边缘点
    					)	
    			{
    				
    				*(p_flgImg + y*cols + x) = 2;						// 标记为边缘点(起点)
    				*p_stack_top = (p_flgImg + y*cols + x);				
    				p_stack_top++;
    
    			}
    			else
    			{
    				*(p_flgImg + y*cols + x) = 1;						// 可能是边缘点
    			}
    	
    		}
    
    	}
    
    	cv::imshow("flgImg", flgImg);
    
    	 更新标记,对可能是边缘的点进行处理(边缘追踪)
    	uchar  *p_tmp;
    	while (p_stack_top - p_stack_bottom)
    	{
    		p_stack_top--;
    		p_tmp = *p_stack_top;
    		
    		if (*(p_tmp - cols - 1) == 1)
    		{
    			*p_stack_top = p_tmp - cols - 1;
    			*(p_tmp - cols - 1) = 2;
    			p_stack_top++;
    			
    		}
    		if (*(p_tmp - cols) == 1)
    		{
    			*p_stack_top = p_tmp - cols ;
    			*(p_tmp - cols) = 2;
    			p_stack_top++;
    
    		}
    
    		if (*(p_tmp - cols + 1) == 1)
    		{
    			*p_stack_top = p_tmp - cols + 1;
    			*(p_tmp - cols + 1) = 2;
    			p_stack_top++;
    
    		}
    		if (*(p_tmp - 1) == 1)
    		{
    			*p_stack_top = p_tmp  - 1;
    			*(p_tmp - 1) = 2;
    			p_stack_top++;
    		}
    
    		if (*(p_tmp + 1) == 1)
    		{
    			*p_stack_top = p_tmp + 1;
    			*(p_tmp + 1 ) = 2;
    			p_stack_top++;
    		}
    		if (*(p_tmp + cols - 1) == 1)
    		{
    			*p_stack_top = p_tmp + cols - 1;
    			*(p_tmp + cols - 1) = 2;
    			p_stack_top++;
    		}
    		if (*(p_tmp + cols) == 1)
    		{
    			*p_stack_top = p_tmp + cols ;
    			*(p_tmp + cols) = 2;
    			p_stack_top++;
    		}
    		if (*(p_tmp + cols + 1) == 1)
    		{
    			*p_stack_top = p_tmp + cols + 1;
    			*(p_tmp + cols + 1) = 2;
    			p_stack_top++;
    		}
    
    
    	}
    
    	生成边缘图像
    	uchar *p_dstImg;
    	p_dstImg = dst.data;
    	for (unsigned int y = 2; y< rows - 1; y++)
    	{
    		for (unsigned int x = 2; x < cols - 1; x++)
    		{
    
    			if (*(p_flgImg + y*cols + x) == 2)
    			{
    				*(p_dstImg + y*cols + x) = 255;
    			}
    			else
    
    			{
    				*(p_dstImg + y*cols + x) = 0;
    			}
    		
    
    		}
    
    	}
    
    
    
    	cv::imshow("fpga_canny_Dst", dst);
    	cv::imwrite("fpga_canny_Dst.bmp", dst);
    
    
    
    }
    640x480原图
    640x480 sobel 图像
    640x480 非极大值抑制图
    生成的 640x480 Canny 图

     

    Opencv   的canny 图

     

     

     

    因能力所限,难免有理解不到位之处,欢迎大家批评指正

    更多分享,请关注微信公众号:FPGA历险记

     

     

     

    展开全文
  • 试题 算法提高 快速幂java c语言实现

    多人点赞 2021-03-14 16:46:12
    试题 算法提高 快速幂 问题描述  给定A, B, P,求(A^B) mod P。...一个关键的公式为a^b%c =(a%c)^b%c 也就是说直接对底数取余对最后的结果没有影响 那我们可以通过指数减半底数翻倍 再底数%c的方式来缩小数据
  •  从前,有一只吃包子很厉害的猴子,它可以吃无数个包子,但是,它吃不同的包子速度也不同;肉包每秒钟吃x个;韭菜包每秒钟吃y个;没有馅的包子每秒钟吃z个;现在有x1个肉包,y1个韭菜包,z1个没有馅的包子;问:...
  • 1、 算法解题过程中,经常会遇到多组输入问题,如果是输入一个n表示n组测试数据,可以使用whlie(n–),注意输出的位置,如果是多组输入,没有限制几组,通常使用while(scanf("%d%d",a,b)==2) 或者while(scanf("%d",a)...
  • 现在的问题是,这些人有多少种排法,可以避免出现体育组没有冰鞋可租的尴尬场面。(两个同样需求的人(比如都是租鞋或都是还鞋)交换位置是同一种排法) 输入格式  两个整数,表示m和n 输出格式  一个整数,表示...
  • 已知一段code生产一条数据的时长...大家有没有好的算法呢。。。 如:生产一条数据用时10微秒,1秒就能输出100000条数据,我通过配置速率为20000条/秒,我可以在code中加个usleep,但是让它睡多久才能达到想要的效果呢?
  • 前序:好久没有C语言了,就是嫌弃C语言几乎所有的底层方法都要自己编码实现,对于业务逻辑的处理就不能更好的把控。但但是C语言确实对于提升编码能力是很有益的。今天应别人的要求,简单实现了一下,C的原生感很强...
  • 现在的问题是,这些人有多少种排法,可以避免出现体育组没有冰鞋可租的尴尬场面。(两个同样需求的人(比如都是租鞋或都是还鞋)交换位置是同一种排法) 输入格式  两个整数,表示m和n 输出格式...
  • 现在的问题是,这些人有多少种排法,可以避免出现体育组没有冰鞋可租的尴尬场面。(两个同样需求的人(比如都是租鞋或都是还鞋)交换位置是同一种排法) 输入格式  两个整数,表示m和n 输出格式  一个整数,表示...
  • 如果 pos 是 -1,则在该链表中没有环。注意,pos 仅仅是用于标识环的情况,并不会作为参数传递到函数中。 说明:不允许修改给定的链表。 进阶: 你是否可以不用额外空间解决此题? 示例 1: 输入:head = [3,2,0,-4...
  • C语言程序设计专复习题 一选择题 1以下选项中可作为C语言合法常量的是 A) -80 B) 080 C) -8e1.0 D) -80.0e 2以下叙述中正确的是 A) 用C语言实现的算法必须要有输入和输出操作 B) 用C语言实现的算法可以没有输出但...
  • C语言程序设计复习题 一选择题 1以下选项中可作为C语言合法常量的是 A) -80 B) -080 C) -8e1.0 D) -80.0e 2以下叙述中正确的是 A) 用C语言实现的算法必须要有输入和输出操作 B) 用C语言实现的算法可以没有输出但必须...
  • 现在的问题是,这些人有多少种排法,可以避免出现体育组没有冰鞋可租的尴尬场 面。(两个同样需求的人(比如都是租鞋或都是还鞋)交换位置是同一种排法) 输入格式  两个整数,表示m和n 输出格式 ...
  • C语言程序设计基础习题集 一选择填空 知识点1C程序的基本结构和算法基本概念 ...以下叙述中正确的是_ A用C程序实现的算法必须要有输入和输出操作 B用C程序实现的算法可以没有输出但必须要输入 C用C程序实现的算法可以没
  • C语言总复习

    2014-04-05 21:05:44
    概念常考到的: 1、编译预处理不是C语言的一部分,不再运行时间。C语言编译的程序称为源程序,它...4、算法的是一定要有输出的,他可以没有输入。 5、break可用于循环结构和switch语句。 6、逗号运算符的级别最低。
  • C语言易错点

    2018-12-10 23:30:00
    2.算法可以没有输入,但必须要有输出。 3.在函数中不可以再定义函数。 4.break可用于循环结构和switch语句。 5.break和continue的区别在于前者是跳出循环,后者是结束本次循环。 6.逗号的运算符的级别最低。 7....
  • 现在的问题是,这些人有多少种排法,可以避免出现体育组没有冰鞋可租的尴尬场面。(两个同样需求的人(比如都是租鞋或都是还鞋)交换位置是同一种排法) 输入格式  两个整数,表示m和n 输出格式  一...
  • c语言基础知识

    2012-07-26 12:27:59
    C语言知识点复习  1)程序结构是三种: 顺序结构 、选择结构(分支结构)、循环结构。  2)读程序都要从main()入口, 然后从最上面顺序往下读(碰到循环做循环,碰到选择做... 5、算法可以没有输入,但是一定要有输出
  • C语言的习题,二级考题,全部的汇编。(1)算法具有五个特性... B)用C程序实现的算法可以没有输出但必须要有输入  C)用C程序实现的算法可以没有输入但必须要有输出  D)用C程序实现的算法可以既没有输入也没有输出
  • C语言是面向过程的,而C++是面向...C++,首要考虑的是如何构造一个对象模型,让这个模型能够契合与之对应的问题域,这样就可以通过获取对象的状态信息得到输出或实现过程(事务)控制。 所以C与C++的最大区别在于...
  • 走迷宫C语言

    2014-12-17 13:24:22
    若走得通输出路径坐标,若走不通,请输出没有出口’。要求是用C语言编程,用栈来做。 第一步:自己设计一个迷宫,设置迷宫的长和宽,确定迷宫中每个坐标,确定入口坐标和出口坐标,确定那些方格可以走得通。 设定...
  • 原题链接 这道题的要点分别有: 插入的时候函数返回最后一个结点的指针,下次插入直接...因为这道题是有序的链表且要不减输出,所以我们在给出交集的时侯可以做如下判断 如果L1链当前的结点小于L2链的当前结点,L...
  • 顺序选择循环(分支)本章要求了解结构化程序的算法描述掌握...2确定性算法的每个步骤必须都是精确定义的无二义性的 3有效性算法中的每一个步骤必须有效地执行并能得到确定结果 4输入一个算法可以没有输入也可以有一个
  • C语言字符串详解

    2020-05-26 17:20:25
    本文将会讲解C语言字符串常用的各种函数,因为都是语法性的,没有算法,所以不会过多阐述。力求精简。 这是我第一篇正式文章,希望对你有所帮助! 一、初级用法 ①字符串的定义 本质是一个字符数组 法一:(一般不用)...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 155
精华内容 62
关键字:

c语言算法可以没有输出

c语言 订阅