算法设计流程

Ⅰ 制定一个算法一般要经历哪几个阶段

设计，确认，编码，检查，调试，计时等过程

Ⅱ 算法设计的过程一般是什么样子

和你做数学题目的过程一样，已知条件是什么？已知量是什么？要求什么？需要输出一个什么结果？

算法设计就是把问题解决步骤用计算机编程语言来表示出来

Ⅲ 其中算法设计所属的步骤是（ ）. A、① B、② C、③ D、①②

一般来说，用计算机解决一个具体问题时，大致经过以下几个步骤：首先要从具体问题抽象出一个适当的数学模型，然后设计一个解此数学模型的算法，最后编出程序进行测试调整知道的到最终解答。寻求数学模型的实质就是分析问题，从中提取操作的对象，并找出这些操作对象之间含有的关系，然后用数学的语言加以描述。

你自己看吧。

Ⅳ 请问程序设计的基本过程是怎样的

（1）分析需求：了解清楚程序应有的功能。

（2）设计算法：根据所需的功能，理清思路，排出完成功能的具体步骤，其中每一步都应当是简单的、确定的。这一步也被称为“逻辑编程”。

（3）编写程序：根据前一步设计的算法，编写符合C++语言规则的程序文本。

（4）输入与编辑程序：将程序文本输入到计算机内，并保存为文件，文件名后缀为“.cpp”。

至此，产生了完整的程序文本，被称为源程序或源代码。保存源程序的文件（例如前面的c:\student\ch1_01.cpp）称为源程序文件，简称源文件，文件名的后缀是“.cpp”。

（5）编译（Compile）：把C++程序编译成机器语言程序。

编译产生的程序称为目标程序，目标程序被自动保存为文件，这一文件称为目标文件，文件名的后缀是“.obj”。

VC++进行编译的依据是源程序，如果源程序中的符号、词语、整体结构等有差错，超出了VC++的“理解能力”，VC++就无法完成编译，这样的差错称为语法错误。一旦发现语法错误，VC++就不生成目标文件，并在窗口下方列出错误；如果没有语法错误，则显示“0 error(s)”，并生成目标文件，允许继续进行后面的步骤。

编译没有出现错误，仅仅说明程序中没有语法错误。

（6）生成执行程序：从目标文件进一步连接生成Windows环境下的可执行文件，即文件名后缀为“.exe”的文件。

由于可执行文件是由若干个文件拼接而成的，其中不但有目标文件，还有另一些标准的库文件，一些规模较大的程序还会有多个目标文件，所以这一步骤又被称为连接（Link）。

（7）运行：在Windows环境中使用可执行文件。这是程序设计的最终目的。这一步也常被称为“Run”。

逻辑错误：算法错，或算法在转变为程序时走样了，导致程序能够运行，却不能实现预想的功能。这种错误被称为“逻辑错误”。

在运行这一步，必须核对程序是否正确实现了预定的功能，如果功能不对，还必须到程序中寻找错误，纠正后再次经历（5）、（6）、（7）各步，直到看不出错误为止。

Ⅳ 算法设计与分析过程典型步骤包括哪些

- 分解：将问题分为若干个子问题。 - 解决：递归地求解每个子问题。 - 合并：将每个子问题的解合并成为整个问题的解。

Ⅵ 程序设计的基本过程是怎样的

从分析需求开始

Ⅶ 算法设计的过程一般是什么样子 算法设计的过程一般是那几步

和你做数学题目的过程一样,已知条件是什么?已知量是什么?要求什么?需要输出一个什么结果?
算法设计就是把问题解决步骤用计算机编程语言来表示出来

Ⅷ python算法设计的步骤有三步分别是

1. 弄清楚题目的意思，列出题目的输入、输出、约束条件
其中又一道题目是这样的：“有一个mxn的矩阵，每一行从左到右是升序的，每一列从上到下是升序的。请实现一个函数，在矩阵中查找元素elem，找到则返回elem的位置。”题设只说了行和列是升序的，我在草稿纸上画了一个3x4的矩阵，里面的元素是1~12，于是我就想当然的认为矩阵的左上角是最小的元素，右下角是最大的元素。于是整个题目的思考方向就错了。
2. 思考怎样让算法的时间复杂度尽可能的小
继续以上面的题目为例子。可以有如下几种算法：
a. 遍历整个矩阵进行查找，那么复杂度为O(m*n)；
b. 因为每一行是有序的，所以可以对每一行进行二分查找，复杂度为O(m*logn)。但是这样只用到了行有序的性质。
c. 网上查了一下，最优的算法是从矩阵的左下角开始，比较左下角的元素（假设为X）与elem的大小，如果elem比X大，那么X所在的那一列元素就都被排除了，因为X是该列中最大的了，比X还大，那么肯定比X上面的都大；如果elem比X小，那么X所在的那一行就可以排除了，因为X是这一行里最小的了，比X还小那么肯定比X右边的都小。每迭代一次，矩阵的尺寸就缩小一行或一列。复杂度为O(max(m,n))。
可以先从复杂度较高的实现方法入手，然后再考虑如何利用题目的特定条件来降低复杂度。
3. 编写伪代码或代码

Ⅸ 算法设计-流程制作

我觉得这样可能比较好理解一点 有三根柱子，标记为A, B, C 先要理解函数hanoi(n,A,B,C) 的意思是借助于B柱子将A上面的n个盘子移到C上面，必须充分对应到各个参数。 如果想将n个盘子从A柱子移动到C柱子 可以分为这样几个步骤 （1）必须将A最下面也就是最大的那个盘子移动到C最下面 首先需要借助C柱子将A上面的n-1个盘子移动到B上面 就是hanoi(n-1,A,C,B) 。 此时A上面只有一个最大的盘子，B上面按序放着n-1个盘子，C上面有0个盘子。 （2）将A上面的盘子移动到C上面，只需要1步。 此时A上面有0个盘子，B上面按序放着n-1个盘子，C上面只有一个最大的盘子。 （3）最后借助于A柱子将B上面n-1个盘子移到C上面即可 就是hanoi(n-1,B,A,C) 。 所以实际上数学推导公式为f(n)=2f(n-1)+1，其中f(1)=1，f(n)表示将n个盘子从A柱子移到C柱子的步数

Ⅹ 算法设计的步骤不包含什么

一、学习内容

1. 算法设计中五大常用算法

1) 分治法

设计思想：将一个难以直接解决的大问题分解成规模较小的相同问题，以便分而治之。

实际的应用：快速排序、归并排序

分治法在每一层递归上的基本步骤：

①分解：将原问题分解为若干个规模较小、相互独立、与原问题形式相同的子问题。

②解决：若子问题规模较小就直接解决，不然就递归解决各个子问题

③合并：将各个子问题的解合并为原问题的解

以快速排序为例理解分治法：

快速排序代码：

public static void quickSort(int a[],int low,int high){

if(low < high){

int pivotpos = partition(a,low,high);

quickSort(a,low,pivotpos-1);

quickSort(a,pivotpos+1,high);

}

}

public static int partition(int a[],int low,int high){

int pivot = a[low];

while (low < high){

while (low < high && a[high] >= pivot){

--high;

}

a[low] = a[high];

while (low < high && a[low] <= pivot){

++low;

}

a[high] = a[low];

}

a[low] = pivot;

return low;

}

①分解:选取基准元素，将左右两侧进行划分

②解决:分别将两个子序列进行快速排序

③合并:将排好的子序列合并

以两路合并排序为例理解分治法：（分治法中的合并在归并排序中体现得更加清楚）

归并排序代码：

public static void merge(int a[],int low,int mid,int high){

int[] temp = new int[high-low+1];

int i = low;

int j = mid+1;

int k = 0;

while (i <= mid && j <= high){

if(a[i] < a[j]){

temp[k++] = a[i++];

}else {

temp[k++] = a[j++];

}

}

//把左边剩下的移到数组中

while (i <= mid){

temp[k++] = a[i++];

}

//把右边剩下的移到数组中

while (j <= high){

temp[k++] = a[j++];

}

//更新原数组

for (int x = 0;x <temp.length;x++){

a[x+low] = temp[x];

}

}

public static int[] mergeSort(int a[],int low,int high){

int mid = (low+high)/2;

if(low < high){

mergeSort(a,low,mid);

mergeSort(a,mid+1,high);

//左右合并

merge(a,low,mid,high);

}

return a;

}

①分解:将一个数组一刀切两半，递归切，直到切成单个元素

②解决:单个元素合并成有序的小数组

③合并:小数组合并成大数组，最终合并完成

2) 动态规划法

设计思想：最优化原理，即一个过程的最优决策具有这样的性质：即无论其初始状态和初始决策如何，其今后诸策略对以第一个决策所形成的状态作为初始状态的过程而言，必须构成最优策略

动态规划法所要满足的条件：

①问题中的状态满足最优化原理

②问题中的状态必须满足无后效性，无后效性指的是下一时刻的状态只与当前的状态 有关而与当前状态的之前状态无关。

动态规划三要素：

①问题的阶段

②每个阶段的状态

③从前一个阶段转换到后一个阶段的递推关系

实际的应用：0/1背包问题 最长公共子串问题

以最长公共子串问题为例理解动态规划法：

定义dp[i][j]表示以A中第i个字符结尾的子串和B中第j个字符结尾的子串的最大公共子串，dp 的大小也为 (n + 1) x (m + 1) ，这多出来的一行和一列是第 0 行和第 0 列，初始化为 0，表示空字符串和另一字符串的子串的最长公共子串。

当我们要求dp[i][j]时，我们要先判断A的第i个元素B的第j个元素是否相同即判断A[i - 1]和 B[j -1]是否相同，如果相同它就是dp[i - 1][j- 1] + 1，相当于在两个字符串都去掉一个字符时的最长公共子串再加 1；否则最长公共子串取0。所以整个问题的初始状态为：

dp[i][0]=0,dp[0][j]=0

相应的状态转移方程为：

实现代码：

public static int findLongest(String A,String B){

int n = A.length();

int m = B.length();

if(m == 0 || n == 0){

return 0;

}

int result = 0;

int[][] dp = new int[n+1][m+1];

//初始状态

for(int i = 0; i <= n;i++){

dp[i][0] = 0;

}

for(int i = 0; i <= m;i++){

dp[0][i] = 0;

}

for(int i = 1;i <= n;i++){

for(int j = 1;j <= m;j++){

if(A.charAt(i-1) == B.charAt(j-1)){

dp[i][j] = dp[i-1][j-1]+1;

result = Math.max(result,dp[i][j]);

}else {

dp[i][j] = 0;

}

}

}

return result;

}