精华内容
下载资源
问答
  • 输入: 一个算法必须有零或以上的输入输出: 一个算法应有一个或以上的输出量 明确性: 算法的描述必须无歧义,实际运行结果是确定的 有限性: 必须在有限个步骤内结束 有效性: 称可行性,能够被执行者实现 如果想...

    算法

    高德纳在《计算机程序设计艺术》里对算法归纳为以下几点:

    1. 输入: 一个算法必须有零或以上的输入量
    2. 输出: 一个算法应有一个或以上的输出量
    3. 明确性: 算法的描述必须无歧义,实际运行结果是确定的
    4. 有限性: 必须在有限个步骤内结束
    5. 有效性: 又称可行性,能够被执行者实现

    如果想详细研究算法推荐《数据结构与算法分析》

    定义问题

    数组array含有N个正整数 输入量为array 请将array中的数字从小到大排列 输出量为排好序的数组

    代码例子

    var array = [5,2,4,6,8]
    function sort(){
       你的代码
    }
    sort(array) === [2,4,5,6,8]
    复制代码

    当你遇到思路障碍怎么办?

    • 抽象的问题转化为具体的问题
    • 没见过的问题转化为见过的问题

    排序算法

    所有算法都可在此查看演示

    冒泡排序(BUBBLE)

    重复地比较要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。比较数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。每比较一整轮,最大的都会出现在最后故名---冒泡排序

    流程如下:

    1. 我们拿到一个数组
    2. 开始从前两个开始比较,发现44>3,所以不用交换
    3. 接着往后比较,发现38<44,所以交换他们两个的位置
    4. 以此类推直到第一轮结束,我们得到了最大的那一个----50(冒的第一个泡)
    5. 接着下一轮,又从头开始两个两个地比较,重复第一轮,我们就得到了第二个最大的------48
    6. 如此进行多轮比较我们会得到一个从小到大的数组
    7. 代码实现:
    function bubbleSort(array) {
        for (let i = 0; i < array.length - 1; i++) {
            for (let j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    let temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
    复制代码

    2. 选择排序(SELECT)

    每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。 流程如下:

    1. 拿到一个数组
    2. 我们要选出这个数组中最小的元素然后把它和第一个数交换(放到最前面),所以我们先认为3为最小,然后和后面的数依次进行比较.
    3. 当比到2的时候,我们发现3>2,所以我们就认为2为最小值,后面的数应该都和2进行比较.
    4. 当比较完所有的元素,确定2为最小值的时候,把最小值也就是2与第一个元素的位置互换.
    5. 然后从第二个元素开始新一轮的比较,过程和第一轮一样.把44看做最小值和后面的元素进行比较.
    6. 经过多轮比较得到从小到大的数组.
    7. 代码实现
    function selectSort(arr) {
        var minIndex, temp;
        for (let i = 0; i < arr.length - 1; i++) {
            minIndex = i; // 先把第一个看做最小值
            for (let j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        return arr;
    }
    复制代码

    3, 插入排序(INSERT)

    将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据,算法适用于少量数据的排序。是稳定的排序方法。 流程如下:

    1. 拿到一个数组
    2. 把第一个元素看做一个新数组,然后把第二个元素依次和新数组的元素进行比较(虽然只有一个...),然后插入到适当的位置.
    3. 然后以此类推,把前两个元素看做是一个新数组,然后把第三个元素依次与新数组进行比较,然后插入到适当的位置.
    4. 把剩下的元素依次插入,最后得到从小到大排列的数组.
    5. 代码实现
    function insertionSort(array) {
    
        for (let i = 1; i < array.length; i++) {
            let key = array[i];
            let j = i - 1;
            while (j >= 0 && array[j] > key) {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = key;
        }
        return array;
    }
    复制代码

    4. 归并排序(MERGE)

    将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。 流程如下:

    1. 拿到一个数组
    2. 我们把数组平均分成左右两部分,得到两个新数组,然后再把每个数组平均分成两部分,一直分到每个数组只有两个元素,然后比较第一组
    3. 因为3<44所以位置不变然后比较第二组,因为38>5所以调换位置.
    4. 重点来了,这个时候先不着急比较第三组而是把排好序的一二两组放在一起排序.
    5. 之后就是比较第三组和第四组,然后同样把他们放在一起排好序.
    6. 然后并不是比较第五组和第六组,而是把第一组和第二组产生的新数组和,第三组和第四组产生的新数组放在一起排序成为新数组.
    7. 同样把剩下的按以上步骤重来一遍.我们得到两个排好序的数组.然后给这两个数组排序就完成了.
      排序后:
    8. 代码实现
    function mergeSort(arr) {
        var len = arr.length;
        if (len < 2) {
            return arr;
        }
        var middle = Math.floor(len / 2),
            left = arr.slice(0, middle),
            right = arr.slice(middle);
        return merge(mergeSort(left), mergeSort(right));
    }
    
    function merge(left, right) {
        var result = [];
    
        while (left.length && right.length) {
            if (left[0] <= right[0]) {
                result.push(left.shift());
            } else {
                result.push(right.shift());
            }
        }
    
        while (left.length)
            result.push(left.shift());
        while (right.length)
            result.push(right.shift());
    
        return result;
    }
    复制代码

    5. 快速排序

    每个元素找到自己对应的位置(前面的都比我小,后面的都比我大) 流程如下:

    1. 拿到一个数组
    2. 拿第一个元素和后面的元素进行比较,找出所有比第一个元素小的元素,放在第一个元素的右边然后把第一个元素与这些比他小的元素的最后一个互换.
    3. 前两个元素的位置已经没错了,然后以第三个元素为标准,和后面的元素进行比较.
    4. 把比他小的元素放在他的右边(绿色),然后让它和绿色的最后一个交换位置.
    5. 然后从左边没有确定位置的元素(非橙色)开始以上步骤----也就是19
    6. 一直到所有元素的位置都正确.
    7. 代码实现
    let quickSort = function (arr) {
        if (arr.length <= 1) { return arr; }
        let pivotIndex = Math.floor(arr.length / 2);
        let pivot = arr.splice(pivotIndex, 1)[0];
        let left = [];
        let right = [];
        for (let i = 0; i < arr.length; i++) {
            if (arr[i] < pivot) {
                left.push(arr[i]);
            } else {
                right.push(arr[i]);
            }
        }
        return quickSort(left).concat([pivot], quickSort(right));
    };
    复制代码

    6. 随机快速排序

    顾名思义,就是在快速排序的基础上,加入随机的机制. 在快速排序的时候我们是从左到右来选取比较对象,在随机快速排序中我们是随机来选取对象. 流程如下:

    1. 拿到一个数组
    2. 随机选择一个元素.
    3. 并且把比他小的放在他的右边
    4. 然后把他和比他小的最右边的元素交换位置
    5. 然后在随机选一个元素,重复步骤,知道所有元素都是在正确的位置上.
    6. 代码实现
    let quickRandomSort = function (arr) {
        if (arr.length <= 1) { return arr; }
        let pivotIndex = Math.floor(Math.random()*arr.length);
        let pivot = arr.splice(pivotIndex, 1)[0];
        let left = [];
        let right = [];
        for (let i = 0; i < arr.length; i++) {
            if (arr[i] < pivot) {
                left.push(arr[i]);
            } else {
                right.push(arr[i]);
            }
        }
        return quickSort(left).concat([pivot], quickSort(right));
    };
    复制代码
    展开全文
  • 算法设计的方法

    千次阅读 2016-03-01 21:57:31
    1.算法简介作用:要使计算机能完成人们预定的工作,首先必须为如何完成预定的工作设计一个算法,然后再根据算法编写程序。定义:简单的说,算法(Algorithm)是由穷规则构成的为解决某一类...一个算法必须在执行了

    1.算法简介

    作用:要使计算机能完成人们预定的工作,首先必须为如何完成预定的工作设计一个算法,然后再根据算法编写程序。

    定义:简单的说,算法(Algorithm)是由有穷规则构成的为解决某一类问题的运算序列(方法或过程)。

    算法的性质:算法可以有若干输入,这些输入是在算法开始时给出的初始值或条件;算法通常又有若干输出,是对输入进行加工后的计算结果。另外算法的性质有:
    (1)有穷性。一个算法必须在执行了有穷步之后结束。当然也有例外,在某些领域也需要研究不终止的算法。
    (2)确定性。算法的每一步,必须具有确切的定义。也就是说,对于每步需要执行的动作必须严格和清楚地给出规定。
    (3)可行性。算法的每一步必须要求是可行的,能够由机器或人准确完成。整个算法好像是解决问题的工作序列,其中的每一步都是我们力所能及的一个动作。
    (4)正确性。这是算法最基本最重要的性质。正确性指如果一个算法以一组满足初始条件的输入开始,那么该算法的执行一定终止,并且在终止时得到满足要求的输出结果。

    2.算法的常用设计方法

    实际应用的算法千变万化,种类繁多。设计一个好的算法需要设计者根据实际要解决的问题,充分发挥自己的分析和综合能力,经过认真构思、仔细设计和耐心调整。

    在算法的设计过程中,最重要的是创新精神。经过数千年无数前人的创新,人类不近积累了大量精妙的算法,同时在算法的设计方法上也进行了深入的探讨,发现许多不同问题的解决算法,它们的设计思想有相似之处。经过科学的总结,找到了一些行之有效的能够用于设计算法的一般方法。下面列举最常用的算法设计的方法。

    2.1穷举法

    穷举法(Exhaustion)是对可能是解的众多候选解按某种顺序进行逐一枚举和检验,并从众找出那些符合要求的候选解作为问题的解。

    如将A、B、C、D、E、F这六个变量排成如图所示的三角形,这六个变量分别 取[1,6]上的整数,且均不相同。求使三角形三条边上的变量之和相等的全部解。这个问题的求解就可以使用穷举法,列出所有可能的三角形的边的组合,求出最大值。

    2.2贪婪法

    贪婪法(Greedy),其基本设计思想是当追求的目标是一个问题的最优解时,设法把对整个问题的求解工作分成若干步骤来完成。在其中的每一个步骤都选择从局部看是最优的方案,以期望通过各阶段的局部最优选择来达到整体的最优。

    贪婪法的特点是一般可以快速得到满意的解,因为它省去了为找最优解要穷尽所有可能而必须耗费的大量时间。贪婪法常以当前情况为基础作最优选择,而不考虑各种可能的整体情况,所以贪婪法不要回溯。

    如装箱问题和和着色问题都可以采用贪婪法来求解。

    2.3递归法

    递归(Recursion)是设计和描述算法的一种有力的工具,由于它在复杂算法的描述中被经常采用,为此在进一步介绍其他算法设计方法之前先讨论它。

    能采用递归描述的算法通常有这样的特征:为求解规模为N的问题,设法将它分解成规模较小的问题,然后从这些小问题的解方便地构造出大问题的解,并且这些规模较小的问题也能采用同样的分解和综合方法,分解成规模更小的问题,并从这些更小问题的解构造出规模较大问题的解。特别地,当规模N=1时,能直接得解。

    编写计算斐波那契(Fibonacci)数列的第n项函数fib(n)。
    斐波那契数列为:0、1、1、2、3、…,即:

    fib(0)=0;  
    fib(1)=1; 
    fib(n)=fib(n-1)+fib(n-2) (当n>1时)

    2.4分治法

    分治法(DIvide and Conquer),其基本思想是把一个规模较大的问题分成两个或多个较小的与原问题相似的子问题,首先对子问题进行求解,然后再把各个子问题的解合并起来,得出整个问题的解,即对问题分而治之。

    如果原问题可分割成k个子问题(1<kn),且这些子问题都可解,并可利用这些子问题的解求出原问题的解,那么这种分治法就是可行的。由分治法产生的子问题往往是原问题的较小模式,这就为使用递归技术提供了方便。在这种情况下,反复应用分治手段,可以使子问题与原问题类型一致而其规模却不断缩小,最终使子问题缩小到很容易直接求出其解。这自然导致递归过程的产生。分治与递归像一对孪生兄弟,经常同时应用在算法设计之中,并由此产生许多高效算法。

    如二路归并排序就用到分治法。二路归并的具体实现可参见本人blog:归并排序及其并行化

    2.5回溯法

    回溯法(Backtracking)也称为试探法,该方法首先暂时放弃关于问题规模大小的限制,并将问题的候选解按某种顺序逐一枚举和检验。

    回溯法的基本思想是采用深度优先策略,一步一步向前试探的方法,当某一步有多种选择时,可以先任意选择一种,继续向前试探。一旦发现到达某步后无法再前进,说明上一步做的选择有问题,就后退到上一步重新选择(这就称为回溯)。

    回溯法的特点是可以避免穷举式的盲目搜索,从而可能减少问题求解的搜索时间。

    如迷宫问题和八皇后问题都可以采用回溯方法来设计求解算法。

    2.6动态规划法

    动态规划(Dynamic Programming)是运筹学的一个分支,是求解决策过程(Decision Process)最优化的数学方法。

    动态规划与分治法相似,都是把一个大问题分解为若干较小的子问题,通过求解子问题而得到原问题的解。不同的是分治法每次分解的子问题数目较少,子问题之间界限清楚,处理的过程通常是自顶向下进行;而动态规划法分解子问题可能较多,而且子问题相互包含,为了重用已经计算的结果,要把计算的中间结果保存起来,动态规划法通常是自底向上进行。

    带权图中,求解所有结点之间最短路径Floyd算法就属于动态规划法。

    2.7分枝界限法

    分枝界限法(Branch and Bound)与回溯法相似,也是一种在全部问题解的空间中进行系统搜索的方法。所不同的是,回溯法使用深度优先策略,而分支界限法可以采用广度优先策略。与此同时,分支界限法在搜索过程中,还利用最优解属性的上下界来控制搜索的分支,剪去不必再花时间搜索的部分,从而提高搜索的效率。

    该方法在人工智能中使用比较广泛。利用分支界限法,可以设计背包问题的算法。


    参考文献

    [1]算法与数据结构——C语言描述(第二版).张乃孝

    展开全文
  • Day3 什么是算法

    2020-12-21 20:05:42
    一个算法必须是既有输入又有输出的 正确性 算法需要在输入之后得到一个满足预期的输出结果 有限性 算法的操作次数是有限的,即在有限次的操作后一定会得到一个符合预期的结果 鲁棒性 一个算法能够接受所有可能...

    什么是算法?程序和算法的区别

    算法的理解

    • 数学角度

    算法是对于一个问题,对于输入经过有限次的运算组合后,得到最优解的过程。

    • 计算机角度

    算法是对于输入问题,通过一系列的计算机操作指令组合,得到一个符合预期输出结果的方法

    算法的特点

    • 有始有终

    一个算法必须是既有输入又有输出的

    • 正确性

    算法需要在输入之后得到一个满足预期的输出结果

    • 有限性

    算法的操作次数是有限的,即在有限次的操作后一定会得到一个符合预期的结果

    • 鲁棒性

    一个算法能够接受所有可能的输入,而得到一个符合要求的输出

    • 易用性

    算法在满足输入条件的前提下,要满足运行时间尽可能短,占用内存尽可能小

    衡量算法好坏的标准

    • 时间复杂度

    算法执行有限次操作得到预期输出结果所花费的时间,所花费的时间越少越好

    • 空间复杂度

    算法程序在运行的时候所占用的内存的大小

    算法与程序的关系

    • 算法的实现需要借助编程语言来在计算机上运行而产生需要的输出

    • 一个算法的好坏与输入的大小,编程语言的设计,编译的环境等有很大的关系

    展开全文
  • 为该问题设计一个算法,它的平均效率必须属于Θ(n log n)。 题意分析 可能看完题目,不知道它到底要我们干什么,没有规定输入,也没有要求输出。这跟我们做oj的题很不一样,oj的题目只要在规定时间和空间内给...

    教材原题

    假设我们有n个直径各不相同的螺钉以及n个相应的螺母。我们一次只能比较一对螺钉螺母,来判断螺母是大于螺钉、小与螺钉还是正好适合螺钉。然而我们不能拿两个螺母做比较,也不能拿两个螺钉做比较

    我们的问题是要找到每一对匹配的螺钉和螺母。为该问题设计一个算法,它的平均效率必须属于Θ(n log n)。

    题意分析

    可能看完题目,不知道它到底要我们干什么,又没有规定输入,也没有要求输出。这跟我们做oj的题很不一样,oj的题目只要在规定时间和空间内给出正确答案就行了。而这种算法分析设计题,输入、输出、算法和代码都要我们设计。

    有的同学可能直接对 螺钉 和 螺母 两个数组分别进行快排,然后输出结果。很显然,分别快排,就违背了上面 标粗 的题意要求。

    在正式设计算法和写代码之前,我们简单想想输入、输出。输入肯定就是螺母和螺钉两个数组,输出我们可以简单一点,直接输出两个排序后的数组,但是中间的算法是符合我们题意要求的。

    还有一个问题!划分时,元素下标不断变化,而一开始我们也没有对各个螺钉和螺母进行编号。我们这样输入和输出,怎么体现 上面标粗的 “找到” 呢? 输出是两个有序数组,一一对应就可以体现我们 “找到” “匹配到”了。就好比现实中,我们可以不需要通过编号标识,而直接通过手动移动位置,让匹配螺钉和螺母放到一块。

    说这么多,是因为:在真正写代码之前,进行一定的逻辑分析是有必要的。

    算法分析

     假设我们一开始随便选一枚螺钉A,假设就取区间最左侧那一枚(一开始区间是[0, n-1])。然后在螺母的对应区间([0, n-1])首先找到与螺钉A对应的螺母a。然后把螺母a与区间最左侧的螺母调换位置。然后根据螺钉A,在区间内,对螺母a进行划分。注意,这里是根据 螺钉A , 而不是根据调换了位置的螺母a!!!不然就违背题意了。螺母一次划分后。同理以 螺母a 来划分 螺钉,注意此时的区间还是 [0, n-1]。

    上面是一次划分的算法。我们需要多次划分,每次划分都要缩小区间。详见代码。

    快排的模板代码

    先贴一下快排的模板代码,这个实现比教材的要更简单一点,虽然算法思路是一样的。

    void quicksort(int x[],int left,int right)  //快速排序 
    {
        if(left<right)
        {
            int i=left,j=right,key=x[left];
            while(i<j)
            {
                while(i<j&&x[j]>=key)
                    j--;
                if(i<j)
                    x[i++]=x[j];
    
                while(i<j&&x[i]<=key)
                    i++;
                if(i<j)
                    x[j--]=x[i];
            }
            x[i]=key;
            
            quicksort(x,left,i-1);
            quicksort(x,i+1,right);
        }
    }

    解题代码

    #include<iostream>
    #include<cstdio>
    #include<algorithm>
    using namespace std;
    
    const int N = 9;
    
    void print(int ld[], int lm[]) {
    	printf("ld:");
    	for (int i = 0; i < N; i++) {
    		printf("%d ", ld[i]);
    	}
    	printf("\n");
    	printf("lm:");
    	for (int i = 0; i < N; i++) {
    		printf("%d ", lm[i]);
    	}
    	printf("\n");
    }
    
    // 进行一次划分 
    // [l, r] { 5, 2, 4, 3, 1 }
    int partition(int x[], int l, int r, int key) {
    	
    	// 假设key是螺钉,则首先在螺母中找到与之匹配的螺母
    	// 然后与最左侧的螺母交换,使之称为中轴,方便之后作partition 
    	for(int i=l; i<=r; i++)
    		if(x[i]==key)
    		{
    			swap(x[i], x[l]);
    			break;
    		}
    	
    	// 以key划分螺母 
    	int i=l,j=r;
    	int t=x[l]; // 暂存中轴 
        while(i<j)
        {
            while(i<j&&x[j]>=key) // 注意,这里要与key做比较,不要用t来比较 
                j--;
            if(i<j)
                x[i++]=x[j];
    
            while(i<j&&x[i]<=key)
                i++;
            if(i<j)
                x[j--]=x[i];
        }
        x[i]=t;
        
    //    printf("i=%d\n", i);
    //    for(int i = l; i <= r; i++ ) {
    //    	printf("%d ", x[i]);
    //	}
    	return i;
    } 
    
    // [l, r]
    void match(int ld[], int lm[], int l, int r) {
    	
    	if (l < r) {
    		// 随便选一个 ld,此处以区间的最左侧(第1个)那个 ld 为例子 
    		int ldKey = ld[l];
    		// 返回划分之后 lm 的位置 
    		// 此时与选的ld对应的lm,(划分之后)在下标为 pos 的位置
    		int pos1 = partition(lm, l, r, ldKey);
    		
    		// 选这个 lm,来划分 ld 
    		int lmKey = lm[pos1]; 
            int pos2 = partition(ld, l, r, lmKey); 
            
            // 在这里pos1与pos2相等的 
            print(ld, lm);
            printf("pos1=%d pos2=%d\n", pos1, pos2);
           
    		match(ld, lm, l, pos1-1); 
    		match(ld, lm, pos1+1, r); 
    	}
    }
    
    
    int main() {
        // 为了方便模拟,螺钉和螺母都以数字1-9编号
        // 而且,约定编号越大,直径越大
    	int ld[N] = { 5, 9, 3, 7, 1, 8, 2, 4, 6 };
    	int lm[N] = { 7, 1, 4, 2, 5, 6, 9, 8, 3 };
    		
    	match(ld, lm, 0, N-1);
    	
    	return 0;
    }

    “注意,这里要与key做比较,不要用t来比较 ”

    可能有人不太理解注释这句话。因为螺钉和螺母都是用相同的数字来表示,可能感觉不到差别。

    假如你以 小写字母 来 表示螺钉,以大写字母 来 表示螺母。那么上面代码中比较的地方就需要改动,那样可能会更能理解上面这句注释和原题的题意要求!

    展开全文
  • 穷性:一个算法必须穷步之后结束,都有有穷性的时间完成,不能够无限的执行下去 确定性:算法的每一个步骤都是确定意义的,每一个过程不能二叉性 可行性:每一个步骤都应当能够有效的运行,算法是可执行...
  • 2、算法一些概念

    2020-09-01 20:31:11
    一个算法必须在执行穷步之后结束,且每一步都可以在穷时间内完成。算法必须是穷的,程序可以是无穷的。 确定性。算法中每条指令必须确切的含义,对于相同的输入只能得出相同的输出。 可行性。算法中描述的...
  • 穷性:一个算法必须在有限的步骤结束,每一步都穷的时间内结束 确定性:相同的输入只能得到相同的输出 可行性:可以被执行的操作 输入零个或多个输入 输出一个或多个输出 一个好的算法应该达到一下...
  • 给定一些已经训练好的数据,输入一个新的测试数据点,计算包含于此测试数据点的最近的点的分类情况,哪个分类的类型占多数,则此测试点的分类与此相同,所以在这里,的时候可以复制不同的分类点不同的权重。...
  • 1.有穷性:一个算法必须总在执行有穷步之后结束,且每一步都可在穷时间内完成。 注意:算法必须是有穷的,而程序可以是无穷的 2.确定性:算法中的每条指令必须有确切的含义,对于相同的输入只能得出相同的输出 3....
  • 例题:刷学分到了一年一度的公选课选课时间,已知n课目可选择,每课目分别在时间Si开始,Fi结束。对于每课目,小白可以选择参与或者不参与。如果参与了某个课目,那么必须全程参与才能拿到学分。此外,...
  • 算法是解决问题的一种方法或一个过程,更严格的讲算法是由若干指令组成的穷序列 2 算法特征: 输入0个或多个输入 输出:至少1个输出 确定性:组成算法的指令必须清晰无歧义 有限性:每条指令执行...
  • 至少有一个或者多个输出 可行性 : 原则上精确进行,操作可以通过已实现基本运算执行有限次而完成 正确性 (四个层次) 1. 不含有语法错误 2. 对于几组数据可以得出满意的结果 3. 程序对于精心挑选的典型。苛刻...
  • K-均值聚类算法研究

    2020-07-04 16:06:50
    由于其算法思想简便,容易实现对大规模数据的聚类,因此K-均值算法已成为一种最常用的聚类算法之一K-均值算法能找到关于聚类误差的局部的最优解,是一个能应用在许多聚类问题上的快速迭代算法。它是一种以点为基础的...
  • 确定性:每条指令都必须有确切含义 有效性:每步骤都能有效执行并能得到确定结果 输入&amp;amp;amp;amp;gt;=0输出&amp;amp;amp;amp;gt;=1 算法的复杂度 时间复杂度:程序运行从开始到结束所...
  • 算法:高精度阶乘

    2015-08-13 12:13:00
    问题描述:输入一个正整数n,输出n!的值,这里的阶乘结果必须是完全准确的,每一位都需要被精确输出,而且这里的计算结果可能会非常巨大,超过计算机中的任何数据类型。阶乘的计算公式:n!=1*2*3*…*n。 解题...
  • 输入数据首先包含一个正整数C,表示C组测试用例,然后是C行数据,每行包含一个正整数n(2),表示志愿者的总人数。 Output 对于每组测试数据,请输出分组的方案数目,每个输出占一行。 Sample Input 3 3 4 5 ...
  • note:行号和列号从一开始,如果多个MM的分数绝对值一样,那么输出排在最前面的一个(即行号最小的那个,如果行号相同则取列号最小的那个)。 Sample Input 2 3 1 4 -3 -7 3 0 Sample Output 2 1 ...
  • 章、绪论

    2018-04-01 19:53:00
     1、有穷性:一个算法必须在有穷的步骤执行之后结束,且每一步在穷时间之内完成。  2、确定性:算法中每一条指令都必须有确切的含义,不能存在二义性。  3、可行性:一个算法描述的操作都是可以在已经实现的...
  • 13. 一个算法应该具有“确定性”等5个特性,下面对另外4个特性的描述中错误的是【 】 A. 零个或多个输入 B. 零个或多个输出 C. 穷性 D. 可行性 14、一个线性表第一个元素的存储地址是100,每个元素的长度为2,则...
  • ①网络实质上实现了一个输入输出的映射功能,而数学理论已证明它具有实现任何复杂非线性映射的功能。这使得它特别适合于求解内部机制复杂的问题。我们无需建立模型,或了解其内部过程,只需输入,获得输出。只要...
  • 格雷编码是一个二进制数字系统,在该系统中,两个连续的数值仅有一个位数的差异。 给定一个代表编码总位数的非负整数 n,打印其格雷编码序列。格雷编码序列必须以 0 开头。第一个数与最后一位数 也只差以为一位数 ...
  • 牛牛最近在家里看到一个棋盘,有 n * m 个格子,在棋盘旁边还放着 k 颗棋子,牛牛想把这 k 颗棋子全部放在 n * m 的棋盘上,但是有一个限制条件:棋盘的第一行、第一列、最后一行和最后一列都必须有棋子。...
  • 汉诺塔问题(称为河内塔问题),是一个大家熟知的问题。在A,B,C三根柱子上,n个不同大小的圆盘(假设半径分别为1-n吧),一开始他们都叠在我A上(如图所示),你的目标是在最少的合法移动步数内将所有盘子从A...
  • 每组数据输出一行,一个数res(res>0),表示多少人可能是狼人。 输入样例 1 6 2 4 6 6 1 -1 3 1 5 -1 3 2 -1 -1 2 hehe 输出样例 2 我就暴力解 错了 我是先标记那些能够直接知道身份的 其他默认是...
  • 3、编写一个截取字符串的函数,输入一个字符串和字节数,输出为按字节截取的字符串,但要保证汉字不被截取半个,如“我ABC”,4,应该截取“我AB”,输入“我ABC汉DEF”,6,应该输出“我ABC”,而不是“我ABC+汉...
  • 学习记事

    2013-12-06 22:33:00
    (1) 算法是对特定问题求解步骤的一种描述,他规定了解决问题的运算序列。 算法的优劣使用算法复杂度来描述,即时间复杂度和空间...输入项:一个算法必须0或者多个输入来刻画对象的初始状态 输出项:一个算法...
  • 当客户机第一次调用一个Stateful Session Bean 时,容器必须立即在服务器中创建一个新的Bean实例,并关联到客户机上,以后此客户机调用Stateful Session Bean 的方法时容器会把调用分派到与此客户机相关联的Bean实例...
  • 有些数的素因子只有 3,5,7,请设计一个算法找出第 k 个数。注意,不是必须有这些素因子,而是必须不包含其他的素因子。例如,前几个数按顺序应该是 1,3,5,7,9,15,21。 示例 1: 输入: k = 5 输出: 9 // 方法...
  • 数字证书:从文件中读取数字证书,生成文件输入流,输入文件为c:/mycert.cer,获取一个处理X.509证书的证书工厂…… Java+ajax写的登录实例 1个目标文件 内容索引:Java源码,初学实例,ajax,登录 一个Java+ajax写的...

空空如也

空空如也

1 2 3 4 5 6
收藏数 104
精华内容 41
关键字:

一个算法必须有输入又有输出