20162328蔡文琛 实验三 查找与排序
20162328蔡文琛 大二 实验三 查找与排序
实验三(1)
这个实验要求我们对之前实现的查找类以及排序类进行测试，并实现排序类的正序和逆序的实现。
实验三(2)
实验要求对(1)中的代码进行重构，并使用bash编译并运行代码。
实验三(3)
实验要求实现：插值查找，斐波那契查找，数值查找，分块查找，哈希查找。
插值查找
public static int interpolationSearch(int[] a, int key) {
int low, mid, high;
low = 0;// 最小下标
high = a.length - 1;// 最大小标
while (low < high) {
mid = low + (high - low) * (key - a[low]) / (a[high] - a[low]);
if (key > a[mid]) {
low = mid + 1;
} else if (key < a[mid]) {
high = mid - 1;
} else {
return mid;
}
}
return -1;
}
斐波那契查找
public static int fibonacci_search(int[] a, int key, int n){
int low = 0, high = n-1;
int mid = 0;
int k = 0;
int[] F = new int[MAXSIZE];
fibonacci(F);
while( n > F[k]-1){ //确保fibonacci数列中的值可以表示整个待搜索数组中的位置
++k;
}
//将待搜索数组的规模扩展为F[k]-1；原来不足的部分用a[high]填充
int[] tempArray = new int[F[k]-1];
for (int i = n; i < F[k]-1; i++) {
tempArray[i] = a[high];
}
for (int i = 0; i < n; i++) {
tempArray[i] = a[i];
}
a = tempArray;
//对于规模为F[k]-1的数组
//黄金分割搜索， 每次将数组分为三部分，
//第一部分为从low（包含）开始的F[k-1]-1个元素，到mid-1（包含）为止;
//第二部分即为单个的a[mid],其中 mid = low+F[k-1]-1;
//第三部分为 从啊mid+1 （包含）开始的F[k-2]-1个元素，到high为止
//每次循环均遵循这一规律
while(low <= high){
mid = low + F[k-1] -1;
if (a[mid] > key) {
high = mid -1;
k = k - 1;
}else if (a[mid] < key){
low = mid + 1;
k = k - 2;
}else{
if (mid <= high) {
return mid;
}else {
return -1;
}
}
}
return -1;
}
哈希查找
public static int searchHash(int[] hash, int hashLength, int key) {
// 哈希函数
int hashAddress = key % hashLength;
// 指定hashAdrress对应值存在但不是关键值，则用开放寻址法解决
while (hash[hashAddress] != 0 && hash[hashAddress] != key) {
hashAddress = (++hashAddress) % hashLength;
}
// 查找到了开放单元，表示查找失败
if (hash[hashAddress] == 0)
return -1;
return hashAddress;
}
public static void insertHash(int[] hash, int hashLength, int data) {
// 哈希函数
int hashAddress = data % hashLength;
// 如果key存在，则说明已经被别人占用，此时必须解决冲突
while (hash[hashAddress] != 0) {
// 用开放寻址法找到
hashAddress = (++hashAddress) % hashLength;
}
// 将data存入字典中
hash[hashAddress] = data;
}
实验三(4)
实验要求实现希尔排序，堆排序，桶排序，二叉树排序。
桶排序
public static int[] countSort1(int[] arr){
if (arr == null || arr.length == 0) {
return null;
}
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
//找出数组中的最大最小值
for(int i = 0; i < arr.length; i++){
max = Math.max(max, arr[i]);
min = Math.min(min, arr[i]);
}
int help[] = new int[max];
//找出每个数字出现的次数
for(int i = 0; i < arr.length; i++){
int mapPos = arr[i] - min;
help[mapPos]++;
}
int index = 0;
for(int i = 0; i < help.length; i++){
while(help[i]-- > 0){
arr[index++] = i+min;
}
}
return arr;
希尔排序
public static void shellSortSmallToBig(int[] data) {
int j = 0;
int temp = 0;
for (int increment = data.length / 2; increment > 0; increment /= 2) {
System.out.println("increment:" + increment);
for (int i = increment; i < data.length; i++) {
// System.out.println("i:" + i);
temp = data[i];
for (j = i - increment; j >= 0; j -= increment) {
// System.out.println("j:" + j);
// System.out.println("temp:" + temp);
// System.out.println("data[" + j + "]:" + data[j]);
if (temp < data[j]) {
data[j + increment] = data[j];
} else {
break;
}
}
data[j + increment] = temp;
}
for (int i = 0; i < data.length; i++)
System.out.print(data[i] + " ");
}
}
堆排序
public static void adjustHeap(int[] a, int i, int len) {
int temp, j;
temp = a[i];
for (j = 2 * i; j < len; j *= 2) {// 沿关键字较大的孩子结点向下筛选
if (j < len && a[j] < a[j + 1])
++j; // j为关键字中较大记录的下标
if (temp >= a[j])
break;
a[i] = a[j];
i = j;
}
a[i] = temp;
}
public static void heapSort(int[] a) {
int i;
for (i = a.length / 2 - 1; i >= 0; i--) {// 构建一个大顶堆
adjustHeap(a, i, a.length - 1);
}
for (i = a.length - 1; i >= 0; i--) {// 将堆顶记录和当前未经排序子序列的最后一个记录交换
int temp = a[0];
a[0] = a[i];
a[i] = temp;
adjustHeap(a, 0, i - 1);// 将a中前i-1个记录重新调整为大顶堆
}
}
代码参考
http://blog.csdn.net/vmxplus/article/details/45845451
http://blog.csdn.net/xiaoping8411/article/details/7706376
http://blog.csdn.net/l294265421/article/details/45848677
http://blog.csdn.net/jianyuerensheng/article/details/51258460
https://www.cnblogs.com/developerY/p/3319618.html
