精华内容
下载资源
问答
  • 如果算法正确,请给出算法的正确性证明。 (1)与主教材中的算法binarySearch相比,数组段左、右游标left和right的调整正确,导致陷入死循环 (2)与主教材中的算法binarySearch相比,数组段左、右游标left和...

    分治法

    2-2 下面的7个算法与本章的二分搜索算法binarySearch略有不同。请判断这7个算法的正确性。如果算法不正确,请说明产生错误的原因;如果算法正确,请给出算法的正确性证明。

    1560568644920

    (1)与主教材中的算法binarySearch相比,数组段左、右游标left和right的调整不正确,导致陷入死循环

    1560568663293

    (2)与主教材中的算法binarySearch相比,数组段左、右游标left和right的调整不正确,导致当x=a[n-1]时返回错误。

    1560568702411

    (3)与正确算法binarySearch5相比,数组段左、右游标left和right的调整不正确,导致当x=a[n-1]时返回错误。

    1560568738410

    (4)与正确算法binarySearch5相比,数组段左、右游标left和right的调整不正确,导致陷入死循环。

    1560568776663

    (5)算法正确,且当数组中有重复元素时,返回满足条件的最右元素。

    1560568796034

    (6)与正确算法binarySearch5相比,数组段左、右游标left和right的调整不正确,导致当x=a[n-1]时返回错误。

    1560568816865

    (7)与正确算法binarySearch5相比,数组段左、右游标left和right的调整不正确,导致当x=a[0]时陷入死循环。

    展开全文
  • 对数器-测试自己算法算法正确

    万次阅读 2021-01-29 17:35:18
    对数器-测试自己算法算法正确前言概括对数器概念对数器例子-测试选择排序算法是否正确对数器例子-测试冒泡排序算法是否正确 前言 真正在公司中的实践:NoSQL + RDBMS 一起使用才是最强的,阿里巴巴的架构演进! ...

    前言

    真正在公司中的实践:NoSQL + RDBMS 一起使用才是最强的,阿里巴巴的架构演进! 技术没有高低之分,就看你如何去使用!(提升内功,思维的提高!) 云计算的长征之路:阿里云的这群疯子

    概括

    1.你在网上找到了某个公司的面试题,你想了好久,感觉自己会做,但是你找不到在线测试,你好心烦…
    2.你和朋友交流面试题,你想了好久,感觉自己会做,但是你找不到在线测试,你好心烦…
    3.你在网上做笔试,但是前几个测试用例都过了,突然一个巨大无比数据量来了,结果你的代码报错了,如此大的数据量根本看不出哪错了,你好心烦…

    对数器概念

    1,你想要测的方法a
    2,实现复杂度不好但是容易实现的方法b3,实现一个随机样本产生器
    4,把方法a和方法b跑相同的随机样本,看看得到的结果是否一样
    5,如果有一个随机样本使得比对结果不一致,打印样本进行人工干预,改对方法a和方法b
    6,当样本数量很多时比对测试依然正确,可以确定方法a已经正确。

    对数器例子-测试选择排序算法是否正确

    import java.util.Arrays;
    
    public class Code01_SelectionSort {
    
        public static void selectionSort(int[] arr) {
            if (arr == null || arr.length < 2) {
                return;
            }
            // 0 ~ N-1  找到最小值,在哪,放到0位置上
            // 1 ~ n-1  找到最小值,在哪,放到1 位置上
            // 2 ~ n-1  找到最小值,在哪,放到2 位置上
            for (int i = 0; i < arr.length - 1; i++) {
                int minIndex = i;
                for (int j = i + 1; j < arr.length; j++) { // i ~ N-1 上找最小值的下标 
                    minIndex = arr[j] < arr[minIndex] ? j : minIndex;
                }
                swap(arr, i, minIndex);
            }
        }
    
        //交换
        public static void swap(int[] arr, int i, int j) {
            int tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    
        // for test
        public static void comparator(int[] arr) {
            Arrays.sort(arr);
        }
    
        // for test 根据给定的值,生成一个随机数组
        public static int[] generateRandomArray(int maxSize, int maxValue) {
            // Math.random()   [0,1)  
            // Math.random() * N  [0,N)
            // (int)(Math.random() * N)  [0, N-1]
            int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
            for (int i = 0; i < arr.length; i++) {
                // [-? , +?]
                arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
            }
            return arr;
        }
    
        // for test 复制数组
        public static int[] copyArray(int[] arr) {
            if (arr == null) {
                return null;
            }
            int[] res = new int[arr.length];
            for (int i = 0; i < arr.length; i++) {
                res[i] = arr[i];
            }
            return res;
        }
    
        // for test 判断两组数组是否相同
        public static boolean isEqual(int[] arr1, int[] arr2) {
            if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
                return false;
            }
            if (arr1 == null && arr2 == null) {
                return true;
            }
            if (arr1.length != arr2.length) {
                return false;
            }
            for (int i = 0; i < arr1.length; i++) {
                if (arr1[i] != arr2[i]) {
                    return false;
                }
            }
            return true;
        }
    
        // for test 打印数据
        public static void printArray(int[] arr) {
            if (arr == null) {
                return;
            }
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();
        }
    
        // for test 写一个对数器,测试自己的算法是否正确
        public static void main(String[] args) {
            int testTime = 500000;
            int maxSize = 100;
            int maxValue = 100;
            boolean succeed = true;
            for (int i = 0; i < testTime; i++) {
                int[] arr1 = generateRandomArray(maxSize, maxValue);
                int[] arr2 = copyArray(arr1);
                selectionSort(arr1);
                comparator(arr2);
                if (!isEqual(arr1, arr2)) {
                    succeed = false;
                    printArray(arr1);
                    printArray(arr2);
                    break;
                }
            }
            System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    
            int[] arr = generateRandomArray(maxSize, maxValue);
            printArray(arr);
            selectionSort(arr);
            printArray(arr);
        }
    
    }
    
    

    对数器例子-测试冒泡排序算法是否正确

    import java.util.Arrays;
    
    public class Code02_BubbleSort {
    
    	public static void bubbleSort(int[] arr) {
    		if (arr == null || arr.length < 2) {
    			return;
    		}
    		// 0 ~ N-1
    		// 0 ~ N-2
    		// 0 ~ N-3
    		for (int e = arr.length - 1; e > 0; e--) { // 0 ~ e
    			for (int i = 0; i < e; i++) {
    				if (arr[i] > arr[i + 1]) {
    					swap(arr, i, i + 1);
    				}
    			}
    		}
    	}
    
    	// 交换arr的i和j位置上的值
    	public static void swap(int[] arr, int i, int j) {
    		arr[i] = arr[i] ^ arr[j];
    		arr[j] = arr[i] ^ arr[j];
    		arr[i] = arr[i] ^ arr[j];
    	}
    
    	// for test
    	public static void comparator(int[] arr) {
    		Arrays.sort(arr);
    	}
    
    	// for test
    	public static int[] generateRandomArray(int maxSize, int maxValue) {
    		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
    		for (int i = 0; i < arr.length; i++) {
    			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
    		}
    		return arr;
    	}
    
    	// for test
    	public static int[] copyArray(int[] arr) {
    		if (arr == null) {
    			return null;
    		}
    		int[] res = new int[arr.length];
    		for (int i = 0; i < arr.length; i++) {
    			res[i] = arr[i];
    		}
    		return res;
    	}
    
    	// for test
    	public static boolean isEqual(int[] arr1, int[] arr2) {
    		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
    			return false;
    		}
    		if (arr1 == null && arr2 == null) {
    			return true;
    		}
    		if (arr1.length != arr2.length) {
    			return false;
    		}
    		for (int i = 0; i < arr1.length; i++) {
    			if (arr1[i] != arr2[i]) {
    				return false;
    			}
    		}
    		return true;
    	}
    
    	// for test
    	public static void printArray(int[] arr) {
    		if (arr == null) {
    			return;
    		}
    		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i] + " ");
    		}
    		System.out.println();
    	}
    
    	// for test
    	public static void main(String[] args) {		
    		int testTime = 500000;
    		int maxSize = 100;
    		int maxValue = 100;
    		boolean succeed = true;
    		for (int i = 0; i < testTime; i++) {
    			int[] arr1 = generateRandomArray(maxSize, maxValue);
    			int[] arr2 = copyArray(arr1);
    			bubbleSort(arr1);
    			comparator(arr2);
    			if (!isEqual(arr1, arr2)) {
    				succeed = false;
    				break;
    			}
    		}
    		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
    
    		int[] arr = generateRandomArray(maxSize, maxValue);
    		printArray(arr);
    		bubbleSort(arr);
    		printArray(arr);
    	}
    
    }
    
    
    展开全文
  • 梯度下降算法正确步骤是什么?

    万次阅读 2018-08-27 09:09:42
    梯度下降算法正确步骤是什么?   a.用随机值初始化权重和偏差 b.把输入传入网络,得到输出值 c.计算预测值和真实值之间的误差 d.对每一个产生误差的神经元,调整相应的(权重)值以减小误差 e.重复迭代...

    梯度下降算法的正确步骤是什么?

     

    a.用随机值初始化权重和偏差

    b.把输入传入网络,得到输出值

    c.计算预测值和真实值之间的误差

    d.对每一个产生误差的神经元,调整相应的(权重)值以减小误差

    e.重复迭代,直至得到网络权重的最佳值

    展开全文
  • 关于kruskal算法正确性的证明

    千次阅读 2018-11-04 12:45:22
    因为这条边是最小的边,而点1和点2在最小生成树中一定会直接或间接的相连,因此任何从点1到点2的路径都小于这条边。如图,如果走这条边就只能走1→3→2(而如果这样走显然会使得1→2的距离过大,而我们当前只...

    证明过程:

    • 首先,假设我们已经对所有边进行了排序,并且当前遍历到的边是连接点1和点2的边
    • 因为这条边是最小的边,而点1和点2在最小生成树中一定会直接或间接的相连,因此任何从点1到点2的路径都不小于这条边。如图,如果不走这条边就只能走1→3→2(而如果这样走显然会使得1→2的距离过大,而我们当前只讨论1→2的最优选项)。或者,我们可以假设一种情况:点1和点2之间有两条权值为0.5的边,间接的连接了点1和点2,那么这条路径显然比当前权值为2的边的权值小。但是我们是从小到大遍历边的,所以如果出现了这种情况,那么由于比权值为2的这条边小,那么他们必定已经被遍历。
    • 由于那条路径已经被遍历过,那么这时候点1和点2就处于一个并查集了,也就是说我们不会再选择边权为2的这条边了。
    • 因此我们可以证明出一个结论:图中权值最小的这条边必然要被选择
    • 假设我们已经选择了直接连接点1点2的这条边,那么我们就可以对点1和点2进行缩点,由于最小生成树的性质(只要有路径连接两个任意结点即可),缩点对建图没有任何影响。
    • 重复以上操作,直到边的数量等于点的数量减一(一个图的最小生成树的边的数量必定等于这个图的点的数量减一)即可得出最小生成树。

    拓展资料:

    • 求有向图最小生成树需要使用朱刘算法
    展开全文
  • 贪心算法正确性证明

    万次阅读 多人点赞 2019-03-15 16:43:52
    贪心算法最难的部分就是正确性的证明,常用的方法有归纳法(对算法步数归纳、对问题归纳)和交换论证法(从最优解出发,变坏地替换,得到贪心策略的解)。下面以三个例子说明这些正确性证法。 活动选择问题——对...
  • 循环不变式证明算法正确性循环不变式主要用来辅助我们理解算法正确性,对于循环不变式,必须证明它的三个性质(有些类似于数学归纳法的意味): 初始化:它在循环的第一轮迭代开始之前,应该是正确的。 保持:...
  • 如何证明算法正确性?

    千次阅读 2018-04-02 17:04:39
    结合算法导论相关章节的学习,利用号循环不变式可以帮助我们理解算法的正确性。循环不等式主要满足以下的三条性质: 初始化:循环的第一次迭代之前,它...插入排序算法正确性 INSERTION-SORT(A) for j = 2 to A...
  • Floyd算法正确

    千次阅读 2016-01-10 17:21:25
    三层循环,就能获得任意起始点与终止点的最短路径,很简洁也很神奇,但是一直它的正确性,它为什么能通过这些简洁的循环就达到最优解,算法课里老师也没太讲过,我想就正确性给出一个简单的证明。  Floyd算法代码...
  • Dijkstra算法正确性证明 命题:当算法进行到第 k 步时,对于 S 中每个结点 i,dist [i] = short [i] 归纳基础 k = 1, S = {s}, dist [s] = short [s] = 0. 归纳步骤 证明:假设命题对 k 为真,则对 k+1命题...
  • 贪心算法正确性证明

    千次阅读 2018-12-08 00:15:04
    贪心算法正确性证明 什么是贪心算法 WKI定义:贪心算法(英语:greedy algorithm),又称贪婪算法,是一种在每一步选择中都采取在当前状态下最好或最优(即最有利)的选择,从而希望导致结果是最好或最优的算法。...
  • 关于KMP算法正确性的证明

    千次阅读 2008-03-10 16:50:00
  • 算法

    万次阅读 2018-02-08 00:13:09
    1.算法定义 ...如果一个算法有缺陷,或适合于某个问题,执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。
  • Dijkstra 算法 -方法、算法、代码和正确性的证明 摘要本文介绍Dijkstra算法,包括方法、算法正确性的证明和算法C++的实现。 §1 Dijkstra算法方法介绍算法适用范围:Dijkstra算法解决的是带权重的问题的有向图上...
  • 今天在帮圈子里一位朋友规划第七层网络路径规划的时候,又一次遇到了最短路径算法的问题,我想在这里贴Dijkstra算法或者Floyd算法的源码,也想去刻意分辨什么动态规划和贪心算法的联系和区别,只是闲来记录几笔...
  • 理解强连通分量Kosaraju算法正确

    千次阅读 多人点赞 2018-03-26 21:03:55
    1.基本概念 在看《算法》的有向图章节时,对于Kosaraju算法的理解花了很多时间,为了让更多人在这个算法的理解上面耗费过多时间,特地把自己理解该算法的过程记录下来,分享给有需要的各位。 Kosaraju算法是计算...
  • 如何正确的选择聚类算法

    千次阅读 2019-10-26 16:21:26
    文章目录四种基本算法以及如何选择基于连通性的聚类或层次聚类基于质心的聚类期望最大化...数据聚类是搭建一个正确数据模型的重要步骤。数据分析应当根据数据的共同点整理信息。然而主要问题是,什么一般性的参数...
  • 在考研备考中,参考严奶奶的教材,我也是在关于求next值的算法中卡了一下午时间,感觉挺有意思的,把一些思考的结果整理出来,与大家一起探讨。 以下的顺序为 1、最基本的朴素算法 2、优化的KMP算法 3、应算法...
  • 从最短路径角度证明floyd算法正确

    千次阅读 2017-08-21 19:18:36
    floyd最短路径算法是用于求图中任意两点之间最短路径的经典算法,但是关于正确性的证明书上以及网上并没有很好的解释。一年前自己从最短路径结果本身出发想出了证明办法,但是一直没有发表,今天和朋友又聊起了这...
  • 关于算法学习方法的讨论

    千次阅读 2014-07-20 08:53:53
    【来信】 老师,关于算法和数据结构我还是有点疑惑。你说要通过实践,我现在看到数据结构的图了,算法学习我借了刘汝佳的算法入门那本书,数据结构我把书中的代码在电脑上敲了出来,并且搞懂了第一行代码,也算是...
  • 关于算法,我们都应知道的

    千次阅读 2019-03-11 22:14:49
    定义: 算法是指对特定问题求解步骤的一种描述。 特性: ...(1)有穷性:算法是由若干条指令组成的有穷序列,总是在执行若干次后结束,可能永不停止。...(1)正确性:正确性是指算法能够...
  • 如何正确学习数据结构、算法这门课?

    千次阅读 多人点赞 2019-09-05 09:29:48
    你是否曾跟我一样,因为看懂数据结构和算法,而一度怀疑是自己太笨?实际上,很多人在第一次接触这门课时,都会有这种感觉,觉得数据结构和算法很抽象,晦涩难懂,宛如天书。正是这个原因,让很多初学者对这门课...
  • 关于LRU算法

    千次阅读 2016-04-06 10:24:46
    LRU(Least Recently Used,最近最少使用)算法根据数据的历史访问记录来进行淘汰数据,其核心思想是“如果数据最近被访问过,那么将来被访问的几率也更高”。 实现 最常见的实现是使用一个链表保存缓存数据,...
  • 利用循环不变性证明算法正确应该满足3个条件:(算法导论中提到的) 初始条件: 首次循环前不变性成立 保持条件: 一次循环前不变性如果成立,则下次循环开始前不变性成立 终止条件: 循环结束后,循环不变性应能表明...
  • 一,部分背包问题的贪心算法 部分背包问题可以用贪心算法求解,且能够得到最优解。 贪心策略是什么呢?将物品按单位重量 所具有的价值排序。总是优先选择单位重量下价值最大的物品。 单位重量所具有的价值...
  • 什么是算法

    万次阅读 多人点赞 2016-12-14 10:55:04
    什么是算法 1、什么是算法 算法(algorithm):就是定义良好的计算过程,他取一个或一组的值为输入,并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤,用来将输入数据转化成输出结果。 mark:我们...
  • 本人初学《算法(第四版 谢路云译)》有一段时间了,对于初学者按书敲完第一个BinarySearch二分查找算法发现运行...(第一次写博客,如有详,见谅,请大牛们不要客气在评论区指正补充。)1.确保Java环境配置正确(适
  • 算法正确性证明三要素

    千次阅读 2014-12-30 12:43:46
    1)invariant property 是什么,每步循环保证了invariant property。 2)证明循环可以退出:(比如,在循环体的每个分支,循环的界都是在收敛) 3)根据循环退出的condition和 invariant property 得出answer。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 716,953
精华内容 286,781
关键字:

关于算法不正确的是