一、查找算法:
(1)顺序查找
int[] arr = {-1,34,9,11,89};
public static int seqSearch(int[]arr,int key){
逐一比对,发现有相同的值时返回下标
for(int i = 0;i<arr.length;i++){
if(arr[i]==key){
return i;
}
}
return -1;
}
(2)二分查找:
待查找的数组必须是有序的
思路分析:
a.首先确定该数组的中间的下标:mid = (left+right)/2
b.让需要查找的数的findVal和arr[mid]比较
c.如果findVal大于arr[mid],则需要递归向右查找
d.如果findVal小于arr[mid],则需要递归向左查找
e.如果findVal等于arr[mid],则直接返回mid
结束递归的情况:
a.找到待查找的数据
b.递归完毕整个数组仍然没有找到待查找的数据;也就是left>right
代码实现:
public static int binarySearch(int[]arr,int left,int right,int key){
int mid = (left+right)/2;
int midVal = arr[mid];
if(left>right){
return -1;
}
if(midVal<key){
return binarySearch(arr,mid+1,right,key);
}else if(midVal>key){
return binarySearch(arr,left,mid-1,key);
}else{
return mid;
}
}
当需要返回多个值时,找到mid索引值时不要马上返回
向mid索引值的左边扫描,找到待查找的数据将其索引加入到ArrayList中
向mid索引值的右边扫描,找到待查找的数据将其索引加入到ArrayList中
public static ArrayList<Integer> binarySearch(int[]arr,int left,int right,int key){
int mid = (left+right)/2;
int midVal = arr[mid];
ArrayList<Integer> a = new ArrayList<>();
if(left>right){
return new ArrayList<Integer>();
}
if(midVal<key){
return binarySearch(arr,mid+1,right,key);
}else if(midVal>key){
return binarySearch(arr,left,mid-1,key);
}else{
int temp = mid - 1;
while(true){
if(temp<0||arr[temp]!=key){
break;
}
a.add(temp);
temp-=1;
}
a.add(mid);
int temp = mid + 1;
while(true){
if(temp<0||arr[temp]!=key){
break;
}
a.add(temp);
temp+=1;
}
}
return a;
}
(3)插值查找:
插值查找算法类似于二分查找,不同的是插值查找每次从自适应mid处开始查找
对于数据量比较大,关键字比较分布均匀的情况下比较实用,如果分布不均匀,则推荐使用二分查找
代码实现:
public static int insertValueSearch(int[]arr,int left,int right,int key){
int mid = left+(right-left)*(key-arr[left])/(arr[right]-arr[left]);
int midVal = arr[mid];
if(left>right||key<arr[0]||key>arr[arr.length-1]){
return -1;
}
if(midVal<key){
return binarySearch(arr,mid+1,right,key);
}else if(midVal>key){
return binarySearch(arr,left,mid-1,key);
}else{
return mid;
}
}
当需要返回多个值时,找到mid索引值时不要马上返回
向mid索引值的左边扫描,找到待查找的数据将其索引加入到ArrayList中
向mid索引值的右边扫描,找到待查找的数据将其索引加入到ArrayList中
public static ArrayList<Integer> binarySearch(int[]arr,int left,int right,int key){
int mid = left+(right-left)*(key-arr[left])/(arr[right]-arr[left]);
int midVal = arr[mid];
ArrayList<Integer> a = new ArrayList<>();
if(left>right||key<arr[0]||key>arr[arr.length-1]){
return new ArrayList<Integer>();
}
if(midVal<key){
return binarySearch(arr,mid+1,right,key);
}else if(midVal>key){
return binarySearch(arr,left,mid-1,key);
}else{
int temp = mid - 1;
while(true){
if(temp<0||arr[temp]!=key){
break;
}
a.add(temp);
temp-=1;
}
a.add(mid);
int temp = mid + 1;
while(true){
if(temp<0||arr[temp]!=key){
break;
}
a.add(temp);
temp+=1;
}
}
return a;
}
(4)斐波那契查找:
斐波那契查找原理与前两种相似,仅改变了中间结点(mid)的位置。此时mid不再是中间或插值得到的,而是位于黄金分割点附近,即mid=low+F(k-1)-1,其中F代表斐波那契数列。
对F(k-1)-1的理解:
只要顺序表的长度为F(k)-1,则可以将该表分成长度为F(K-1)-1和F(K-2)-1的两段,从而中间位置mid=low+F(k-1)-1;类似的,每一子段也可以用相同的方式分割;
但顺序表长度n不一定刚好等于F(K)-1,所以需要将原来的顺序表长度n增加至F(K)-1,这里的k值只要能使得F(K)-1恰好大于或等于n即可,新增的位置都赋为n位置的值即可。
代码实现:
static int maxSize = 20;
int[] arr = {1,8,10,89,1000,1234};
public static int[] fib(){
int[] arr = new int[maxSize];
f[0] = 1;
f[1] = 1;
for(int i = 2;i<maxSize;i++){
f[i] = f[i-1] + f[i-2];
}
return f;
}
public static int fibSearch(int[]a,int key){
int low = 0;
int high = a.length - 1;
int k = 0;//表示斐波那契分割数值的下标
int mid = 0;//存放mid值
int []f = fib();
//获取到斐波那契分割数值的下标
while(high>f[k]-1){
k++;
}
//因为f[k]可能大于a的长度,因此需要使用Arrays构造一个新的数组并指向a
//并使用a数组的最后数填充temp
int[]temp = Arrays.copy(a,f[k]);
for(int i = high+1;i<temp.length;i++){
temp[i] = a[high];
}
while(low<=high){
mid = low + f[k] - 1;
if(key<temp[mid]){
high = mid - 1;
//全部元素 = 前部元素 + 后部元素
//f[k] = f[k-1] + f[k-2];
//因为前面有f[k-1]个元素,可以继续拆分为f[k-1] = f[k-2] + f[k-3]
//即在f[k-1]前面继续查找,所以需要k--
key--;
}else if(key>temp[mid]){
low = mid + 1;
//全部元素 = 前部元素 + 后部元素
//f[k] = f[k-1] + f[k-2];
//因为后面有f[k-2]个元素,可以继续拆分为f[k-2] = f[k-3] + f[k-4]
//即在f[k-2]前面继续查找,所以需要k-=2
key-=2;
}else{
if(mid<=high){
return mid;
}else{
return high;
}
}
}
return -1;
}