精华内容
下载资源
问答
  • 算法基础——算法优劣的衡量

    千次阅读 2018-09-13 13:25:33
    如何衡量算法的好坏,是学习算法的重要基础。 最初,用所需要的计算时间来衡量一个算法的好坏 但不同的机器相互之间无法比较 需要用独立于具体计算机的客观衡量标准 1.问题的规模 2.基本运算 3.算法的计算量...

    针对一个问题可以有多种的算法方法来解决问题,当然我们最喜欢的还是简单的、高效的方法。如何衡量算法的好坏,是学习算法的重要基础。

    1. 最初,用所需要的计算时间来衡量一个算法的好坏
    2. 但不同的机器相互之间无法比较
    3. 需要用独立于具体计算机的客观衡量标准
      1.问题的规模
      2.基本运算
      3.算法的计算量函数

    问题的规模

    输入数据量的测度(一般是n来表示)

    基本运算

    解决给定问题时占支配地位的运算(一般一种、偶尔两种)

    计算量函数

    用问题规模的某个函数来表示算法的基本 运算量,这个表示基本运算量的函数称为算 法的时间复杂性(度)。时间复杂度用用T(n)(或T(n,m)等)来表示。
    重点概念:

    渐进时间复杂度

    当问题的规模趋于极限情形时的时间复杂度的表示
    3种记号
    1. O(f(n))表示算法时间复杂度的上界
    定义为:若存在c > 0,和正整数n0≥1,使得当n≥n0时,总有 T(n)≤c*f(n) 。
    O(f(n))
    2. Ω(f(n)) 表示算法时间复杂度的下界
    定义为:若存在c > 0,和正整数n0≥1,使得当n≥n0时,存在无穷多个n ,使得T(n)≥c*f(n)成立。
    Ω(f(n))
    3. Θ(f(n)) 表示算法时间复杂度的确界
    定义为:若存在c1,c2>0,和正整数n0≥1,使得当n≥n0时,总 有 T(n)≤c1*f(n),且有无穷多个n,使得T(n)≥c2*f(n) 成立,即:T(n)= O(f(n))与T(n)=Ω(f(n))都成立。
    Θ(f(n))

    补充:

    • o记号:由O记号提供的渐进上界可能是也可能不是渐进紧确的。eg:2n^2 = O(n^2)是渐进紧确的,但是2n =
      O(n^2)却不是。用o记号来表示一个非渐进紧确的上界。
      定义:对任意正常数c,存在正整数n0≥1,使得当n≥n0时,总有 T(n)≤c*f(n) 。
    • ω记号:与Ω记号关系类似于O和o的关系,表示一个非渐进紧确的下届。
      定义:对任意正常数c,存在正整数n0≥1,对所有的n≥n0时,T(n)≥c*f(n)成立。

    参考文档

    算法导论

    展开全文
  • 衡量算法的标准 时间复杂度: 空间复杂度: 时间频度:(Tn) 八种基本排序算法的实现 冒泡排序 冒泡排序的java实现: package demo4; import java.util.Arrays; public class BubbleSort { public static void ...

    在数据结构与算法的学习中,排序算法有着举足轻重的地位,其实自己之前也学过,但是由于时间较长,也忘得差不多了,也才想着趁着假期的时间来系统的学习一下。但是理解的不够细致,还需要在花费点时间。
    在这里插入图片描述

    八种基本排序算法的实现

    冒泡排序

    冒泡排序(Bubble Sort)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

    时间复杂度: O(n^2)

    步骤如下:
    比较相邻的元素。如果第一个比第二个大,就交换他们两个,直到把最大的元素放到数组尾部。
    遍历长度减一,对剩下的元素从头重复以上的步骤。
    直到没有任何一对数字需要比较时完成。

    冒泡排序的java实现:

    package demo4;
    import java.util.Arrays;
    
    public class BubbleSort {
    	public static void main(String[] args) {
    		int [] arr=new int[]{5,7,2,9,4,1,0,5,7};
    		System.out.println(Arrays.toString(arr));
    		bubbleSort(arr);
    		System.out.println(Arrays.toString(arr));
    	}
    	/*
    	 * 冒泡排序
    	 * 共需要比较length-1次
    	 */
    	public static void bubbleSort(int[] arr) {
    		//控制共比较多少轮
    		for(int i=0;i<arr.length-1;i++) {
    			//控制比较次数
    			for(int j=0;j<arr.length-1;j++) {
    				if(arr[j]>arr[j+1]) {
    					int temp=arr[j];
    					arr[j]=arr[j+1];
    					arr[j+1]=temp;
    				}
    			}
    		}
    	}
    }
    

    快速排序

    快速排序(Quicksort)是对冒泡排序的一种改进。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

    时间复杂度:O(N*logN)

    步骤:
    从数列中挑出一个元素,称为 “基准”(pivot),
    重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
    递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

    快速排序的java代码实现:

    package demo4;
    
    import java.util.Arrays;
    
    public class QuickSort {
    	public static void main(String[] args) {
    		int [] arr=new int[]{5,7,2,9,4,1,0,5,7};
    		quickSort(arr,0,arr.length-1);
    		System.out.println(Arrays.toString(arr));
    		
    	}
    	/*
    	 * 快速排序
    	 */
    	public static void quickSort(int [] arr,int start,int end) {
    		if(start<end) {
    			//把数组中第0 个数作为基准数
    			int stard=arr[start];
    			//记录需要排序的下标
    			int low=start;
    			int high=end;
    			//循环找比标准数大的数和比标准数小的数
    			while(low<high) {
    				//右边的数字比标准数大
    			while(low<high&&stard<=arr[high]) {
    				high--;
    				}
    			//使用右边的数字替换左边的数字
    			arr[low]=arr[high];
    			//如果左边的数字比标准数小
    			while(low<high&&arr[low]<=stard) {
    				low++;
    				
    			}
    			arr[high]=arr[low];
    			}
    			//把标准数赋给所在的位置的元素
    			arr[low]=stard;
    			//处理所有的小的数字
    			quickSort(arr,start,low);
    			//处理所有大的数字
    			quickSort(arr,low+1,end);
    		}
    	}		
    }
    

    插入排序(直接插入)

    插入排序(Insertion Sort)在要排序的一组数中,假定前n-1个数已经排好序,现在将第n个数插到前面的有序数列中,使得这n个数也是排好顺序的。如此反复循环,直到全部排好顺序。

    时间复杂度: O(n^2)

    步骤如下:
    ①从第一个元素开始,该元素可以认为已经被排序
    ②取出下一个元素,在已经排序的元素序列中从后向前扫描
    ③如果该元素(已排序)大于新元素,将该元素移到下一位置
    ④重复步骤3,直到找到已排序的元素小于或者等于新元素的位置5. 将新元素插入到该位置中
    ⑤重复步骤2
    插入排序的java代码实现:

    package demo4;
    
    import java.util.Arrays;
    
    public class insertSort {
    	public static void main(String[] args) {
    		int [] arr=new int[] {5,2,3,6,1,8,7};
    		insertSort(arr);
    		System.out.println(Arrays.toString(arr));
    	}
    	
    	public static void insertSort(int[] arr) {
    		//遍历所有的数字
    		for(int i=1;i<arr.length;i++) {
    			//如果当前数字比前一个数字更小
    			if(arr[i]<arr[i-1]) {
    				//把当前边遍历数字存起来
    				int temp=arr[i];
    				int j;
    				//遍历当前数字前面的所有数字
    				for(j=i-1;j>=0&&temp<arr[j];j--) {
    					//把前一个数字赋值给后一个数字
    					arr[j+1]=arr[j];
    				}
    				//把临时变量(外层for循环的元素)赋值给不满足条件的后一个元素
    				arr[j+1]=temp;
    			}	
    		}
    	}
    }
    
    

    插入排序之希尔排序

    针对直接插入排序的效率问题,有人对此进行了改进与升级,这就是现在的希尔排序。希尔排序又称递减增量排序算法,是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是基于插入排序的以下两点性质而提出改进方法的:

    插入排序在对几乎已经排好序的数据操作时, 效率高, 即可以达到线性排序的效率
    但插入排序一般来说是低效的, 因为插入排序每次只能将数据移动一位
    希尔排序的java实现:

    package demo4;
    
    import java.util.Arrays;
    
    public class shellSort {
    	public static void main(String[]args) {
    		int [] arr=new int[] {5,2,3,6,1,8,7,0};
    		System.out.println(Arrays.toString(arr));
    		shellSort(arr);
    		System.out.println(Arrays.toString(arr));
    	}
    	public static void shellSort(int [] arr) {
    		int k=1;
    		//遍历所有的步长
    		for(int d=arr.length/2;d>0;d/=2) {
    			//遍历所有元素
    			for(int i=0 ;i<arr.length;i++) {
    				//遍历本组中所有的元素
    				for(int j=i-d;j>=0;j-=d) {
    					if(arr[j]>arr[j+d]) {
    						int temp=arr[j];
    						arr[j]=arr[j+d];
    						arr[j+d]=temp;
    					}
    				}
    			}
    			System.out.println("第"+k+"次排序结果:"+Arrays.toString(arr));
    			k++;
    		}
    	}
    }
    

    排序后的结果为:
    在这里插入图片描述

    选择排序

    选择排序法的思路是:
    1、找出一个最小数,交换到最前面。
    2、在剩下的数里面,再找一个最小的,交换到剩下数的最前面
    3、重复步骤2 ,直到所有数都已排好。
    显然,对于含有N个数的数组来说,其过程也要进行N-1趟 ( 0 <= i < N-1 )。
    找出一个最小数,交换到最前面的方法是:
    先将剩下数中的第一个数(序号是i)作为基数,用变量k记下其序号,后面的数依次与该基数比较,若比基数还小,则用k记下其序号(注意:此时不要交换),当所有数都与基数比较后,k中存放的就是最小数的序号,然后将它交换到最前面(现在才交换)。在上面的过程中,数据只交换了一次,即每趟只交换一次数据。
    选择排序的java实现:

    package demo4;
    
    import java.util.Arrays;
    
    public class selectSort {
    	public void main(String[]args) {
    	int [] arr=new int[] {6,1,4,3,6,1,8,7,0};
    	selectSort(arr);
    	System.out.println(Arrays.toString(arr));
    	}
    	/*
    	 * 选择排序
    	 */
    	public static void selectSort(int []arr) {
    		//遍历所有的数
    		for(int i=0;i<arr.length;i++) {
    			int minIndex=i;
    			//把当前遍历的数和后面所有的数依次进行比较
    			for(int j=0;j<arr.length;j++) {
    				//如果后面比较的数比记录的最小的数小
    				if(minIndex<arr[j]) {
    					//记录下最小的那个数的下标
    					minIndex=j;
    				}
    			}
    			//如果最小的数和当前遍历的数的下标不一致,说明下标为Index的数比当前遍历的数更小
    			if(i!=minIndex) {
    				int temp=arr[i];
    				arr[i]=arr[minIndex];
    				arr[minIndex]=temp;
    			}
    		}
    	}
    }
    
    

    归并排序

    归并排序(Merge sort)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

    时间复杂度:O(N*logN)

    步骤如下:
    申请空间,创建两个数组,长度分别为两个有序数组的长度
    设定两个指针,最初位置分别为两个已经排序序列的起始位置
    比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
    重复步骤3直到某一指针达到序列尾
    将另一序列剩下的所有元素直接复制到合并序列尾
    归并排序的java代码实现:

    package demo4;
    import java.util.Arrays;
    
    public class MergeSort {
    	public static void main(String[]args) {
    		int [] arr=new int[] {1,3,5,2,4,6,8,10};
    		System.out.println(Arrays.toString(arr));
    		mergeSort(arr,0,arr.length-1);
    		System.out.println(Arrays.toString(arr));
    	}
    	/*
    	 * 归并排序
    	 */
    	public static void mergeSort(int[]arr,int low,int high) {
    		int middle=(high+low)/2;
    		if(low<high) {
    		//处理左边
    		mergeSort(arr,low,middle);
    		//处理右边
    		mergeSort(arr,middle+1,high);
    		//归并
    		merge(arr,low,middle,high);
    		}
    	}
    	
    	public static void merge(int [] arr,int low,int middle,int high) {
    		//用于存储归并后的临时数组
    		int [] temp=new int[high-low+1];
    		//记录第一个数组中需要遍历的数组
    		int i=low;
    		//记录第二个数组中需要遍历的数组
    		int j=middle+1;
    		//用于记录在临时数组中存放的下标值
    		int index=0;
    		//遍历两个数组,取出小的数组放入临时文件中
    		while(i<=middle&&j<=high) {
    			//第一个数组中的数据较小
    			if(arr[i]<=arr[j]) {
    				//把小的数据放到临时数组中
    				temp[index]=arr[i];
    				//让下标下移一位
    				i++;
    			}else {
    				temp[index]=arr[j];
    				j++;
    			}
    			index++;
    		}
    		//处理多余的数据
    		while(j<=high) {
    			temp[index]=arr[j];
    			j++;
    			index++;
    		}
    		while(i<=middle) {
    			temp[index]=arr[i];
    			i++;
    			index++;
    		}
    		//把临时数组中的数据重新加入原数组
    		for(int k=0;k<temp.length;k++) {
    			arr[k+low]=temp[k];
    		}
    	}
    }
    

    基数排序

    基数排序(英语:Radix sort)是一种非比较型整数排序算法,其原理是将整数按位数切割成不同的数字,然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数,所以基数排序也不是只能使用于整数。基数排序的发明可以追溯到1887年赫尔曼·何乐礼在打孔卡片制表机(Tabulation Machine)上的贡献[1]。

    它是这样实现的:将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

    基数排序的方式可以采用LSD(Least significant digital)或MSD(Most significant digital),LSD的排序方式由键值的最右边开始,而MSD则相反,由键值的最左边开始。
    基数排序的java代码实现:

    package demo4;
    
    import java.util.Arrays;
    
    public class RadixSort {
    	public static void main(String[]args) {
    		int [] arr=new int[] {23,6,189,45,278,56,78,980,51};
    		System.out.println(Arrays.toString(arr));
    		radixSort(arr);
    		System.out.println(Arrays.toString(arr));
    	}
    	
    	public static void radixSort(int [] arr) {
    		//存储素数组中最大的数字
    		int max=Integer.MIN_VALUE;
    		for(int i=0;i<arr.length ;i++) {
    			if(arr[i]>max) {
    				max=arr[i];
    			}
    		}
    		//System.out.println(max);
    		//求最大数的位数
    		int maxLength=(max+"").length();
    		//用来临时存储数据的数组
    		int[][] temp=new int [10][arr.length];
    		//用于记录在temp中相应的数组中存放的数组
    		int[] counts=new int[10];
    		
    		//根据最大长度的数决定比较的次数
    		for(int i=0,n=1;i<maxLength;i++,n*=10) {
    			//把一个数分别计算余数
    			for(int j=0;j<arr.length;j++) {
    				//计算余数
    				int ys=arr[j]/n%10;
    				temp[ys][counts[ys]]=arr[j];
    				//记录数量
    				counts[ys]++;
    			}
    			//记录取的元素要放的位置
    			int index=0;
    			//把数字取出来
    			for(int k=0;k<counts.length;k++) {
    				//记录数量的数组中当前余数记录的数量部位0
    				if(counts[k]!=0) {
    					//循环取出数组
    					for(int l=0;l<counts[k];l++) {
    						//取出元素
    						arr[index]=temp[k][l];
    						//记录下一个位置
    						index++;
    					}
    					//把数量置为0
    					counts[k]=0;
    				}
    				
    			}
    
    		}
    	}	
    }
    

    堆排序

    堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,可以利用数组的特点快速定位指定索引的元素。它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆,是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值,即A[PARENT[i]]>=A[i]。在数组的非降序排序中,需要使用的就是大根堆,因为根据大根堆的要求可知,最大的值一定在堆顶。

    堆排序的java代码实现:

    package demo4;
    
    import java.util.Arrays;
    
    public class HeapSort {
    	public static void main(String[] args) {
    		int [] arr=new int[] {9,6,8,7,0,1,10,4,2};
    		heapSort(arr);
    		System.out.println(Arrays.toString(arr));
    	}
    
    	/*
    	 * 堆排序
    	 */
    	public static void heapSort(int []arr) {
    		//开始位置是最后一个非叶子节点,即最后一个节点的父节点
    		int start=(arr.length-1)/2;
    		
    		for(int i=start;i>=0;i--) {
    			maxheap(arr,arr.length,i);
    		}
    		//把数组中的第0 个和堆中的最后一个交换位置,再把前面的处理为大顶堆
    		for(int i=arr.length-1;i>0;i--) {
    			int temp=arr[0];
    			arr[0]=arr[i];
    			arr[i]=temp;
    			maxheap(arr,i,0);
    			
    		}
    		
    	}
    	public static void maxheap(int [] arr,int size,int index) {
    		//左子节点
    		int leftNode=2*index+1;
    		//右子节点
    		int rightNode=2*index+2;
    		int max=index;
    		//和两个子节点进行对比,找出最大的节点
    		if(leftNode<size && arr[leftNode]>arr[max]) {
    			max=leftNode;	
    		}
    		if(rightNode<size && arr[rightNode]>arr[max]) {
    			max=rightNode;
    		}
    		//交换位置
    		if(max!=index) {
    			int temp=arr[index];
    			arr[index]=arr[max];
    			arr[max]=temp;
    			//交换位置后需要重新调整位置
    			maxheap(arr,size,max);
    		}
    	}
    }
    

    排序算法的比较

    在这里插入图片描述
    在以上这些排序算法的学习中,自己花费了太多的时间。可是最终理解得还是不够透彻,以上算法采用了比较基础的方法实现,考虑的不是很全面,自己也会在之后的学习中多加思索。

    展开全文
  • 算法基本概念

    2017-04-08 15:38:43
    2、算法好坏衡量标准 问题规模、基本运算、算法计算量函数 3、时间复杂度 上界:O(f(n)) 下界:Ω(f(n)) 确界:θ(f(n)) 4、算法研究几个主要步骤 设计(设计有效算法)-&gt;表示(能在计算机实现)-&...

    1、算法5特性
    确定性、可行性、输入、输出、有穷性
    2、算法好坏衡量标准
    问题规模、基本运算、算法计算量函数
    3、时间复杂度
    上界:O(f(n))
    下界:Ω(f(n))
    确界:θ(f(n))
    4、算法研究的几个主要步骤
    设计(设计有效算法)->表示(能在计算机实现)->确认(合法输入=>正确结果;不合法输入=>正确应对)->分析(复杂度,优缺点 等)->实现和测试
    5、算法评价
    正确性、健壮性、简单性、高效性、最优性

    6、分治法:
    子问题相互独立,不包含公共子问题
    7、动态规划法:
    子问题重复、即有很多公共子问题
    8、背包:
    一般背包可用贪心法(0-1背包一般不用贪心法,因为用贪心有些情况无法求其最优解)
    9、贪心法:
    最优子问题(非整体最优解)
    10、单源最短路径:
    Dijkstra:有向非负,分两集合(已选集合 ; 未选集合),每次从未选顶点集合中选取 已选集合中到未选集合中的最短路径(即每一步均为当前最优解)。
    11、最小生成树:(无向)
    Prim:S(已选点集合)-V(未选点集合),从V中选取到S中的最短路径的点放到S中,直到V为空。
    Kruskal:边按权值由小到大排序,根据点个数En分为n个非连通区(n为点数),然后把非连通区合成一连通区。
    12、随机序列:
    概率相等、不可预测、不可重现
    13、Las Vegas:
    不一定有解,有解必为正确解(一次使用求不出解时,多次调用此算法)
    14、Monte Carlo:
    解的正确性不小于P(1/2 < P < 1),多次执行可以增加其总的正确率
    15、回溯法:
    深度优先
    16、分支限界法:
    广度优先 或 最小耗费优先。

    展开全文
  • 数据是客观事物的符号表示。 数据元素是数据的基本单位。 数据项是组成数据元素的最小单位。...评价算法优劣的基本标准:正确性、可读性、健壮性、高效性。 衡量算法的两个主要指标:时间复杂度、空间复杂度。 ...

    数据是客观事物的符号表示。
    数据元素是数据的基本单位。
    数据项是组成数据元素的最小单位。
    数据对象是性质相同的数据元素的集合,是数据的一个子集。
    在这里插入图片描述

    算法是为了解决某类问题而规定的一个有限长的操作序列。
    算法的五个重要特性:有穷性、确定性、可行性、输入、输出。
    评价算法优劣的基本标准:正确性、可读性、健壮性、高效性。
    衡量算法的两个主要指标:时间复杂度、空间复杂度。

    展开全文
  • 算法的效率

    2018-10-11 09:56:26
    衡量算法的效率有两个标准:时间效率和空间效率 时间复杂度 空间复杂度 时间上的效率时间复杂度(衡量一个算法的运行速度) 时间复杂度:运行基本操作的次数 用O(渐进表示法)表示 空间上的效率空间复杂度(衡量...
  • 衡量算法的的两个标准,时间复杂度和空间复杂度。什么是时间复杂度,算法中某个函数有n次基本操作重复执行,用T(n)表示,现在有某个辅助函数f(n),使得当n趋近于无穷大时,T(n)/f(n)的极限值为不等于零的常数,则称f...
  • 衡量算法的的两个标准,时间复杂度和空间复杂度。什么是时间复杂度,算法中某个函数有n次基本操作重复执行,用T(n)表示,现在有某个辅助函数f(n),使得当n趋近于无穷大时,T(n)/f(n)的极限值为不等于零的常数,则称f...
  • 我们知道, CPU每秒运行的指令数是恒定的, 衡量算法快慢的标准就是算法运行的基本指令个数, 运行指令个数f(n)和数据规模n有关 现在来了解一下大O渐进法, 这个方法就是极限的方法, 在大O符号表示法中, 时间复杂度的...
  • 数据结构与算法 数据结构(存储) 算法(操作) ...2.衡量算法的标准 时间复杂度 大概程序要执行的次数,而非执行的时间 空间复杂度 算法执行过程中大概所占有的最大内存 难易程度 健壮性 ...
  • 02 算法

    2021-02-19 16:02:57
    文章目录算法算法特性评价算法优劣的基本标准算法的时间复杂时间频度算法的空间复杂度衡量算法效率 算法 算法(Algorithm)是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法...
  • 算法算法分析基础

    千次阅读 2019-01-05 16:49:40
    算法和算法分析基本概念算法的特性算法和程序算法与数据结构算法设计的要求评价算法的标准:算法效率的衡量方法和准则:如何估算算法的时间复杂度总结:推导大O阶方法平均时间复杂度和最坏时间复杂度时间复杂度比较...
  • 当然,准确性是基本前提,时间和空间效率是衡量一个算法优劣重要评估标准算法通常在函数中使用控制结构来实现。1 算法分类算法是一个比较大概念范畴,为便于理解,可以从算法思想,典型应用及与数据结构关系...
  • 算法算法分析概念

    2017-04-21 15:15:13
    衡量一个算法的性能,主要有以下标准:正确性,简明性,健壮性,效率。   2 算法的时间复杂度 判断算法的性能要考虑的一个基本特征就是问题实例的规模,规模一般是输入量(有时也涉及输出量)。 算法的事前分析:...
  • 在数学领域里,算法是用于解决某一类问题的公式和思想。 在计算机科学领域的算法,它的本质是一系列程序指令,用于解决特定的运算和逻辑...一、衡量算法好坏的重要标准有两个。 时间复杂度(大O表示法):执行算法的.
  • 内排序算法的时间复杂度比较

    千次阅读 2013-01-12 14:14:43
    排序是一种最基本的、应用最广泛的数据操作,通常排序操作的数据量都非常的大,因而为了节省排序的时间,对排序算法的速度要求一般都比较高。特别是一些大型的数据库,由于数据量非常庞大,如何选择一个高效的排序...
  • 目录K-means聚类聚类的定义相似度或距离计算方法总结聚类的基本思想K-means聚类算法总结聚类的衡量标准层次聚类方法密度聚类方法DBSCAN算法相关概念 K-means聚类 聚类的定义 相似度或距离计算方法总结 聚类的基本...
  • 算法定义: 1、一个有限指令集! 2、接受一些输入(有时候可以无输入) 3、产生输出 ...4、一定在有限步骤后终止 ...2、计算机能处理范围 ...好的算法衡量标准 时间方面:时间复杂度 空间方面:空间复杂度
  • 一、算法的基本概念 1. 什么是算法 算法:算法是对特定问题的求解步骤,是指令的有限序列。 算法的特征: (1)算法有0或多个输入 (2)算法至少有一个输出 (3)算法的每一条指令都可以执行 (4)算法的每一条指令...
  • 而图像增强目的是提高视感 质量,图像增强过程基本上是一个探索过程, 它利用人心理状态和视觉系统去控制图像质量, 直到人们视觉系统满意为止。 图像复原是利用退化现象某种先验知识,建立退化现象...
  • 聚类算法分析——Kmeans算法

    千次阅读 2015-09-07 22:00:44
    Kmeans算法的基本思想是初始随机给定K个簇中心,按照最邻近原则把待分类样本点分到各个簇。然后通过计算各个簇中数据点的平均值,更新簇中心,迭代至满足收敛条件。 Kmeans的目标函数:(这里以欧式距离作为衡量...
  • 聚类算法大杂烩

    2019-09-05 10:18:00
    2.2 聚类使用2.3 性能度量(有效性指标)2.3.1 外部指标衡量法2.3.1.1 簇内结果的衡量标准样本间距离计算样本间聚类结果的衡量标准2.3.1.2 簇间的衡量标准簇间距离计算簇间聚类结果的衡量标准2.3.1.3 距离...
  • 第一章 算法 一基本概念 1算法是指解题方案的准确而完整的描述 2算法的基本特征可行性确定性有穷性拥有足够的情报 3衡量算法的标准时间复杂度用语句条数和空间复杂度开辟变量的个数 4算法的控制结构顺序结构选择结构...
  • 漫画算法读书笔记

    2020-11-20 12:27:49
    衡量算法优劣主要标准是时间复杂度和空间复杂度。 数据结构 数据结构是数据组织、管理和存储格式,其使用目的是高效地访问和修改数据。 数据结构组成方式: 线性结构 数组 链表 栈 队列 哈希表 树 图 ...
  • 算法效率分析基础

    2018-08-14 19:04:00
    一般而言分析算法效率的方式有两种,即:时间效率和空间效率。时间效率也称为时间...在算法分析中,我们不使用时间的标准单位(例如:秒,毫秒等)来衡量算法的快慢,而是使用基本操作的次数来衡量时间复杂度。并...
  • G-N算法解读课件.ppt

    2020-08-03 08:14:51
    4 G-N算法存在的问题 5 社区划分质量衡量标准 6 G-N算法的缺点 7 G-N算法的改进 8 意义 * 一G-N算法概要 GN算法是一个经典的社区发现算法它属于分裂的层次聚类算法最初由Michelle Girvan和Mark Newman提出其基本思想...
  • 其他聚类算法

    2020-02-05 21:09:25
    上篇文章介绍了聚类算法基本的k均值聚类算法,然而还有很多种其他聚类算法 密度聚类(DBSCAN) 这种方法聚类不是以方差最小为衡量标准,而是遵循一个原则,“兄弟兄弟也是兄弟”,也就是加入A与B距离很近...
  • 数据结构及算法详解

    2021-04-14 11:42:57
    算法的衡量标准 算法:解决问题的办法,是一种独立的存在的解决问题的方法和思想,它不依赖于代码。代码只不过是对算法的一种表达和实现。 数据结构:存储和组织数据的方式 时间复杂度:在规模量级上对算法的衡量,...
  • 1.衡量一个算法好坏的标准在于其算法效率高,算法效率分为时间复杂度和空间复杂度,时间复杂度主要衡量一个算法的运行速度,空间复杂度主要衡量一个算法所需要的额外空间。一个算法好应该时间复杂度最低,空间复杂度...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 179
精华内容 71
关键字:

衡量算法的基本标准