实验三-总结博客
实验三-查找与排序-3
参考http://www.cnblogs.com/maybe2030/p/4715035.html 在Searching中补充查找算法并测试
提交运行结果截图
斐波那契查找
-
1.斐波那契数列
斐波那契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、····，在数学上，斐波那契被递归方法如下定义：F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2) （n>=2）。该数列越往后相邻的两个数的比值越趋向于黄金比例值（0.618）。 -
2.实现思路
我认为斐波那契查找和二分查找的区别不大，唯一的区别是二分查找的划分是对半分，而斐波那契查找是根据斐波那契数列进行的划分。但我们知道斐波那契查找的算法复杂度依旧是O(log 2 n )，而且实现还很复杂，所以斐波那契查找相较于二分查找的好处是在每次计算mid的值的时候避免了"除法"，只是涉及到了"加法和减法"，而除法的运算本身就比加减法更加占用时间。
如何进行查找。之所以斐波那契查找避免了除法，是因为我们一开始构造了一个斐波那契数列，每次划分只需要从数列中拿出相应的两个数就行。斐波那契数列：1、1、2、3、5、8、13、21、34、55、89……从第三个数开始，每个数等于前两个数的和，巧妙利用这一点我们在每次比较后对于mid的赋值就不必像二分查找mid = (first + last ) / 2，而是mid = first+fib[idex-1]-1,fib是我们构造的一个斐波那契数列，正是要利用斐波那契数列的特点进行分割，我们就必须根据要进行查找的数组来从fib数组中确定一个数m.这里会出现两种情况：（1）数组长度刚好符合fib数列中的某个数；（2）fib数组找不到恰当的数，这时候就需要将原数组进行扩充，我们采用重复填入最后一个数。如果m = fib[n],那么第一次划分就将数组分为两个部分它们分别含有fib[n-1]和fib[n-2]个元素，然后进行比较，再根据比较的结果再对数组进行划分。
public static Comparable FibonacciSearch(Comparable[] data, Comparable target) {
int idex = 0;
int[] fib = SetFibonacci();
while (data.length>fib[idex]){
idex++;
}
Comparable[] fibdata = new Comparable[fib[idex]];
;
for (int i = 0;i<fibdata.length;i++){
if (i<data.length){
fibdata[i] = data[i];
}
else
fibdata[i] = data[data.length-1];
}
int first=0;
int last = fibdata.length-1;
int mid = 0;
while (first<= last){
mid = first+fib[idex-1]-1;
if (fibdata[mid].compareTo(target)>0){
last = mid;
idex = idex-1;
}
else if (fibdata[mid].compareTo(target)<0){
first = mid;
idex = idex-2;
}
else {
if (mid<=last)
return mid;
else
return last;
}
}
return -1;
}
//构造Fibonacci数列
public static int[] SetFibonacci() {
int[] fib = new int[20];
int i = 0;
fib[0] = 1;
fib[1] = 1;
for (i = 2; i < fib.length; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
}
return fib;
}
插值查找
- 原理：插值查找的主要思路就是划分数组的查找点是自适应，所以该查找的前提是有序数列元素的值是成线性增长的。
二分查找中查找点计算如下：
mid=(low+high)/2, 即mid=low+1/2(high-low);
通过类比，我们可以将查找的点改进为如下：
mid=low+(key-a[low])/(a[high]-a[low])(high-low)，
也就是将上述的比例参数1/2改进为自适应的，根据关键字在整个有序表中所处的位置，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。
- 加入我们要在[1,100]中找到15，我们设15的下标为m,第一个数的下标（first）,第二个数的下标(last),由于数列线性增长，我们不难得到(m-first)/(last-first) ≈ (15-A[first])/(A[last]-A[first])进而得到：m = first + (15-A[first])/(A[last]-A[first])*(last-first).
public static Comparable InsertionSearch(Comparable[] data, Comparable target, int key, int low, int hight) {
if (key < low || key > hight || low < hight) {
throw new NumberFormatException("Wrong number");
} else {
int mid;
Comparable result = null;
while (result == null && low <= hight) {
mid = low + (key - low) / (hight - low) * (hight - low);
if (data[mid].compareTo(target) == 0) {
result = data[mid];
} else if (data[mid].compareTo(target) > 0)
hight = mid - 1;
else
low = mid + 1;
}
return result;
}
}
实验三-查找与排序-4
补充实现课上讲过的排序方法：希尔排序，堆排序，桶排序，二叉树排序等
测试实现的算法（正常，异常，边界）
提交运行结果截图
推送相关代码到码云上
堆排序
- 利用已经完善的类LinkedMaxHeap，现将要排序的数组的元素加入到堆（最大）中，利用removeMax()方法将元素按照从大到小输出。
public static void HeapSort(Comparable[] data){
LinkedMaxHeap myTree = new LinkedMaxHeap();
for (int i=0;i<data.length;i++){
myTree.add(data[i]);
}
for (int i=0;i<data.length;i++){
data[i]=myTree.removeMax();
}
}
