hailushijie的专栏

Euclid求最大公约数规则：1. 如果a除以b能整除,则最大公约数是b。2. 否则,最大公约数等于b和a%b的最大公约数。

1、抽象数据类型是带有一组操作的一些对象的集合。它是数学抽象，大体包含了操作和数据两部分。2、表：对于任何非空表，除了第一个元素，其后的每个元素都有一个前驱，除了最后一个元素，其前的每一个元素都有一个后继。对表上的数据，可以有查找、插入、删除、打印，查找某个元素是否在数组中包含等操作。对于表这种结构，采用不同的实现方式，对于上述操作的时间复杂度也就是运行性能会有影响。如果采用数组实现表

欧几里的算法：计算最大公因数。两个整数的最大公因数就是同时整除二者的最大整数。算法连续计算余数直至余数为0为止，最后的非零余数最时最大公因数。案例：package 最大公因数;public class MaxCommonNum { public static void main(String args[]){ int num1 = 50; int num2 = 15;

分治法和折半查找都是时间复杂度为O（log N）。折半查找：给定一个整数X和整数数组A[]，元素为a,b,c....n,后者这个数列已经预先排序并在内存中，求下标i使得A[i] =X,如果数组内不存在X，则返回-1.解法：如果按照数组的内容，从左到右顺序扫描一遍，那么将要花费线性时间。并且没有用到数组已经排序的事实。折半查找是解决这类问题的一个好办法，首先检查数组居中的元素是否和X

/** * 希尔排序 又叫缩减增量排序 * 在使用增量h的一次排序之后，对于每一个i，我们都有a[i]（小于等于）a[i+k]。所有相隔h的元素都被排序 * 增量序列的不同，时间复杂度也不同。 * 下面程序所用增量，是希尔增量，即默认增量，最坏时间分析为O（N的平方） * Hibbard提出了他的增量，形如：1,3,5,7....（2的k次方-1),这个增量的好处在于增量之间没有公因子

/** * 从0位置开始，依次和后面所有元素进行比较，并将小数交换到前面。 * o(N*N) * @author *冒泡排序，选择排序，插入排序，交换排序属于简单排序方法 */public class ExchangeSort { private static int[] array = new int[]{1,8,2,9,3,7,11,23,90,4,5}; public sta

/** * 快速排序,分治策略。该递归发挥作用了 * 第一步,固定temp=array[0] * 第二步，j=array.length-1.从j向左（j--）开始遍历查找第一个小于temp的元素，替换。 * 第三步，i=0,从i开始向右（i++）遍历查找大于temp的第一个元素，替换。 * 判断i==j， * 如果相等，递归。 * 如果不等，循环第二、三步。 * @author

迭代器模式：提供一个方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。迭代器模式提供了一种方法，可以顺序访问一个聚合对象中的元素，而又不用知道内部是如何标示的。另外，迭代器模式把在元素之间游走的责任交给迭代器，而不是聚合对象，让聚合更专注于数据集合。案例实现情景：我和友人去超市分头购物，在结帐时，我们遍历一下我们的 “扫货” 清单（遍历打印购物清单），在实现上，Me使用Arra

自定义Map集合的两种方式在我们的实际工作中，我们可能需要自定义Map集合接口，例如：扩展Map接口的方法功能，控制Map接口对外部的操作接口等。以下介绍了常用的两种方式：

幂运算：就是n个x相乘。例如：求x的三次方、四次方、n次方等。那么我们要计算x的n次幂，那么我们要连续执行n次x的相乘，花费时间为线性时间。现在有一个O(logN)的算法。原理：如果n为偶数，x的n次方== x的n/2次方 * x的n/2次方相乘。如果n为奇数，x的n次方 == x的n/2次方 * x的n/2次方 * x。 案例：package 幂运算;public c

与或非，由于是直接操作二进制，因而在程序中是执行最快的语句。很多与或非可以实现很多非常巧妙的操作，在此整理一下，随时更新。1、与或非实现信息状态的加减package TwoCode;public class Encode { public static void main(String args[]){ Message message = new Message(Messa

/** * 两两比较，小数在前，大数在后。一次排序后，最小值交换到最前面，类似冒泡。 * o（N*N） * @author * 冒泡排序，选择排序，插入排序，交换排序属于简单排序方法 */public class BubbleSort { private static int[] array = new int[]{1,8,2,9,3,7,11,23,90,4,5}; public

/** * 在一趟比较后选出最小的，交换到前面。 * 比如，第一趟，从1位置开始选择出最小的，跟0位置交换，否则不交换。 * 第二趟，从2位置开始选择出最小数，跟1位置交换，否则不交换。 * 执行n-1次交换，得到顺序序列。 * o（n*n） * @author *冒泡排序，选择排序，插入排序，交换排序属于简单排序方法,再简单排序中，选择排序效率最高 */public class

/** * 桶式排序 * 第一步：查找排序数组array中元素的最大值，max * 第二步：初始化计数数组count，数组长度为max+1 * 第三步：count[array[i]]++。 * 例如排序数组array为1,2,4,5,6,0,那么count：[0,0,0,0,0,0,0],执行count[array[i]]后[1,1,1,0,1,1,1] * 第四步：执行count[i

/** * 归并排序 * 合并两个已排序好的数组花费线性时间，归并排序用到了这个性质。 * 采用分治策略，递归的分，直到只有一个或者两个元素，结束递归。采用merge函数合并。 * @author * */public class MergeSort { private static int[] array = new int[]{1,8,2,9,3,7,11,23,90,4,5}

随着代码量的增加，意识到写出一个工作程序并不够，如果程序在巨大的数集上运行，那么程序运行时间就变成了一个重要的问题。我们要在尚未编码的情况下比较两个程序的运行时间。以及改进程序的速度以及确定程序执行的瓶颈，然后检查程序，优化存在性能的代码段。这些都是数据结构带给我们的。算法分析：平均运行时间反应了程序运行的典型行为，最坏运行时间则代表对所有可能输入的一种保证。程序效率运行时间计算模型：

/** * 插入排序利用到了这样的事实：0到p-1上的元素，全部处于已排序状态。 * 插入排序没有数据替换，而是用到了数据移动。 * 位置p上的元素，储存于temp上，p之前所有更大的元素向右移动一个位置，然后temp被置于正确的位置上。 * 由于嵌套循环，因此插入排序的时间复杂度为O（N的平方 ） * @author * */public class SimpleInsertMe

/** * 双向冒泡排序，从左向右冒泡排序，大数沉底，然后从右向左排序，小数冒泡。如此循环。 * @author * */public class BubbleTwoSort { private static int[] array = new int[]{1,8,2,9,3,7,11,23,90,4,5}; public static void main(String args[

/** * 基数排序 * 结合桶式排序，分两种从高位到低位和从低位到高位。案例代码为从低位到高位 * 第一步：得到数组内最大位数 * 第二步：进行多次 桶式排序，次数为排序最大数字的位数 * 例子：52,38,23,72,271 * 第一步：数组元素最大位数为3, * 第二步：第一次桶式排序，针对数组元素的个位：排序结果为：271，52,72,23,38，按个位桶式排序就完成了 *