有序數組查找演算法

⑴ 查找演算法：採用二分法在有序數組 中查找一數，指出數的位置和查找次數。

#include<iostream>
usingnamespacestd;

voidBinarySearch(int*list,intlen,intkey,int*index_t){
	//最低邊界
	intlow=0;
	//最高邊界
	inthigh=len-1;
	while(low<=high){
		index_t[0]++;
		//取中間值
		intmiddle=(low+high)/2;
		if(list[middle]==key){
			index_t[1]=middle;
			return;
		}
		elseif(list[middle]>key){
			//下降一半
			high=middle-1;
		}
		else{
			//上升一半
			low=middle+1;
		}
	}
	//沒找到
	index_t[1]=-1;
}

intmain(){
	constintN=10;
	intlist[N]={3,9,11,12,21,23,56,61,89,98};
	intindex_t[2]={0};
	BinarySearch(list,N,12,index_t);
	
	cout<<"查找次數為:"<<index_t[0]<<endl;
	if(index_t[1]!=-1)
		cout<<"已經找到12,索引位置為:"<<index_t[1]<<endl;
	else
		cout<<"沒找到!"<<endl;
}

⑵ 在一個有序的數列中查找一某一數據項，使用順序、插入、二分法三種演算法來編程實現，其效率的高低排序是

打個比方，比如數組有100個元素，找出中間的元素，也就是第50個元素，和你輸入的整數做比較大小。如果整數小，就在0-50元素中再找中間元素，如果整數大，就在51-100元素中找中間元素。依此類推，最終能找到整數在數組中的位置。

⑶ C++有序數組查找問題

二分法查找演算法，數據結構應該學的，隨手寫個代碼如下：
int binsearch(int *a, int length, int key)
{
int low=0;
int high = length-1;
if(a[low]==key)
{
return low;
}
if(a[high]==key)
{
return high;
}
while(low<=high)
{
mid=low+(high-low)/2;
if(a[mid]==key)
{
return mid;
}
if(a[mid]>key)
{
high = mid-1;
}
else
{
low = mid+1;
}
if(low>high)
return -1;
}
}

⑷ 找兩個有序數組的中位數的幾種方式

我用5個思路的來解決兩個非減序數組的中位數.但是成功的只有四個,思路3邊界問題太嚴重.
有時間再來弄好他,他在考試中也不適合使用(邊界問題沒法快速解決,網上也有人說小數據枚舉法確定邊界),總的來說費事.

主函數:

#include<stdio.h>
#include<time.h>
#include<limits.h>

doublefindMedianSortedArrays_1(int*nums1,intnums1Size,int*nums2,intnums2Size);
doublesss(inta[],intm,intb[],intn,intk);
doublefindMedianSortedArrays_2(int*nums1,intnums1Size,int*nums2,intnums2Size);
doublefindMedianSortedArrays_3(int*nums1,intnums1Size,int*nums2,intnums2Size);
doublefindMedianSortedArrays_4(int*nums1,intnums1Size,int*nums2,intnums2Size);
doublefindMedianSortedArrays_5(int*nums1,intnums1Size,int*nums2,intnums2Size);

intmain(){
	clock_tstart_t,end_t;
	doubletotal_t;
	doublemid=0;
//			1234567891011
	intstr1[1000]={0,2,4,5,7,9,10,15,21,23,25},
	str2[1000]={5,6,9,15,17,18,20,23,24,26,27,29,50};
//			12345678910111213
	start_t=clock();
	mid=findMedianSortedArrays_1(str1,11,str2,13);
	end_t=clock();
	total_t=(double)((double)end_t-(double)start_t)/CLOCKS_PER_SEC;
	printf("方法1:CPU佔用的總時間：%fns
",(total_t*1000000000));
	printf("中位數%f
",mid);

	start_t=clock();
	mid=findMedianSortedArrays_2(str1,11,str2,13);
	end_t=clock();
	total_t=(double)((double)end_t-(double)start_t)/CLOCKS_PER_SEC;
	printf("方法2:CPU佔用的總時間：%fns
",(total_t*1000000000));
	printf("中位數%f
",mid);

	start_t=clock();
	mid=findMedianSortedArrays_3(str1,11,str2,13);
	end_t=clock();
	total_t=(double)((double)end_t-(double)start_t)/CLOCKS_PER_SEC;
	printf("方法3:CPU佔用的總時間：%fns
",(total_t*1000000000));
	printf("中位數%f
",mid);

	start_t=clock();
	mid=findMedianSortedArrays_4(str1,11,str2,13);
	end_t=clock();
	total_t=(double)((double)end_t-(double)start_t)/CLOCKS_PER_SEC;
	printf("方法4:CPU佔用的總時間：%fns
",(total_t*1000000000));
	printf("中位數%f
",mid);

	start_t=clock();
	mid=findMedianSortedArrays_5(str1,11,str2,13);
	end_t=clock();
	total_t=(double)((double)end_t-(double)start_t)/CLOCKS_PER_SEC;
	printf("方法5:CPU佔用的總時間：%fns
",(total_t*1000000000));
	printf("中位數%f
",mid);

	return0;
}

思路一:

/*
方法1:採用歸並兩個非減數組形成新非減數組,然後求取新數組的中位數.
性能分析:歸並兩數組的時間復雜度O(n+m),查找中位數時間復雜度O(1).所以時間復雜度O((n+m)*1)=O(m+n)
*/
doublefindMedianSortedArrays_1(int*nums1,intnums1Size,int*nums2,intnums2Size){
	inti=0,j=0,k=0;
	intc[10000]={0};
	doublemid_f=(nums1Size+nums2Size);
	intsign=(!((int)mid_f&0x1));
	if((!nums1Size)&&(!nums2Size))return-1;
	/*mid_f=(mid_f/2);
	if(nums1Size==0){
		return((nums2[(int)mid_f]+nums2[(int)(mid_f-sign)])/2);
	}
	if(nums2Size==0){
		return((nums1[(int)mid_f]+nums1[(int)(mid_f-sign)])/2);
	}*/
	while((i<nums1Size)&&(j<nums2Size))
	{
		c[k++]=(nums1[i]<=nums2[j])?nums1[i++]:nums2[j++];
	}
	while(i<nums1Size)
	{
		c[k++]=nums1[i++];
	}
	while(j<nums2Size)
	{
		c[k++]=nums2[j++];
	}
	//mid_f=(k&0x1)?(c[(k/2)]):(((c[(k/2+sign)])+(c[(k/2)]))/2);
	mid_f=(((c[(k/2-sign)])+(c[(k/2)]))/2);
	
	printf("OKk=%d(nums1Size+nums2Size)=%di=%dj=%d
",k,(nums1Size+nums2Size),i,j);
	i=0;
	while(i<=k)
	{
		printf("c[%d]=%d
",i,c[i]);
		i++;
	}
	
	returnmid_f;
}

思路二:

/*
用統計方法,從小到大對兩數組同時進行歸並式的遍歷,並計數.當計數值等於兩數組的中位數的下標,就找到中位數.
性能分析:時間復雜度是歸並時間復雜度的一半,即O(m+n)=O((m+n)/2)
*/
doublefindMedianSortedArrays_5(int*nums1,intnums1Size,int*nums2,intnums2Size){
inti=0,j=0,k=0;
intmiddle=(nums1Size+nums2Size);
doublesign=(!(middle&0x1));
if((nums1Size==0)&&(nums2Size==0))return-1;
middle=(middle/2);
if(nums1Size==0){
return((nums2[(int)middle]+nums2[(int)(middle-sign)])/2);
}
if(nums2Size==0){
return((nums1[(int)middle]+nums1[(int)(middle-sign)])/2);
}
if(sign){
for(i=0,j=0,k=0;i<=(int)(middle-sign);i++)
{
(nums1[j]<=nums2[k])?(nums1[(j++)]):(nums2[k++]);
}
middle=(nums1[j]<=nums2[k])?(nums1[j--]):(nums2[k--]);//偶數中位數的前半部分最大值
middle=((middle+((nums1[j]<=nums2[k])?(nums1[j]):(nums2[k])))/2);//[偶數中位數的後半部分最小值+middle(偶數中位數的前半部分最大值)]/2=middle
}
else
{
for(i=0,j=0,k=0;i<=(middle-sign);i++)
{
(nums1[j]<=nums2[k])?(nums1[(j++)]):(nums2[k++]);
}
middle=(nums1[j]<=nums2[k])?(nums1[j]):(nums2[k]);
}
returnmiddle;
}

測試結果:(出現的特例:這著實具有不可避免性.輸入全體樣本中重復率高時,結束條件能被錯誤觸發.)

/*

OK k = 24 (nums1Size + nums2Size) = 24 i = 11 j = 13

c[0] = 0

c[1] = 2

c[2] = 4

c[3] = 5

c[4] = 5

c[5] = 6

c[6] = 7

c[7] = 9

c[8] = 9

c[9] = 10

c[10] = 15

c[11] = 15

c[12] = 17

c[13] = 18

c[14] = 20

c[15] = 21

c[16] = 23

c[17] = 23

c[18] = 24

c[19] = 25

c[20] = 26

c[21] = 27

c[22] = 29

c[23] = 50

c[24] = 0

方法1:CPU 佔用的總時間：4000000.000000 ns

中位數 16.000000

方法2:CPU 佔用的總時間：0.000000 ns

中位數 16.000000

nums1Size = 11 nums1[5] = 9 nums2Size = 13 nums2[6] = 20

nums1Size = 6 nums1[3] = 21 nums2Size = 7 nums2[3] = 15

nums1Size = 4 nums1[2] = 15 nums2Size = 4 nums2[2] = 18

nums1Size = 2 nums1[0] = 15 nums2Size = 3 nums2[1] = 17

nums1Size = 2 nums1[0] = 15 nums2Size = 2 nums2[0] = 15

方法3:CPU 佔用的總時間：15000000.000000 ns

中位數 15.000000

la = 9 ra = 9 lb = 20 rb = 20

la = 21 ra = 21 lb = 15 rb = 15

la = 10 ra = 15 lb = 17 rb = 18

la = 15 ra = 15 lb = 17 rb = 17

la = 15 ra = 21 lb = 15 rb = 17

方法4:CPU 佔用的總時間：10000000.000000 ns

中位數 16.000000

方法5:CPU 佔用的總時間：0.000000 ns

中位數 16.000000

*/

⑸ 數據的演算法都有哪些……

A*搜尋演算法
俗稱A星演算法。這是一種在圖形平面上，有多個節點的路徑，求出最低通過成本的演算法。常用於游戲中的 NPC的移動計算，或線上游戲的 BOT的移動計算上。該演算法像 Dijkstra演算法一樣，可以找到一條最短路徑；也像BFS一樣，進行啟發式的搜索。

Beam Search
束搜索(beam search)方法是解決優化問題的一種啟發式方法，它是在分枝定界方法基礎上發展起來的，它使用啟發式方法估計k個最好的路徑，僅從這k個路徑出發向下搜索，即每一層只有滿意的結點會被保留，其它的結點則被永久拋棄，從而比分枝定界法能大大節省運行時間。束搜索於20 世紀70年代中期首先被應用於 人工智慧領域,1976 年Lowerre在其稱為 HARPY的語音識別系統中第一次使用了束搜索方法。他的目標是並行地搜索幾個潛在的最優決策路徑以減少回溯，並快速地獲得一個解。

二分取中查找演算法
一種在有序數組中查找某一特定元素的搜索演算法。搜素過程從數組的中間元素開始，如果中間元素正好是要查找的元素，則搜素過程結束；如果某一特定元素大於或者小於中間元素，則在數組大於或小於中間元素的那一半中查找，而且跟開始一樣從中間元素開始比較。這種搜索演算法每一次比較都使搜索范圍縮小一半。

Branch and bound
分支定界演算法是一種在問題的解空間樹上搜索問題的解的方法。但與回溯演算法不同，分支定界演算法採用廣度優先或最小耗費優先的方法搜索解空間樹，並且，在分支定界演算法中，每一個活結點只有一次機會成為擴展結點。

數據壓縮
數據壓縮是通過減少計算機中所存儲數據或者通信傳播中數據的冗餘度，達到增大數據密度，最終使數據的存儲空間減少的技術。數據壓縮在文件存儲和分布式系統領域有著十分廣泛的應用。數據壓縮也代表著尺寸媒介容量的增大和網路帶寬的擴展。

Diffie–Hellman密鑰協商
Diffie–Hellman key exchange，簡稱「D–H」，是一種安全協議。它可以讓雙方在完全沒有對方任何預先信息的條件下通過不安全信道建立起一個密鑰。這個密鑰可以在後續的通訊中作為對稱密鑰來加密通訊內容。

Dijkstra』s 演算法
迪科斯徹演算法（Dijkstra）是由荷蘭計算機科學家艾茲格·迪科斯徹發明的。演算法解決的是有向圖中單個源點到其他頂點的最短路徑問題。舉例來說，如果圖中的頂點表示城市，而邊上的權重表示著城市間開車行經的距離，迪科斯徹演算法可以用來找到兩個城市之間的最短路徑。

動態規劃
動態規劃是一種在 數學和計算機科學中使用的，用於求解包含重疊子問題的最優化問題的方法。其基本思想是，將原問題分解為相似的子問題，在求解的過程中通過子問題的解求出原問題的解。 動態規劃的思想是多種演算法的基礎，被廣泛應用於計算機科學和工程領域。比較著名的應用實例有：求解最短路徑問題，背包問題，項目管理，網路流優化等。這里也有一篇文章說得比較詳細。

歐幾里得演算法
在 數學中，輾轉相除法，又稱 歐幾里得演算法，是求 最大公約數的演算法。輾轉相除法首次出現於 歐幾里得的《幾何原本》（第VII卷，命題i和ii）中，而在中國則可以追溯至 東漢出現的《九章算術》。

快速傅里葉變換(FFT)
快速傅里葉變換（Fast Fourier Transform，FFT），是離散傅里葉變換的快速演算法，也可用於計算離散傅里葉變換的逆變換。快速傅里葉變換有廣泛的應用，如數字信號處理、計算大整數乘法、求解偏微分方程等等。

哈希函數
HashFunction是一種從任何一種數據中創建小的數字「指紋」的方法。該 函數將數據打亂混合，重新創建一個叫做散列值的指紋。散列值通常用來代表一個短的隨機字母和數字組成的字元串。好的散列 函數在輸入域中很少出現散列沖突。在散列表和數據處理中，不抑制沖突來區別數據，會使得資料庫記錄更難找到。

堆排序
Heapsort是指利用堆積樹（堆）這種 數據結構所設計的一種排序演算法。堆積樹是一個近似完全二叉樹的結構，並同時滿足堆積屬性：即子結點的鍵值或索引總是小於（或者大於）它的父結點。

歸並排序
Merge sort是建立在歸並操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。

RANSAC 演算法
RANSAC 是」RANdom SAmpleConsensus」的縮寫。該演算法是用於從一組觀測數據中估計 數學模型參數的迭代方法，由Fischler and Bolles在1981提出，它是一種非確定性演算法，因為它只能以一定的概率得到合理的結果，隨著迭代次數的增加，這種概率是增加的。該演算法的基本假設是觀測數據集中存在」inliers」（那些對模型參數估計起到支持作用的點）和」outliers」（不符合模型的點），並且這組觀測數據受到雜訊影響。RANSAC 假設給定一組」inliers」數據就能夠得到最優的符合這組點的模型。

RSA加密演演算法
這是一個公鑰加密演算法，也是世界上第一個適合用來做簽名的演算法。今天的RSA已經 專利失效，其被廣泛地用於 電子商務加密，大家都相信，只要密鑰足夠長，這個演算法就會是安全的。

並查集Union-find
並查集是一種樹型的 數據結構，用於處理一些不相交集合（Disjoint Sets）的合並及查詢問題。常常在使用中以森林來表示。

Viterbi algorithm
尋找最可能的隱藏狀態序列
等等這些，演算法很多。

⑹ 利用C語言定義有序數組，實現二分查找演算法

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void xuanzhe(int a[], int n)
{
int i, j, min, t;

for (i=0; i<n-1; i++) /*要選擇的次數：0~n-2共n-1次*/
{
min = i; /*假設當前下標為i的數最小，比較後再調整*/
for (j=i+1; j<n; j++)/*循環找出最小的數的下標是哪個*/
{
if (a[j] < a[min])
{
min = j; /*如果後面的數比前面的小，則記下它的下標*/
}
}

if (min != i) /*如果min在循環中改變了，就需要交換數據*/
{
t = a[i];
a[i] = a[min];
a[min] = t;
}
}
}
int main(){
int i,n,x;
int mid,left=0,right=999;
int find1=0,find2=0;
double y;
int a[1000];
for(i=0;i<1000;++i){
a[i]=rand();
}
xuanzhe(a,1000);
scanf("%d",&x);
printf("順序查找:\n");
for(i=0;i<1000;++i){
while(x==a[i]){
printf("找到X=%d,a[%d]\n",x,i);
find1=1;
break;
}
}
if(find1==0){
printf("沒有你要找的數\n");
}

printf("%fs\n",clock()/CLOCKS_PER_SEC);
y=clock();
printf("二分查找:\n");
while(!find2&&left<right)
{
mid=(left+right)/2;
if(x==a[mid])
find2=1;
else if(x<a[mid])
right=mid-1;
else left=mid+1;
}
if(find2==1)
printf("找到x=%d ,a[%d]\n",x,mid);
else
printf("沒有你要找的數\n");
printf("%fs\n",(clock()-y)/CLOCKS_PER_SEC);
}

⑺ 編寫順序查找演算法的程序

查找演算法集：順序查找、二分查找、插值查找、動態查找(數組實現、鏈表實現)

// search.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "LinkTable.h"
#define MAX_KEY 500

//------------------------------數組實現部分----------------------------------
/**//*
無序數組順序查找演算法函數nsq_Order_Search<用數組實現>
參數描述：
int array[] :被查找數組
int n :被查找數組元素個數
int key :被查找的關鍵值
返回值:
如果沒有找到: nsq_Order_Search = -1
否則: nsq_Order_Search = key數組下標
*/
int nsq_Order_Search(int array[],int n,int key)
...{
int i;
array[n] = key;
/**//*for循環後面的分號必不可少*/
for(i=0;key!=array[i];i++);
return(i<n?i:-1);
}
/**//*
有序數組順序查找演算法函數sq_Order_Search<用數組實現>
參數描述：
int array[] :被查找數組
int n :被查找數組元素個數
int key :被查找的關鍵值
返回值:
如果沒有找到: sq_Order_Search = -1
否則: sq_Order_Search = key數組下標
*/
int sq_Order_Search(int array[],int n,int key)
...{
int i;
array[n] = MAX_KEY;
/**//*for循環後面的分號必不可少*/
for(i=0;key>array[i];i++);
if(i<n && array[i] == key)
return(i);
else
return(-1);
}
/**//*
有序數組二分查找演算法函數sq_Dichotomy_Search0<用數組實現>
參數描述：
int array[] :被查找數組
int n :被查找數組元素個數
int key :被查找的關鍵值
返回值:
如果沒有找到: sq_Dichotomy_Search0 = -1
否則: sq_Dichotomy_Search0 = key數組下標
*/
int sq_Dichotomy_Search0(int array[],int n,int key)
...{
int low,high,mid;
low = 0;
high = n - 1;

while(low<=high)
...{
mid = (high+low)/2;
if(array[mid] == key)
return(mid);
/**//*key>array[mid] 表明要求查找的值在[mid+1,high]*/
/**//*否則,在[low,mid-1]*/
if(key > array[mid])
low = mid + 1;
else
high = mid - 1;
}
return(-1);
}
/**//*
有序數組插值查找演算法函數sq_Dichotomy_Search1<用數組實現>
(插值查找演算法是二分查找演算法的改進)
參數描述：
int array[] :被查找數組
int n :被查找數組元素個數
int key :被查找的關鍵值
返回值:
如果沒有找到: sq_Dichotomy_Search1 = -1
否則: sq_Dichotomy_Search1 = key數組下標
*/
int sq_Dichotomy_Search1(int array[],int n,int key)
...{
int low,high, //二分數組的上,下標
pos; //查找碼的大致(估算)位置
low = 0;
high = n-1;
while(low <= high)
...{
pos = (key-array[low])/(array[high]-array[low])*(high-low)+low;
/**//*找到關鍵值,中途退出*/
if(key == array[pos])
return(pos);
if(key > array[pos])
low = pos + 1;
else
high = pos - 1;
}
/**//*沒有找到,返回-1*/
return(-1);
}
//------------------------------數組實現部分----------------------------------
//------------------------------鏈表實現部分----------------------------------
/**//*
無序鏈表順序查找演算法函數nlk_Order_Serach<用鏈表實現>
[查找思想:遍歷鏈表的所有節點]
參數描述：
Node *head :被查找鏈表的首指針
int key :被查找的關鍵值
返回值:
如果沒有找到: nlk_Order_Serach = NULL
否則: nlk_Order_Serach = 鍵值為key的節點的指針
*/
Node *nlk_Order_Serach(Node *head,int key)
...{
for(;head!=NULL && head->data != key;head = head->link);
return(head);
}
/**//*
有序鏈表順序查找演算法函數lk_Order_Serach<用鏈表實現>
[查找思想:依次遍歷鏈表的節點,發現節點不在key的范圍時提前結束查找]
參數描述：
Node *head :被查找鏈表的首指針
int key :被查找的關鍵值
返回值:
如果沒有找到: lk_Order_Serach = NULL
否則: lk_Order_Serach = 鍵值為key的節點的指針
*/
Node *lk_Order_Search(Node *head,int key)
...{
for(;head!=NULL && head->data < key;head=head->link);
/**//*當遍歷指針為NULL或沒有找到鍵值為key的節點,返回NULL(表明沒有找到)*/
/**//*否則,返回head(表明已經找到)*/
return(head==NULL || head->data != key ? NULL : head);
}
/**//*
有序鏈表動態查找演算法函數lk_Dynamic_Search<用鏈表實現>
[查找思想:依次遍歷鏈表的節點,發現節點不在key的范圍時提前結束查找]
參數描述：
Node *head: 被查找鏈表的首指針
Node **p; 鍵值為key的節點的前驅指針(回傳參數)
Node **q: 鍵值為key的節點指針(回傳參數)
int key : 被查找的關鍵值
注意:
當 *p == NULL 且 *q != NULL,鏈表的首節點鍵值為key
當 *p != NULL 且 *q != NULL,鏈表的中間(非首,尾)節點鍵值為key
當 *p != NULL 且 *q == NULL,鏈表的尾節點鍵值為key
當 *p == NULL 且 *q == NULL,鏈表是空鏈表
*/
void lk_Dynamic_Search(Node *head,Node **p,Node **q,int key)
...{
Node *pre,*cur;
pre = NULL;
cur = head;
for(;cur != NULL && cur->data < key;pre = cur,cur = cur->link)
*p = pre;
*q = cur;
}
/**//*
有序鏈表動態插入演算法函數lk_Dynamic_Insert<用鏈表實現>
參數描述：
Node *head: 被插入鏈表的首指針
int key : 被插入的關鍵值
返回值:
lk_Dynamic_Search = 插入鍵值為key的節點後的鏈表首指針
*/
Node *lk_Dynamic_Insert(Node *head,int key)
...{
Node
*x, //插入節點的前驅節點
*y, //插入節點的後續節點
*p; //插入的節點
p = (Node *)malloc(sizeof(Node));
p->data = key;
p->link = NULL;
lk_Dynamic_Search(head,&x,&y,key);
if(x==NULL)
...{
p->link = x;
head = p;
}
else
...{
p->link = x->link;
x->link = p;
}
ListLinkTable(head,"插入節點");
return(head);
}
/**//*
有序鏈表動態刪除演算法函數lk_Dynamic_Delete<用鏈表實現>
參數描述：
Node *head: 被刪除鏈表的首指針
int key : 被刪除的關鍵值
返回值:
lk_Dynamic_Delete = 刪除鍵值為key的節點後的鏈表首指針
*/
Node *lk_Dynamic_Delete(Node *head,int key)
...{
Node *x, //刪除節點的前驅節點
*y; //刪除的節點
lk_Dynamic_Search(head,&x,&y,key);
if(x==NULL)
/**//*因為x=NLLL時,y指向首指針*/
head = y->link;
else
x->link = y->link;
free(y);
ListLinkTable(head,"刪除節點");
return(head);
}
//------------------------------鏈表實現部分----------------------------------
int main(int argc, char* argv[])
...{
Node *head;
//Node *p,*x,*y;
int KEY;
int count,i;
//int result;
KEY = 11;
//PrintArrayValue(TestArray2,DEFAULT_ARRAY_SIZE,"原始");
//result = sq_Dichotomy_Search1(TestArray2,DEFAULT_ARRAY_SIZE,KEY);
//printf("查找結果是：數組[%d] = %d ",result,TestArray2[result]);
head = CreateLinkTable(DEFAULT_ARRAY_SIZE,TestArray2);
ListLinkTable(head,"原始");
/**//*
p = lk_Order_Search(head,KEY);
if(p==NULL)
printf(" 查找結果是：指定鏈表中沒有[數據域 = %d]的節點! ",KEY);
else
printf(" 查找結果是：節點.Data = %d 節點.Link = %d 節點.Addr = %d ",p->data,p->link,p);
*/
printf("輸入插入節點的個數： ");
scanf("%d",&count);
for(i=0;i<count;i++)
...{
printf("輸入插入節點的數據域： ");
scanf("%d",&KEY);
lk_Dynamic_Insert(head,KEY);
}
do
...{
printf("輸入刪除節點的數據域： ");
scanf("%d",&KEY);
lk_Dynamic_Delete(head,KEY);
}while(head!=NULL);
printf(" 應用程序正在運行...... ");
return 0;
}

⑻ 數據結構演算法查找，一個原本有序的數組，現隨機取出前面一段放到後面去，然後再找到其中最小的數，詳說

能用到的查找方法都是可以用的。順序、建樹、快速排序查找等等。
演算法是很多，但對於本題來說，對於兩段有序的表，從演算法的時間復雜度來看，
還是用二分法（改良後）較好。就是最差的情況下，也不會比順序查找長。

有二分法，找到一個中間的數值後，要進行兩次比較，分為要和第一個元素、最後一個元素比較，才能確定下一次要二分的區間。
直到步長為1為止。

⑼ 幾種常見的查找演算法之比較

二分法平均查找效率是O(logn)，但是需要數組是排序的。如果沒有排過序，就只好先用O（nlogn)的預處理為它排個序了。而且它的插入比較困難，經常需要移動整個數組，所以動態的情況下比較慢。

哈希查找理想的插入和查找效率是O(1)，但條件是需要找到一個良好的散列函數，使得分配較為平均。另外，哈希表需要較大的空間，至少要比O(n)大幾倍，否則產生沖突的概率很高。

二叉排序樹查找也是O(logn)的，關鍵是插入值時需要做一些處理使得它較為平衡（否則容易出現輕重的不平衡，查找效率最壞會降到O(n)），而且寫起來稍微麻煩一些，具體的演算法你可以隨便找一本介紹數據結構的書看看。當然，如果你用的是c語言，直接利用它的庫類型map、multimap就可以了,它是用紅黑樹實現的，理論上插入、查找時間都是O(logn)，很方便，不過一般會比自己實現的二叉平衡樹稍微慢一些。

⑽ 二分搜索演算法是利用什麼實現的演算法

二分搜索演算法是利用排除剩餘元素中一半的元素實現的演算法。

在計算機科學中，二分搜索（英語：binary search），也稱折半搜索（英語：half-interval search）、對數搜索（英語：logarithmic search），是一種在有序數組中查找某一特定元素的搜索演算法。

二分搜索演算法原理：

1、如果待查序列為空，那麼就返回－1，並退出演算法；這表示查找不到目標元素。如果待查序列不為空，則將它的中間元素與要查找的目標元素進行匹配，看它們是否相等。如果相等，則返回該中間元素的索引，並退出演算法；此時就查找成功了。如果不相等，就再比較這兩個元素的大小。

2、如果該中間元素大於目標元素，那麼就將當前序列的前半部分作為新的待查序列；這是因為後半部分的所有元素都大於目標元素，它們全都被排除了。

3、如果該中間元素小於目標元素，那麼就將當前序列的後半部分作為新的待查序列；這是因為前半部分的所有元素都小於目標元素，它們全都被排除了。