演算法學習之尋找演算法：靜態尋找表（1）順序表尋找，演算法靜態

演算法學習之尋找演算法：靜態尋找表（1）順序表尋找，演算法靜態

引言：

        對尋找表一般的操作有：1、查詢某個“特定的”資料元素是否在尋找表中；2、檢索某個“特定的”資料元素的各種屬性；3、在尋找表中插入一個資料元素；4、從尋找表中刪去某個資料元素。

         靜態尋找表的操作只包括兩種：1、尋找某個“特定的”資料元素是否在尋找表中；2、檢索某個“特定的”資料元素的各種屬性；

       靜態尋找表又有四種表現形式：順序表的尋找、有序表的尋找、靜態樹的尋找、索引順序表的尋找。

       靜態尋找涉及的關鍵字類型和資料元素類型統一說明：

/*典型關鍵字類型*/typedef float   KeyType;     //實型typedef int     KeyType;     //整型typedef char    *KeyType;   //字串型/*資料元素類型*/typedef struct{         KeyType   key;     //關鍵字域         .....                        //其他域}SElemType;/*對兩個關鍵字的比較約定如下*///-----對數值型關鍵字#define EQ(a, b)    ((a) == (b))#define LT(a, b)    ((a)  <   (b))#define LQ(a, b)    ((a)  >   (b))//-----對字元型關鍵字#define EQ(a, b)    (!strcmp((a), (b)))#define LT(a, b)    (strcmp((a), (b)) < 0)#define LQ(a, b)    (strcmp((a), (b)) <= 0)

順序表結構定義如下：

typedef struct{

             ElemType   *elem;   //資料元素儲存空間基址，建表時按實際長度分配，0號單元留空

             int                length; //表長度

}SSTable；

       順序尋找過程：從表中最後一個記錄開始，逐個進行記錄的關鍵字和給定值的比較，若某個記錄的關鍵字和給定值比較相等，則尋找成功，找到所查記錄；反之，若直至第一個記錄，其關鍵字和給定值比較都不相等，則表明表中沒有所查記錄，尋找不成功。

       假設順序表長度為10，即length=11，elem所指各個資料為：10  25   36  49  52  15  68  45  90  80 .圖示順序尋找如下：

  elem--->    [0]   [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    [10]   

                   '\0'   10   25    36     49    52   15     68    45    90    80    

elem的0號單元為空白，假設尋找元素在順序表中，比如尋找36，則首先將36放入elem的0號單元中，然後依次從80開始往前比較，直到遇到3號單元中的36，尋找成功。樣本如下：

  elem--->    [0]   [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    [10]   

                   36  10   25    36     49    52   15     68    45    90    80      //將36放入0號單元，作為哨兵

  elem--->    [0]   [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    [10]   

                   36   10   25    36     49    52   15     68    45    90    80    //將36與80比較，不等則繼續向前

  elem--->    [0]   [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    [10]   

                   36   10   25    36     49    52   15     68    45    90    80     //將36與90比較，不等則繼續向前

                   。。。。。。。。。

     

依次往前移動比較元素，當比較到3號單元時，相等，則比較結束

  elem--->    [0]   [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    [10]   

                   36   10   25    36    49    52   15     68    45    90    80 //將36與36比較，相等，比較結束，返回i

                      

如果比較的值不在順序表中，比如給定的值為5，首先將5放入0號單元，

  elem--->    [0]   [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    [10]   

                   5      10   25    36     49    52   15     68    45    90    80      //將5放入0號單元，作為哨兵

當比較到5時，返回i的值為0。表示尋找失敗。

以靜態尋找表的順序儲存結構實現：

範例程式碼（C語言描述）：

/*********************************************************************Author：李冰 date：2014-9-20Email：libing1209@126.com*********************************************************************/#define EQ(a, b) ((a) == (b))#defineElemTypeinttypedef struct{ElemType *elem;  //資料元素儲存空間基址，建表時按實際長度分配，0號單元留空int length;  //表長度}SSTable;//在順序表ST中順序尋找其關鍵字等於key的資料元素。若找到，則函數值為該元素在表中的位置,否則為0int Search_Seq(SSTable ST, ElemType key){int i;ST.elem[0] = key;      //“哨兵”for(i = ST.length; !EQ(ST.elem[i], key); --i);  //從後往前找return i;               //找不到時，i為0}

       效能分析：我們知道當討論一個程式的效能時一般從3個角度：時間複雜度、空間複雜度、和演算法的其他效能。由於在尋找過程中，通常只是需要一個固定大小的輔助空間來做比較，所以空間複雜度是一定的。而時間複雜度卻是可變的：其關鍵字和給定值進行過比較的記錄個數的平均值。

      適用範圍：順序尋找一般適用於尋找資料比較少的情況下。

      優點：

      1、演算法實現簡單且適應面廣

      2、對錶的結構無任何要求，無論記錄是否按關鍵字有序排列。

      3、即適用於順序表又適用於單鏈表。

     缺點：

     1、平均尋找長度較大，特別是當n很大時，尋找效率較低。

     2、速度慢，平均尋找長度為 (n + 1) / 2，時間複雜度為 O(n) 

靜態尋找演算法中 平均尋找演算法 怎用 C語言實現？？？ 急

靜態尋找演算法常見有以下兩種：

1. 順序尋找，平均尋找長度為：(n+1)/2

2. 有序表的尋找之折半尋找：前提必須是有序表，效能只有在均勻分布的時候才是最優的。

平均尋找長度：log2(n+1)-1
演算法實現：
1.順序尋找

從數組的第一個元素開始尋找，直到找到待尋找元素的位置，直到尋找到結果。

最佳的狀況時間是1 ，最差的尋找狀況是O（n）。

#include "stdio.h"
#define MAXITEM 100
typedef int KeyType;
typedef int ElemType;
typedef struct
{
KeyType key;
ElemType data;
}NodeType;
typedef NodeType SeqList[MAXITEM]; /*順序表類型*/

//演算法順序尋找
int SeqSearch(SeqList R,int n,KeyType k)
{
int i=0;
while (i<n && R[i].key!=k) /*從表頭往後找*/
i++;
if (i>=n)
return -1;
else
return i;
}

void main()
{
int i,n=10;
SeqList R;
KeyType a[]={2,3,1,8,5,4,9,0,7,6},x=9;
for (i=0;i<n;i++)
R[i].key=a[i];
printf("R[%d]=%d\n",SeqSearch(R,n,x),x);
}

2.二分法尋找

折半尋找是將待尋找的數組元素不斷的分為兩部分，每次淘汰二分之一，但是有個大前提是，元素必須是有序的，如果是無序的則要先進行排序操作。

最佳的狀況時間是1，最差的尋找狀態是O（n）

#include "stdio.h"
#define MAXITEM 100
typedef int KeyType;
typedef int ElemType;
typedef struct
{
KeyType key;
ElemType data;
}NodeType;
typedef NodeType SeqList[MAXITEM]; /*順序表類型*/

//演算法二分法尋找
int BinSearch(SeqList R,int n,KeyType k)
{
int low=0,high=n-1,mid;
while (low<=high)
{
mid=(low+high)/2;
if (R[mid].key==k) /*尋找成功返回*/
return mid;
if (R[mid].key>k) /*繼續在R[low..mid-1]中尋找*/
high=mid-1;
else
low=mid+1; /*繼續在R[mid+1..high]中尋找*/
}
return -1;
}

void main()
{
int i,n=10;
SeqList R;
KeyType a[]={2,13,15......餘下全文>>
 
用c語言編一個靜態尋找的 順序表尋找的演算法

#include<stdio.h>
/*++++++++++++++++++++++++
類型可以按具體實際情況而定
+++++++++++++++++++++++*/
int Lsearch(int *L,int n,int key)//if find return the location
//if not return -1;
{
int i;
for(i=n-1;i>=0;i--)if(key==L[i])return i;
return -1;
}
int Bsearch(int *L,int n,int key)//if find return the location
//if not return -1
{
int l=0,r=n-1,mid;
while(l<=r)
{
mid = (l+r)/2;
if(L[mid]==key)return mid;
else if(L[mid]<key)l=mid+1;
else r=mid-1;
}
return -1;
}
int main()
{
int a[6]={
1,2,3,4,5,6
};
printf("Lsearch:\n");
printf("find %d\n",Lsearch(a,6,4));
printf("not find %d\n",Lsearch(a,6,7));
printf("Bsearch:\n");
printf("find %d\n",Bsearch(a,6,4));
printf("not find %d\n",Bsearch(a,6,7));
}