算法设计之一些算法的实现

最新推荐文章于 2024-06-08 21:43:59 发布
最新推荐文章于 2024-06-08 21:43:59 发布
阅读量1.6k 收藏 2
点赞数
文章标签： 算法 function 数据结构 作业 struct class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SCHOLAR_II/article/details/1535368
版权

 算法设计

　　第一次作算法设计的作业，感觉还是有点难度的．虽然以前上＜＜数据结构＞＞的时候也写过不少的复杂算法，但都是于课本为中心改来改去的．所以没觉得有什么．但自己写算法感觉还不算，特有成就感，（虽然写得不是很好）．虽然方法与步骤不是很科学，但我觉得随着课程的深入学习，这方面会有所提高于规范化的．

　　最有体会的是数据结构与算法的那种密切联系的关系，还有是有用＂栈＂的思想来实现原本用递归来实现的算法，所得到的效果与好处，有时真是说不出good．大家就看看我所写的作业吧（一些实现的代码），代码所关的问题，大家可以去找算法的书，应该容易找到想关的主题的．希望大家多多指教呀！

 

/* 本程序利用霍纳规则计算型如：*/
/*p(x)=AnX*/
#include<iostream.h>
/* 函数1 （非递归算法）*/
double heNaFunction_1(double Array[], double x, int n);
/* 函数2 （递归算法）*/
double heNaFunction_2(double Array[], double x, int n, int tag);
/* 函数3 （' 栈' 算法）*/
double heNaFunction_3(double Array[], double x, int n);
/* 主函数*/
void main()
{
       /* 定义测试变量*/      
       double Array_a[6] = {1,2,3,4,5,6};/* 用于存放多项式的各个系数*/
       double b = heNaFunction_1(Array_a, 2.0, 5);/* 算多项式的值*/
       double c = heNaFunction_2(Array_a, 2.0, 5, 1);/* 算多项式的值*/
       double d = heNaFunction_3(Array_a, 2.0,5);/* 算多项式的值*/
       cout<<"***********"<<endl;
       cout<<b<<endl;/* 输出结果*/
       cout<<c<<endl;/* 输出结果*/
       cout<<d<<endl;/* 输出结果*/
       cout<<"###########"<<endl;
}
/*-------------------------------------------------------------*/
/* 函数的功能：利用霍纳规则计算多项式的值（非递归算法）*/
/* 函数返回值：多项式的计算结果（浮点数）*/
/* 函数参数 第一个：多项式按降幂顺序的对应系数（浮点型数组）*/
/*         第二个：多项式x 当前的数值（浮点数）*/
/*         第三个：多项式的最高次幂
/*-------------------------------------------------------------*/
double heNaFunction_1(double a[], double x, int n)
{
       double sum = 0;/* 存放多项式的总和*/
       sum = a[0]*x + a[1];/* 先计算利用霍纳规则化简后的最内式的值*/
       for(int i=2; i<=n; i++)/* 循环从内到外的计算总和（从霍纳表达式*/
       {                      /* 一层一层的算出总和）*/
              sum = sum*x +a[i];
       }
       return sum;/* 返回多项式的和*/
}
/*-------------------------------------------------------------*/
/* 函数的功能：利用霍纳规则计算多项式的值（递归算法）*/
/* 函数返回值：多项式的计算结果（浮点数）*/
/* 函数参数 第一个：多项式按降幂顺序的对应系数（浮点型数组）*/
/*         第二个：多项式x 当前的数值（浮点数）*/
/*         第三个：多项式的最高次幂*/
/*         第四个：递归的系数（赋值为1 ）（整型数）*/
/*-------------------------------------------------------------*/
double heNaFunction_2(double Array[], double x, int n, int tag)
{
       if(tag==n)/* 当递归次数到时停止（递归次数为多项系的最高次幂）*/
       {      
              cout<<"last"<<endl;/* 方便查看递归过程*/
              return (Array[0]*x + Array[1]);
       }
       else
       {      
              cout<<"mill"<<endl;/* 方便查看递归过程*/
              return (heNaFunction_2(Array, x, n, tag+1)*x + Array[n-tag+1]);
                      /* 递归调用------------------ 递归次数加1---- 上一层的系数*/
       }
}
 
/*-------------------------------------------------------------*/
/* 函数的功能：利用霍纳规则计算多项式的值（递归算法）*/
/* 函数返回值：多项式的计算结果（浮点数）*/
/* 函数参数 第一个：多项式按降幂顺序的对应系数（浮点型数组）*/
/*         第二个：多项式x 当前的数值（浮点数）*/
/*         第三个：多项式的单项式个数*/
/*        
/*-------------------------------------------------------------*/
double heNaFunction_3(double Array[], double x, int n)
{
       double temp = 0;
       for(int i=0;i<=n;i++)
       {
              temp = temp*x + Array[i];
       }
       return temp;
}
 
 
 
 
 
 
 
 
/* 本程序演示AckermannFunction 函数的计算过程*/
#include<iostream.h>
/* 函数声名*/
int AckermannFunction(int m, int n);
void main()
{
       int a = 0;
       a = AckermannFunction(2, 3);
       cout<<"AckermannFunction(2, 3)="<<a<<endl;
}
/*-------------------------------------------------------------*/
/* 函数的功能：计算Ackermann 函数的值（递归算法）*/
/* 函数返回值：Ackermann 函数的值（整型）*/
/* 函数参数 第一个：Ackermann 函数的第一个参数（整型）*/
/*         第二个：Ackermann 函数的第二个参数（整型）*/
/*-------------------------------------------------------------*/
int AckermannFunction(int m, int n)
{
       if(m==0)/* 递归结束的条件*/
              {
                     cout<<n+1<<endl;/* 方便查看过程*/
                     return (n+1);
              }     
       else if(n==0)/* 递归调用*/
              {    /* 方便查看过程*/
                     cout<<"AckermannFunction("<<m-1<<","<<1<<")"<<endl;
                     return AckermannFunction(m - 1,1);
              }
       else/* 递归调用*/
              {   /* 方便查看过程*/
                     cout<<"AckermannFunction("<<m-1<<","<<"AckermannFunction("<<m<<","
                     <<n-1<<") )"<<endl;
                     return AckermannFunction(m -1, AckermannFunction(m, n -1));
              }
}
 
/* 本程序用堆栈思想实现AckermannFunction 函数功能*/
/* 编者：Lgw*/
/* 专业：04 计本二*/
/* 日期：07/3/13*/
#include<iostream.h>
/* 函数声名*/
int AckermannFunction(int m, int n);
/* 主函数*/
void main()
{
       int a =AckermannFunction(2,3);/* 调试数据*/
       cout<<"AckermannFunction(2,3)="<<a<<endl;/* 打印过程*/
}
/*-------------------------------------------------------------*/
/* 函数的功能：计算AckermannFunction 函数*/
/* 函数返回值：函数的值（整型数）*/
/* 函数参数 第一个：函数的 m （整型数）*/
/* 函数参数 第二个：函数的 n （整型数）*/
/*-------------------------------------------------------------*/
int AckermannFunction(int m, int n)
{
       int a[100] ;/* 数组" 栈"++++ 看情况可以加大数组元素*/
       a[0]=m;/* 初使化*/
       a[1]=n;/* 初使化*/
       int i=1;/* 栈指针*/
       while(i!=0)
       {
              if(a[i-1]==0)/* 第一种情况*/
              {                     /*A(m,n)=n+1 当m=0*/
                     a[i-1]=a[i]+1;
                     i--;/* 出栈*/
              }
              else if(a[i]==0)/* 第二种情况*/
              {               /*A(m,n)=A(m-1,1)*/
                     a[i]=1;
                     a[i-1]=a[i-1]-1;
              }
              else
              {
                    int temp=a[i];/* 第三种情况 A （m, n ）=A(m-1,A （m,n-1 ）)*/
                    a[i]=a[i-1];
                    a[i-1]=a[i-1]-1;
                    i++;
                    a[i]=temp-1;
 
              }
 
              for(int k=0;k<=i;k++)/* 输出运算过程*/
                     cout<<a[k]<<" ";
              cout<<endl;
       }
       return a[0];
}
 
程序运行结果如同作业本上的运算过程~
 
/* 本程序用于演示鸽巢原理*/
#include<iostream.h>
/* 函数声名*/
double function(double x);
void geChaoFunction(double Array[], int n);
/* 主函数*/
void main()
{
       double Array_a[15];
       for(int i=0; i<15; i++)
              Array_a[i]=i;
       geChaoFunction(Array_a, 15);
}
 
/*-------------------------------------------------------------*/
/* 函数的功能：计算自定义的满足鸽巢原理的函数的值*/
/* 函数返回值：函数的值（浮点数）*/
/* 函数参数 第一个：函数的变量（浮点数）*/
/*-------------------------------------------------------------*/
double function(double x)
{
       return (x-6)*(x-6);/* 函数表达式y=(x-6)*(x-6)*/
}
/*-------------------------------------------------------------*/
/* 函数的功能：演示过程与结果*/
/* 函数返回值：无*/
/* 函数参数 第一个：变量数组（浮点型数组）*/
/*         第二个：变量个数（整型）*/
/*-------------------------------------------------------------*/
void geChaoFunction(double Array[], int n)
{
       for(int i=0; i<n; i++)
       {      for(int j=0; j<n; j++)
                     {       /* 如果a!=b 且f(a)==f(b) 就输出*/
                            if((function(Array[i])==function(Array[j]))&&(i!=j))
                            cout<<"f("<<Array[i]<<")=="<<"f("<<Array[j]<<")"<<endl;
                     }
       }
}
 
#include<iostream.h>
#define MaxSize_1 20
#define MaxSize_2 50
 struct CharStruct/* 用于存放子集*/
 {
       char A[MaxSize_1+1];
       int p;/* 用于记录子集中有多少个字符*/
 
 };
 class PowSet/* 用来指挥计算的类*/
 {
       public:
 
       CharStruct Set[MaxSize_2+1];
       int Set_number;/* 记录有多少个子集*/
 
       public:
 
       PowSet(char a)/* 构造函数*/
       {
              Set_number = 2;
              Set[1].A[1]= a;
              Set[2].A[1]= ' ';
              Set[1].p = 1;
              Set[2].p = 1;
       }
 
       void SetPlay()/* 打印函数*/
       {
              for(int i=1;i<=Set_number;i++)
              {
                     cout<<"(";
                     for(int k=1;k<=Set[i].p;k++)
                     {
                            cout<<Set[i].A[k]<<" ";
                     }
                     cout<<")"<<endl;
              }
       }
 
       void SetCopyItSelf()/* 自身的复印函数*/
       {
              int j=1;
              for(int i=Set_number+1;i<=2*Set_number;i++)
              {
                     for(int k=1;k<=Set[j].p;k++)
                     {
                            Set[i].A[k]=Set[j].A[k];
                  }
                  Set[i].p=Set[j].p;
                  j++;
              }
              Set_number = 2*Set_number;
       }
 
       void AddNumber(char a)/* 一个子集中加入一个符的函数*/
       {
              for(int i=1; i<=Set_number/2;i++)
              {
                     Set[i].A[Set[i].p+1]=a;
                     Set[i].p=Set[i].p+1;
              }
       }
 };
/*-------------------------------------------------------------*/
/* 函数的功能：计算一个集合的子集*/
/* 函数返回值：无*/
/* 函数参数 第一个：变量数组（整型数组）*/
/*         第二个：集合元数个数（整型）*/
/*-------------------------------------------------------------*/
 
void PowSetFunction(char a[], int n)/* 计算过程的函数*/
{
    PowSet myset(a[0]);
       for(int i=1;i<=n-1;i++)
       {
              myset.SetCopyItSelf();
              myset.AddNumber(a[i]);
       }
    myset.SetPlay();
 
       cout<<" 以上为(";
       for(int j=0;j<n;j++)
              cout<<a[j]<<" ";
       cout<<")"<<" 的子集"<<endl;
       cout<<" 一共有"<<myset.Set_number<<" 个"<<endl;
 
   
}
 
void main()
{
       char Char_Array[5]={'A','B','C','D','E'};/ 调试用的数据**/
       PowSetFunction(Char_Array, 5);
}
 
 
 
 
 
 
 
 

 

喜欢踢足球的老罗
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法设计与实现小结
x_xx_xxx_xxxx的博客
11-07 706
算法设计主要讲了什么？ 1.    基础的排序包含插入、冒泡、快排等。（提供给他自己会的信息） 2.    编程思想： a.    分治法 b.    动态规划 c.    贪心 d.    回溯（不会） e.    分支界限（不会）   插入实现： 维护一个有序数组或是一个有序链表。插的时候按顺序。 冒泡实现：        两层循环，内层遍历时将一个最大的放置尾部，外层
《算法设计与实现》
04-09
算法的设计与实现
一些重要的算法
热门推荐
陈皓专栏　【空谷幽兰，心如皓月】
07-22 10万+
本文罗列了一些比较重要的算法，有的我们经常在用，有的基本不用。有的很常见，有的有点偏。不过了解一下也是好事。也欢迎你留下你觉得有意义的算法。（原文：http://coolshell.cn/?p=2583）
算法设计与分析（基础简化版）
最新发布
qq_74755889的博客
06-08 1557
主要内容：算法概述、递归与分治策略、动态规划、贪心算法、回溯法、分支限界法、智能算法
实验二 预测分析算法的设计与实现
CooperNiu's Blog
11-17 8639
实验二 预测分析算法的设计与实现 （8学时） 一、实验目的 通过预测分析算法的设计与实现，加深对自上而下语法分析方法的理解，尤其是对自上而下分析条件的理解。 二、实验要求 输入文法及待分析的输入串，输出其预测分析过程及结果。 三、实验步骤 1. 参考数据结构 (1)/定义产生式的语法集结构/ typedef struct{ char formula[200];//产
7、算法设计(基础)
qq_44774198的博客
09-22 5011
算法设计：迭代、穷举搜索、递推、递归、回溯、贪心、动态规划、分治等算法设计。在算法设计中，主要考查动态规划法、分治法、回溯法、递归法、贪心法。
操作系统课程设计——页面置换算法模拟实现
02-24
设计目的：存储管理的主要功能之一是合理的分配空间。请求页式存储管理是一种常用的虚拟存储管理技术。通过对请求页式存储管理中页面置换算法的模拟设计，掌握请求页式存储管理页面置换算法，并进一步理解虚拟存储...
python 实现hash 哈希算法 课程设计
05-19
python 实现hash 哈希算法 课程设计 . 包括实现 Adler32 Chaos Machine Djb2 Elf Enigma Machine Hamming Code Luhn Md5 Sdbm Sha1 Sha256 阿德勒32 混沌机器 DJB2 小精灵 谜机 海明码 卢恩 MD...
基于C++的分水岭算法设计与实现
05-13
基于C++的分水岭算法设计与实现
CPU调度算法的模拟实现课程设计.doc
05-05
CPU 调度算法的模拟实现课程设计 本课程设计旨在通过编写程序语言，模拟实现四种 CPU 调度算法：先到先服务算法（FCFS）、非抢占最短作业优先算法（SJF）、可抢占优先权调度算法（PRIOR）和时间片轮转算法（RR）。...
RSA算法设计与实现.pdf
05-16
RSA算法设计与实现 RSA算法是目前最广泛使用的公钥加密算法之一，其设计和实现涉及到大数运算、同余方程求解、模幂运算和大素数获取等关键技术。以下是RSA算法设计与实现的详细知识点： 一、大数存储和运算 RSA...
算法设计TSP问题的四种算法实现
06-01
算法设计中的TSP问题的蛮力法、动态规划法、贪心法及回溯法。
算法设计——算法设计
04-28
算法设计 算法设计 算法设计 算法设计 算法设计 算法设计 算法设计
如何设计算法
Kemin | 本博客独立到nakeman.cn
01-03 4836
如何设计算法摘自：《The Algorithm Design Manual 》刘建文略译（http://blog.csdn.net/keminlau）How to Design Algorithms Designing the right algorithm for a given application is a difficult job. It requires a maj
开方算法的设计与实现
一点一滴铺就人生
09-30 1366
1.算法原理 使用二分法对开方进行运算。 2.算法描述 采用small进行标记开方结果所在区域的最小值，采用bigger进行标记开方结果所在区域的最大值，运用二分法对开方结果所在区域，进行缩小（逼近），再运用while循环实现对开方结果精确度进行控制；最后再主函数中用scanner方法从键盘上输入被开方数x，即可求解； 3.算法实现 importjava.util.Scanner...
一些算法
lusic01的专栏
02-19 127
0，动态/时序推荐系统 （跨模态）语义匹配/检索 深度/强化学习 贝叶斯/统计学习 AutoML 1，很久以前，我用过TFIDF做过行业关键词提取。TFIDF仅仅从词的统计信息出发，而没有充分考虑词之间的语义信息。现在本文将介绍一种考虑了相邻词的语义关系、基于图排序的关键词提取算法TextRank。 2，fasttext和Word2vec 相似处：     图模型结构很像，都是采用embedd...
实现算法
CSDN_LYY的专栏
09-29 449
在平时的工作和学习中，使用直接封装好的代码框架是大多数人的选择，最明显的例子，比如在使用机器学习算法的时候，多数人会直接使用scikit-learn框架，这是一个优秀的、知名度最高的机器学习框架；在使用深度学习算法的时候，多数人会直接使用tensorflow或者pytorch框架，它们是知名度很高的深度学习框架等等。相似的例子还有很多，这些框架都是由世界上排的上名的、有名的工程师或者程序员编写的，...
简单一些算法
°Destiny
08-17 209
#include<iostream> using namespace std;void move(char from, char to) { cout << from << "---->" << to << endl; } void haoi(int n, char a, char b, char c) { if (1 == n) { move(a, c);
算法设计
a1058420631的博客
06-20 507
方法 试用情况 分治法 各子问题独立 动态规划 各子问题重叠 1.分治 分治算法能解决问题的特征: –问题规模缩小到一定的程度可以容易地解决 –问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质 –利用该问题分解出的子问题的解可以合并为该问题的解 –该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题 解题步骤： – 划分阶段的时间复杂性...
算法设计与实现的基本概念
算法设计与算法搜集 算法是解决问题的清晰指令，能够在有限...同时，我们还可以看到一些数学公式和符号的应用，如函数f(x)=0、g(x)=x、 fabs(x0-x1)>Epsilon等，这些公式和符号都是算法设计和搜集中的重要组成部分。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值