03 2017 档案
摘要：代码实现： 单元测试： 输出结果： 性能测试： 输出结果：
阅读全文
摘要：关键代码： 测试用例： 输出结果： 红色部分可看到右子数组的最左元素可作为左子数组右边界的哨兵。 性能对比： 没有大区别。
阅读全文
摘要：一、思路 快速排序是一种分治排序算法。快速排序先把数组重新整理分割两个子数组，然后对两个子数组进行排序。 快速排序和归并排序是互补的： 归并排序中，算法先将数组分为两个子数组进行排序，再将两个子数组进行归并成一个有序的数组。 快速排序中，算法先对数组进行重新整理分割成两个子数组，再对两个子数组进行排
阅读全文
摘要：在sort函数创建aux数组： 在merge函数创建aux数组： 性能对比：
阅读全文
摘要：package com.qiusongde; import edu.princeton.cs.algs4.In; import edu.princeton.cs.algs4.StdOut; public class MergeNoStaticArray { public static void sort(Comparable[] input) { int N...
阅读全文
摘要：top-down： bottom-up：
阅读全文
摘要：测试结果： 算法（Algorithms）第4版 练习 2.2.10 算法（Algorithms）第4版 练习 2.2.11（1） 算法（Algorithms）第4版 练习 2.2.11（2） 算法（Algorithms）第4版 练习 2.2.11（3） 算法（Algorithms）第4版 练习 2.
阅读全文
摘要：测试： 性能比较：
阅读全文
摘要：关键代码实现： 测试用例： 测试结果： 性能比较：
阅读全文
摘要：关键代码： 整体： 测试结果： 性能对比：
阅读全文
摘要：实现关键代码： 整体： 验证： 性能对比：
阅读全文
摘要：关键代码实现： 分析： 当j从hi减到mid的时候，less(aux[j],aux[i])永为false，则一直执行input[k] = aux[i++]。 当i从lo增至mid+1时，less(aux[j],aux[i])永为true，则一直执行input[k] = aux[j--]。 所以可以移
阅读全文
摘要：一、思路 希尔排序是基于插入排序算法，通过允许不相邻的元素进行交换这一简单的改进，使数组变为局部有序，最终再用插入排序。 希尔排序的思想是使数组中任意间隔h的元素都是有序的。这样的数组被称为h有序数组。也就是说h有序数组是h个互相独立的有序数组交叉编织在一起的一个数组。 如果h很大，算法能将元素移动
阅读全文
摘要：一、思路 1、在长度为N的数组，将数组中第i【1~（N-1）】个元素，插入到数组【0~i】适当的位置上。 2、在排序的过程中当前元素之前的数组元素已经是有序的了。 3、在插入的过程中，有序的数组元素，需要向右移动为更小的元素腾出空间，直到为当前元素找到合适的位置。 二、代码实现 三、性能分析 结论：
阅读全文
摘要：一、思路 1、先找到数组中的最小元素，然后跟数组的第一个元素交换位置。 2、在剩下的元素中找到最小元素，然后跟数组的第二个元素交换位置。 3、如此重复，直到将整个数组排序好。 二、代码实现 三、性能分析 结论：对于长度为N的数组，选择排序需要~N2/2次比较和N次交换。 分析： 由代码可知，对外循环
阅读全文
摘要：一、思路 另一种实现归并排序的方法是，先归并微型数组，再成对归并得到的子数组，直到将整个数组归并在一起。 我们先进行1-by-1归并，然后2-by-2归并，4-by-4归并，如此下去。 在最后一次归并中，第二个数组可能比第一个数组要小。 二、代码实现 关键代码： 测试数据：M E R G E S O
阅读全文
摘要：一、自顶向下的归并排序思路： 1、先把数组分为两个部分。 2、分别对这两个部分进行排序。 3、排序完之后，将这两个数组归并为一个有序的数组。 重复1-3步骤，直到数组的大小为1，则直接返回。 这个思路用递归函数来实现最方便，其中mid的计算公式：mid = lo + (hi-lo)/2，lo初始化为
阅读全文
摘要：代码实现： SortCompare： 测试结果：
阅读全文
摘要：E A S Y Q U E S T I O N A E S Y Q U E S T I O N A E S Y Q U E S T I O N A E S Y Q U E S T I O N A E Q S Y U E S T I O N A E Q S U Y E S T I O N A E E Q S U Y S T I O N A E E Q S S U Y T I O N ...
阅读全文
摘要：E A S Y Q U E S T I O N A E S Y Q U E S T I O N A E S Y Q U E S T I O N A E E Y Q U S S T I O N A E E I Q U S S T Y O N A E E I N U S S T Y O Q A E E I N O S S T Y U Q A E E I N O Q S T Y U S ...
阅读全文
摘要：package com.qiusongde; import edu.princeton.cs.algs4.StdOut; public class Exercise2127 { public static void main(String[] args) { int T = 100; double previnse...
阅读全文
摘要：代码实现： 单元测试结果： 比较Insertion和InsertionHalfExchange 的性能：
阅读全文
摘要：结果： 比较奇怪的是Quick-union的运行时间比Quick-find的还要久。
阅读全文
摘要：Quick-find Quick-union Weighted-quick union
阅读全文
摘要：用归纳法推导： 1、height = 0时，成立，其level 0的节点个数为C(0,0)=1. height = 1时，成立，其level 0的节点个数为C(1,0)=1，其level 1的节点个数为C(1,1)=1. 2、假设height = n-1时，每个level的节点个数都是二次项系数。
阅读全文
摘要：运行结果： 0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 0 0 0 0 10 components4 30 1 2 4 4 5 6 7 8 9 0 0 0 0 1 0 0 0 0 0 9 components3 80 1 2 4 4 5 6 7 4 9 0 0 0 0 1 0 0
阅读全文
摘要：测试： 输入序列： 10 0 1 1 2 2 3 这样产生了长度为4的路径0->1->2->3。
阅读全文
摘要：Yes, but it could increase the tree height, so the performance guarantee would be invalid.
阅读全文
摘要：不可能。如果是weighted quick-union的话，6的父节点应该是5，而不是5的父节点是6。
阅读全文
摘要：假设原id数组： 0 1 1 4 4 8 6 1 8 0 输入p = 5, q = 7 则输出结果会出错，最终为： 0 1 1 4 4 1 6 1 8 0 因为当id[p]（id[5] = 8）被赋值为id[q]（id[7] = 1）之后，再用if(id[i] == id[p])来判断id[8]时，
阅读全文
摘要：算法（Algorithms）第4版 练习 1.5.1 算法（Algorithms）第4版 练习 1.5.2
阅读全文
摘要：对于weighted quick-union，对每个输入数据对，其最大的循环次数为lgN（sites） 故对于109 sites和106 input pairs，其总的指令次数为：sum = lg10^9 * 10^6 * 10 总的时间为：T = sum / 10^9 = 0.1s（约等于）
阅读全文
摘要：对于quick-find，对每个输入数据对，其最少的循环次数为N（sites） 故对于109 sites和106 input pairs，其总的指令次数为：sum = 10^9 * 10^6 * 10 总的时间为：T = sum / 10^9 / 3600 / 24 = 116 days
阅读全文
摘要：代码实现： reference input： 结果： worst-case input： 结果：
阅读全文
摘要：id数组和treesize数组变化情况： 森林图： 操作次数分析： find函数每次访问数组次数是1 + 2 * depth connected函数每次调用两次find函数 union函数每次调用两次find函数（如果两个连接点不在同一个树的话，则多一次数组访问） 对于这个client，对每个数据对
阅读全文
摘要：森林图： 操作次数分析： find函数每次访问数组次数是1 + 2 * depth connected函数每次调用两次find函数 union函数每次调用两次find函数（如果两个连接点不在同一个树的话，则多一次数组访问） 对于这个client，对每个数据对，都调用一次connected函数和uni
阅读全文
摘要：id数组的变化情况： 操作次数分析： find()函数每次调用访问数组1次。 connected函数每次调用两次find()函数，故访问数组2次。 union函数访问数组的次数为：2 + N + （1，N-1）。其中2为两次调用find（）函数，N为N次数组判断，（1，N-1）为可能的数组替换次数。
阅读全文
摘要：（1）sum = N + N/2 + N/4 + …… + 1 假设N是2的倍数(N = 2q)，则sum = N -1 ~ N （2）sum = 1+2+……N/2 同（1）分析，sum = N/2 -1 ~ N （3）N * logN ~ N * logN
阅读全文
摘要：a. N b. 1 c. 1 d. N3 e. 1 f. 1 g. 1(0)
阅读全文
摘要：=N(N-1)(N-2)/6
阅读全文
摘要：After copy Left on Stack r: be to not or be to Left on Stack copy: be to not or be to After r pop Left on Stack r: to not or be to Left on Stack copy: be to not or be to //1.3.42 Stac...
阅读全文
摘要：方法实现： 测试： 结果：
阅读全文
摘要：测试1： 1 3 5 0 4 2 6 测试2： 2 6 5 1 3 0 4
阅读全文
摘要：ADT： 代码实现以及测试： 输出结果：
阅读全文
摘要：双向链表实现： 测试用例： 结果输出：
阅读全文
摘要：package com.qiusongde; import java.util.Iterator; import java.util.NoSuchElementException; import edu.princeton.cs.algs4.StdIn; import edu.princeton.cs.algs4.StdOut; public class FixedCapacityStac...
阅读全文
摘要：was best times of the was the it (1 left on stack)
阅读全文
摘要：解题思路： 因为栈是后进先出的，又是按0到9这个顺序进行压栈的（push），因此如果pop出了某个值x，则后边比x小的值出现的顺序必须是逆序的。 举例，如果出现了4，则后边0 1 2 3出现的顺序必须是逆序的。 b中0 1不满足要求。 f中3 1 2不满足要求。 g中3 0 2不满足要求。
阅读全文
摘要：主要思路： 遇到左括号则一直压栈，遇到右括号时则从栈中弹出一个元素。 如果此时栈为空，则返回false。 如果这个元素与右括号不匹配，则返回false。 重复此过程，最后判断栈是否为空，若为空则返回true，否则返回false。 代码实现： 测试结果：
阅读全文
摘要：package com.qiusongde; import java.util.Iterator; import java.util.NoSuchElementException; import edu.princeton.cs.algs4.StdIn; import edu.princeton.cs.algs4.StdOut; public class Stack implements ...
阅读全文
摘要：方法实现： 测试结果：
阅读全文
摘要：主要思路： 用Dijkstra的双栈算法。 遇到数字则压入数字栈中（String）。 遇到运算符则压入运算符栈中（String）。 遇到右括号时，从数字栈和运算法栈中弹出相应的元素，生成相应的运算表达式（添加左括号）。 再次压入数字栈中（String）。 最后从数字栈中弹出最终的运算表达式。 方法实
阅读全文
摘要：主要思路：和1.3.9相似，只不过运算表达式的生成方式不一样 用Dijkstra的双栈算法。 遇到数字则压入数字栈中（String）。 遇到运算符则压入运算符栈中（String）。 遇到右括号时，从数字栈和运算法栈中弹出相应的元素，生成相应的运算表达式（后缀表示）。 再次压入数字栈中（String）
阅读全文
摘要：主要思路： 这个和Dijkstrad的双栈算法不太一样，后缀的计算只需要一个栈即可。 用一个栈来存数字栈即可。 遇到数字，压栈。 遇到运算法，从栈中弹出相应的数字，用该运算法计算得到结果。 再次压入栈中。 最终从栈中弹出最终运算结果。 方法实现： 测试1：( 2 + ( ( 3 + 4 ) * (
阅读全文
摘要：方法实现： 结果输出：
阅读全文
摘要：答案：bcd 解释：因为Queue是先进先出的，而且加进队列是0-9按顺序添加的。 故任意位置上后边的数字都不能比该位置小。 （b）中3 2 0 1在4后边 （c）中1 0 在2后边 （d）中3 2 1 0 在4后边
阅读全文
摘要：方法实现： 测试结果：
阅读全文
摘要：Queue： 测试用例： 测试结果：
阅读全文
摘要：1.3.18 Deletes from the list the node immediately following x.
阅读全文
摘要：package com.qiusongde.linkedlist; import java.util.Iterator; import java.util.NoSuchElementException; public class LinkedList implements Iterable { private Node first; //Node shou...
阅读全文
摘要：方法实现： 测试用例： 测试数据1： 输出结果： 测试数据2： 输出结果： 测试数据3： 输入为空 输出结果：
阅读全文
摘要：方法实现： 测试用例： 测试数据： 输出结果：
阅读全文
摘要：方法实现： 测试用例： 输入数据： 输出结果：
阅读全文
摘要：1.3.23 When it comes time to update t.next, x.next is no longer the original node following x, but is instead of itself! 1.3.22 Insert node t immediat
阅读全文
摘要：代码实现： 测试用例： 结果输出：
阅读全文
摘要：方法实现： 测试用例： 输入数据： 结果1： 结果2： 结果3： insertAtBeginning success: toto insertAtBeginning success: bebe to insertAtBeginning success: oror be to insertAtBegi
阅读全文
摘要：代码实现： 测试用例： 测试数据1： insertAtBeginning success: 1010 insertAtBeginning success: 2525 10 insertAtBeginning success: 3030 25 10 insertAtBeginning success:
阅读全文
摘要：代码实现： 测试数据； 输出结果：
阅读全文
