java分塊查找演算法

① 分塊查找演算法中如何對數據分塊

可以實現確定待查找數據的上限和下限，
然後對該區間等分N塊，
那麼這N塊就可以作為分塊查找的塊，
然後將原數組中的元素按區間插入進去，
當然，這樣劃分不能保證每個塊中的元素個數相等，
但是，分塊查找演算法並不嚴格要求每塊中的元素的個數相等。

② 數據查找和排序

java:
Java排序演算法
package com.cucu.test;

/**
* @author http://www.linewell.com <a href=mailto:[email protected]>[email protected]</a>
* @version 1.0
*/
public class Sort {

public void swap(int a[], int i, int j) {
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}

public int partition(int a[], int low, int high) {
int pivot, p_pos, i;
p_pos = low;
pivot = a[p_pos];
for (i = low + 1; i <= high; i++) {
if (a[i] > pivot) {
p_pos++;
swap(a, p_pos, i);
}
}
swap(a, low, p_pos);
return p_pos;
}

public void quicksort(int a[], int low, int high) {
int pivot;
if (low < high) {
pivot = partition(a, low, high);
quicksort(a, low, pivot - 1);
quicksort(a, pivot + 1, high);
}

}

public static void main(String args[]) {
int vec[] = new int[] { 37, 47, 23, -5, 19, 56 };
int temp;
//選擇排序法(Selection Sort)
long begin = System.currentTimeMillis();
for (int k = 0; k < 1000000; k++) {
for (int i = 0; i < vec.length; i++) {
for (int j = i; j < vec.length; j++) {
if (vec[j] > vec[i]) {
temp = vec[i];
vec[i] = vec[j];
vec[j] = temp;
}
}

}
}
long end = System.currentTimeMillis();
System.out.println("選擇法用時為：" + (end - begin));
//列印排序好的結果
for (int i = 0; i < vec.length; i++) {
System.out.println(vec[i]);
}
// 冒泡排序法(Bubble Sort)
begin = System.currentTimeMillis();
for (int k = 0; k < 1000000; k++) {
for (int i = 0; i < vec.length; i++) {
for (int j = i; j < vec.length - 1; j++) {
if (vec[j + 1] > vec[j]) {
temp = vec[j + 1];
vec[j + 1] = vec[j];
vec[j] = temp;
}
}

}
}
end = System.currentTimeMillis();
System.out.println("冒泡法用時為：" + (end - begin));
//列印排序好的結果
for (int i = 0; i < vec.length; i++) {
System.out.println(vec[i]);
}

//插入排序法(Insertion Sort)
begin = System.currentTimeMillis();
for (int k = 0; k < 1000000; k++) {
for (int i = 1; i < vec.length; i++) {
int j = i;
while (vec[j - 1] < vec[i]) {
vec[j] = vec[j - 1];
j--;
if (j <= 0) {
break;
}
}
vec[j] = vec[i];
}
}
end = System.currentTimeMillis();
System.out.println("插入法用時為：" + (end - begin));
//列印排序好的結果
for (int i = 0; i < vec.length; i++) {
System.out.println(vec[i]);
}

//快速排序法(Quick Sort)

Sort s = new Sort();
begin = System.currentTimeMillis();
for (int k = 0; k < 1000000; k++) {
s.quicksort(vec, 0, 5);
}
end = System.currentTimeMillis();
System.out.println("快速法用時為：" + (end - begin));
//列印排序好的結果
for (int i = 0; i < vec.length; i++) {
System.out.println(vec[i]);
}
}

}
以下是運行結果：
選擇法用時為：234
56
47
37
23
19
-5
冒泡法用時為：172
56
47
37
23
19
-5
插入法用時為：78
56
47
37
23
19
-5
快速法用時為：297
56
47
37
23
19
-5

③ java二分法查找的遞歸演算法怎麼實現

什麼是二分查找？

二分查找也稱折半查找（Binary Search），它是一種效率較高的查找方法。但是，折半查找要求線性表必須採用順序存儲結構，而且表中元素按關鍵字有序排列。

二分查找優缺點

優點是比較次數少，查找速度快，平均性能好；

其缺點是要求待查表為有序表，且插入刪除困難。

因此，折半查找方法適用於不經常變動而查找頻繁的有序列表。
使用條件：查找序列是順序結構，有序。

過程

首先，假設表中元素是按升序排列，將表中間位置記錄的關鍵字與查找關鍵字比較，如果兩者相等，則查找成功；否則利用中間位置記錄將表分成前、後兩個子表，如果中間位置記錄的關鍵字大於查找關鍵字，則進一步查找前一子表，否則進一步查找後一子表。重復以上過程，直到找到滿足條件的記錄，使查找成功，或直到子表不存在為止，此時查找不成功。

利用循環的方式實現二分法查找

public class BinarySearch {
public static void main(String[] args) {
// 生成一個隨機數組 int[] array = suiji();
// 對隨機數組排序 Arrays.sort(array);
System.out.println("產生的隨機數組為： " + Arrays.toString(array));

System.out.println("要進行查找的值： ");
Scanner input = new Scanner(System.in);
// 進行查找的目標值 int aim = input.nextInt();

// 使用二分法查找 int index = binarySearch(array, aim);
System.out.println("查找的值的索引位置： " + index);

}

/** * 生成一個隨機數組 *
* @return 返回值，返回一個隨機數組 */
private static int[] suiji() {
// random.nextInt(n)+m 返回m到m+n-1之間的隨機數 int n = new Random().nextInt(6) + 5;
int[] array = new int[n];
// 循環遍歷為數組賦值 for (int i = 0; i < array.length; i++) {
array[i] = new Random().nextInt(100);
}
return array;
}

/** * 二分法查找 ---循環的方式實現 *
* @param array 要查找的數組 * @param aim 要查找的值 * @return 返回值，成功返回索引，失敗返回-1 */
private static int binarySearch(int[] array, int aim) {
// 數組最小索引值 int left = 0;
// 數組最大索引值 int right = array.length - 1;
int mid;
while (left <= right) {
mid = (left + right) / 2;
// 若查找數值比中間值小，則以整個查找范圍的前半部分作為新的查找范圍 if (aim < array[mid]) {
right = mid - 1;
// 若查找數值比中間值大，則以整個查找范圍的後半部分作為新的查找范圍 } else if (aim > array[mid]) {
left = mid + 1;
// 若查找數據與中間元素值正好相等，則放回中間元素值的索引 } else {
return mid;
}
}
return -1;
}}
運行結果演示：

總結：

遞歸相較於循環，代碼比較簡潔，但是時間和空間消耗比較大，效率低。在實際的學習與工作中，根據情況選擇使用。通常我們如果使用循環實現代碼只要不是太繁瑣都選擇循環的方式實現~

④ JAVA中的查找演算法如何實現... 高手幫幫忙

這個。。。我隨便亂說幾句啊，說的不對別見笑。

有一個數組 當中存有一些字元串
另外有一個字典文件 我也將它導入一個數組 有50000多個單詞
然後要找出字元串中包含的單詞

由你給的條件可知：
1。數組 應該是從前到後依次順序掃描字元串。
2。50000多個單詞的字典文件一定優化。具體優化要看具體內容吧。
比如你可以按單詞的首字母排序，然後分組。等掃描字元串的時候可以分組比較。但這種方法應該沒省多少時間。
你還可以把50000多個單詞的字典文件按單詞的長度進行分組。比如1個字母的分成一組，二個字母的分成一組。。。。N個字母的分成一組，這樣就分成了N組。然後掃描字元串的時候你可以按後續匹配（好象叫這個演算法吧，名字記不清了）演算法，這樣就可以省很多時間了。
你還可以這樣做，因為你要查的是單詞，單詞一定有意義。那你可以直接把你的字元串數組先進行語法、語義分析並分割，然後再去匹配你的字典。這樣應該是最快的。但這要用到自然語言處理。。。

⑤ 求分塊查找演算法 最好有代碼和詳細注釋

注意：採用「二分查找」時，初始的數組或其他線性表中的每個元素都必須是按一定的順序排列的（從大到小，或從小到大），
該演算法的基本思想：對一個有序數據序列，總是先把查找目標與該序列的中間的元素進行比較，我們假設該序列是由從小到大排列的，if(key > data[mid]),則key一定在data[mid]的又邊，於是，把mid到序列data[end]分成一塊，此時mid = (mid + end) / 2,依次類推

參考程序：

#include<stdio.h>
#define MAXSIZE 26 //定義索引表的最長長度
typedef char TYPE;

int blksearch(TYPE R[],TYPE K);
void main()
{
int num, i;
TYPE R[N + 1];
TYPE K;

for(i = 0;i<N;i++)
R[i]='a'+i;
printf("\nplease input the key number:\n");
K=getchar();
num=blksearch(R,K);

if(num!=-1)
printf("第%d個是關鍵字\n",num+1);
else
printf("查找失敗！\n");
}

int blksearch(TYPE R[],TYPE K) //分塊查找
{
int low1,mid,high1;
low1=0;
high1=N - 1; //二分查找區間上下界初值
while(low1<=high1)
{
mid=(low1+high1)/2;

if(K < R[mid])
high1=mid-1;
else
if(K > R[mid])
low1=mid+1;
else
return mid; //如果找到key，立即返回key的位置

}
return -1;// 只要上面的return語句沒執行，則原數組中無key，返回-1

}

⑥ 什麼叫java中的二分查找法

1、演算法概念。

二分查找演算法也稱為折半搜索、二分搜索，是一種在有序數組中查找某一特定元素的搜索演算法。請注意這種演算法是建立在有序數組基礎上的。

2、演算法思想。

①搜素過程從數組的中間元素開始，如果中間元素正好是要查找的元素，則搜素過程結束；

②如果某一特定元素大於或者小於中間元素，則在數組大於或小於中間元素的那一半中查找，而且跟開始一樣從中間元素開始比較。

③如果在某一步驟數組為空，則代表找不到。

這種搜索演算法每一次比較都使搜索范圍縮小一半。

3、實現思路。

①找出位於數組中間的值，並存放在一個變數中（為了下面的說明，變數暫時命名為temp）；

②需要找到的key和temp進行比較；

③如果key值大於temp，則把數組中間位置作為下一次計算的起點；重復① ②。

④如果key值小於temp，則把數組中間位置作為下一次計算的終點；重復① ② ③。

⑤如果key值等於temp，則返回數組下標，完成查找。

4、實現代碼。

/**
*description:二分查找。
*@paramarray需要查找的有序數組
*@paramfrom起始下標
*@paramto終止下標
*@paramkey需要查找的關鍵字
*@return
*/
publicstatic<EextendsComparable<E>>intbinarySearch(E[]array,intfrom,intto,Ekey)throwsException{
if(from<0||to<0){
("paramsfrom&lengthmustlargerthan0.");
}
if(from<=to){
intmiddle=(from>>>1)+(to>>>1);//右移即除2
Etemp=array[middle];
if(temp.compareTo(key)>0){
to=middle-1;
}elseif(temp.compareTo(key)<0){
from=middle+1;
}else{
returnmiddle;
}
}
returnbinarySearch(array,from,to,key);
}

⑦ 快速查找演算法 具體文字描述 附java程序更好 拜託各位了

快速查找演算法 有叫做二分發，前提是必須對有序數組中的元素進行遞歸查找， 首先假設目標在數組中中間位置，與中間位置比較，如大於，則重左側開始查找，如小於，則右側開始查找，這樣每次查找都能排除當前的一半，

⑧ java中哪種查找演算法最有效率

這個問題不能一概而論

如果有一種演算法優於其他演算法，那麼其他演算法就不存在了不是？

所以，要看在什麼情況下，那麼有這么幾個方面

1. 背景數量級和匹配數量級，就是說你要在多少數據中查找多少數據。

2. 背景數據差異度，背景數據如果包羅萬象，或者都是數字，那麼選擇的演算法區別就大了

3. 背景數據整理程度。很多人在選擇查找演算法時不考慮這個，但是這在實際應用中很有異議，比如數據都排序過和沒有排序過，可想而知演算法的選擇有很大的不同。

4. 匹配方式，是用「等於」 這種方式匹配，還是用like這種方式匹配，也對演算法有很大影響。

⑨ 怎麼計算java二分法查找的比較次數

您好，我來為您解答：
演算法：當數據量很大適宜採用該方法。採用二分法查找時，數據需是有序不重復的。 基本思想：假設數據是按升序排序的，對於給定值 x，從序列的中間位置開始比較，如果當前位置值等於 x，則查找成功；若 x 小於當前位置值，則在數列的前半段中查找；若 x 大於當前位置值則在數列的後半段中繼續查找，直到找到為止。
希望我的回答對你有幫助。

⑩ java 多條件 查詢 演算法

將數據轉換成16進制，可以用InteInteger.toHexString()這個方法。

將16進制轉換成10進制，可以用intValue()方法。

高低位轉換就不知道了哦。。。

下面是測試代碼，希望能幫到你～！

public class DataTransfer {

public static void main(String[] args) {
// TODO Auto-generated method stub
Integer a = -1;
System.out.println(Integer.toHexString(a));
Integer b = 0xff;
System.out.println(b.intValue());
}

}

下面這個是在網上找到的，高低位轉換：

// Java讀取後，順序已經反了
int javaReadInt = ;

// 將每個位元組取出來
byte byte4 = (byte) (javaReadInt & 0xff);
byte byte3 = (byte) ((javaReadInt & 0xff00) >> 8);
byte byte2 = (byte) ((javaReadInt & 0xff0000) >> 16);
byte byte1 = (byte) ((javaReadInt & 0xff000000) >> 24);

// 拼裝成 正確的int
int realint = (byte1& 0xff)<<0 + (byte2& 0xff)<<8 + (byte3& 0xff)<< 16 +(byte4& 0xff)<<24 ;