靜態尋找表：順序尋找、折半尋找、分塊尋找，靜態折半

靜態尋找表：順序尋找、折半尋找、分塊尋找，靜態折半

引言：

       除去各種線性和非線性資料結構外，還有一種在實際應用中大量使用的資料結構——尋找表。尋找表是由同一類型的資料元素構成的集合。

       對尋找表經常進行的操作有：1、尋找某個"特定的"資料元素是否在尋找表中；2、檢索某個"特定的"資料元素的各種屬性；3、在尋找表中插入一個資料元素；4、從尋找表中刪去某個資料元素。對尋找表只作前兩種統稱為"尋找"的操作，則稱此類尋找表為靜態尋找表。若在尋找過程中同時插入尋找表中不存在的資料元素，或者從尋找表中刪除已存在的某個資料元素，則稱此類表為動態尋找表。

基礎知識：

關鍵字類型和資料元素類型統一說明如下：  典型的關鍵字類型說明可以是：  typedef float KeyType;      //實型  typedef int    KeyType;            //整型  typedef char KeyType;            //字串型  資料元素類型定義為：  typedef struct {           KeyType   key;               //關鍵字域           ........                               //其他域  }SElmType;  對兩個關鍵字的比較約定如下的宏定義：  //對數值型關鍵字  #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) 

具體分析：

1、順序尋找。

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

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

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

      優點：

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

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

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

     缺點：

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

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

typedef int ElementType;  #define EQ(a, b)  ((a) == (b))    int sequential(int Array[], ElementType key, int n)  {      int index;      for(index = 0; index < n; index++){          if(EQ(Array[index], key))                 return index + 1;      }      return -1;  }  

2、折半尋找。

       折半尋找：折半尋找又稱二分尋找，先確定待查記錄所在的範圍（區間），然後逐步縮小範圍直到找到或找不到該記錄為止。

       適用範圍：對於規模較大的有序表尋找，效率較高。適合很少改動但經常尋找的表。

        優點：

       1、折半尋找的效率比順序尋找要高。

       2、折半尋找的時間複雜度為log2(n)

       3、折半尋找的平均尋找長度為log2(n+1) - 1

       缺點：

       1、折半尋找只適用於有序表

       2、折半尋找限於順序儲存結構，對線性鏈表無法有效地進行折半尋找     

       

        關鍵字key與表中某一元素array[i]比較，有3中情況：

        1. key == array[i]， 尋找成功

        2.key > array[i], 待尋找元素可能的範圍是array[i]之前

        3.key < array[i], 待尋找元素可能的範圍是array[i]之後

typedef int ElementType;  #define EQ(a, b)  ((a) == (b))  #define LT(a, b)  ((a) < (b))  #define LQ(a, b)  ((a) <= (b))    int Search_Bin(ElementType Array[], int num, int length)  {      int index_low, index_mid, index_high;      index_low = 1;      index_high = length;      while(index_low <= index_high){          index_mid = (index_low + index_high) / 2;             if(EQ(num, Array[index_mid]))              return index_mid + 1;          else if (LT(num, Array[index_mid]))              index_high = index_mid - 1;          else              index_low = index_mid + 1;      }      return -1;  }  

3、 分塊尋找。

       分塊尋找：分塊尋找又稱索引順序尋找，它是順序尋找的一種改進方法。將n個資料元素“按塊有序”劃分為m塊（m<=n）。每一塊中的資料元素不必有序，但塊與塊之間必須“按塊有序”，即第1快中的任一元素的關鍵字都必須小於第2塊中任一元素的關鍵字；而第2塊中任一元素又都小於第3塊中的任一元素，……    

        操作步驟：

       1、先選取各快中的最大關鍵字構成一個索引表

       2、尋找分兩部分：先對索引表進行二分尋找或順序尋找，以確定待查記錄在哪一塊中；然後在已確定的快中用順序法進行尋找。

      優點：在表中插入或刪除一個記錄時，只要找到該記錄所在塊，就在該塊中進行插入或刪除運算（因快內無序，所以不需要大量移動記錄）。

      缺點：增加了一個輔助數組的儲存空間和將初始表分塊排序的運算。

      效能：介於順序尋找和二分尋找之間。

#define MAX 3  #define MAXSIZE 18      typedef int ElemType;  typedef struct IndexItem{      ElemType index;      int start;      int length;  }IndexItem;  IndexItem indexlist[MAX];    ElemType MainList[MAXSIZE] = {22, 12, 13, 8, 9, 20, 33, 42, 44, 38, 24, 48, 60, 58, 74, 49, 86, 53};    int sequential(IndexItem indexlist[], ElemType key)  {      int index;      if(indexlist[0].index >= key) return 1;      for(index = 1; index <= MAX; index++){          if((indexlist[index-1].index < key)&&(indexlist[index].index >= key))                   return index+1;      }      return 0;  }    int mainsequential(ElemType MainList[], int index, ElemType key)  {      int i, num=0;      for(i = 0; i < index-1; i++){          num += indexlist[i].length;       }      for(i = num; i < num+indexlist[index-1].length; i++){          if(MainList[i] == key) return i+1;        }      return -1;  }  

除上面介紹的3種尋找方法，還有針對有序表的斐波那契尋找和插值尋找以及靜態樹表的尋找。

要設計實現一個尋找演算法比較，可以對順序尋找、折半尋找、分塊尋找的平均尋找長度進行比較

給你一個我曾經做過的題，不是太一樣你可以參考，希望對你有所協助。
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int ARRSIZE= 10015;
// 從小到大排序數組元素
void asort(int *a, int s)
{
int i, j, k, t;
for (i = 0; i < s-1; ++i)
{
k = i;
for (j = i + 1; j < s; ++j)
{
if (a[k] > a[j])
{
k = j;
}
}

if (k != i)
{
t = a[i];
a[i] = a[k];
a[k] = t;
}
}
}

// 順序尋找，找到返回該元素數組下標，否則返回-1
int SeqSearch(int *a, int s, int k)
{
int i;
for (i = 0; i < s; ++i)
{
if (k == a[i])
return i;
}

return -1;
}

// 折半尋找，找到返回該元素數組下標，否則返回-1
int BinSearch(int *a, int s, int k)
{
int low = 0;
int high = s - 1;

while (low <= high)
{
int mid = (low + high) / 2;

if (k == a[mid])
{
return mid;
}
else
{
if (k < a[mid])
high = mid - 1;
else
low = mid + 1;
}
}

return -1;
}

// 分塊尋找，找到返回該元素數組下標，否則返回-1，bs表示數列分成的塊數
int BlkSearch(int *a, int s, int k, int bs)
{
int i, j, t = s / bs;

for (i = 0; i < bs; ++i)
{
if (k >= a[i*t] && k <= a[i*t+t-1])
{
int e = i*t+t;
for (j = i*t; j < e; ++j)
if (k == a[j])
return j;
}
}

--i;
for (i = i * bs; i < s; ++i)
{
if (k == a[i])
return i;
}
return -1;
}

void main()
{
int i, k, a[ARRSIZE];

srand(time(NULL));
for (i = 0; i < ARRSIZE; ++i)
a[i] = rand() % ARRSIZE;

asort(a, ARRSIZE);

/*
for (i = 0; i < ARRSIZE; ++i)
printf("%d ", a[i]);
*/
putchar('&#......餘下全文>>
 
C語言順序尋找程式

我說上面都在整的太麻煩了
#include<stdio.h>
#define N 10
int sequentialSearch(int a[], int len, int x)
{
for(int i = 0; i < len; i++)
if(x == a[i])
return i;
return -1;
}

void main()
{
int i;
int x,f, a[N]={22,23,5,43,67,24,67,34,12,10};
for(i = 0; i < N; i++)
printf("%d\t",a[i]);
printf("\n");
printf("Input a number\n");
scanf("%d",&x);
f = sequentialSearch(a,N,x);
if(f == -1)
printf("沒有找到\n");
else
printf("%d在數組的下標是%d\n",x,f);
}

22 23 5 43 67 24 67 34 12 10

Input a number
43
43在數組的下標是3
Press any key to continue