Este artículo hace referencia a la "Estructura de datos de Dahua", gracias al autor, el Sr. Cheng Jie.
Uno:
Búsqueda secuencial: También
llamada búsqueda lineal, es la tecnología de búsqueda más básica, su proceso de búsqueda es:
desde el primer (o último) registro de la tabla, uno por uno para registrar las palabras clave y la comparación de Valor dado.
Si la clave de un registro es igual al valor dado, la búsqueda es exitosa y se encuentra el registro buscado;
si la clave no se compara con el valor dado hasta el último (o primer) registro Cuando
son iguales, significa que no hay registro en la tabla y la consulta no es satisfactoria.
Dos:
Establecer habilidades de programación "Sentinel":
1. Sin búsqueda de secuencia centinela: la desventaja es que cada vez que tienes que comprobar si está fuera de los límites
para (i = 1; i <= n; i ++)
{ if (a [i] == key) return i; }
2. Búsqueda centinela: la ventaja es que no hay necesidad de comparar los valores de i y n cada vez:
while (a [i]! = Key) // key es centinela
{ i–; }
Tres: Búsqueda de tabla ordenada:
1. Búsqueda binaria:
también conocida como búsqueda binaria, su premisa es que los registros en la tabla lineal deben estar en orden (generalmente en orden de pequeño a grande), y la
tabla lineal debe estar en orden de almacenamiento .
La idea básica de la búsqueda binaria es:
en una lista ordenada, tome el registro del medio como el objeto de comparación, si el valor dado es igual a la clave del registro del medio, la búsqueda es exitosa;
si el valor dado es menor que la clave del registro del medio, está en el medio Continúe buscando en la mitad izquierda del registro;
si el valor dado es mayor que la clave del registro del medio, continúe buscando en la mitad derecha del registro del medio.
Repita el proceso anterior hasta que la búsqueda sea exitosa o hasta que no haya ningún registro en todas las áreas de búsqueda y la búsqueda falle.
2. Búsqueda de interpolación:
es un método de búsqueda basado en la comparación de la clave a buscar con la clave de los registros más grandes y más pequeños en la tabla de búsqueda.
El núcleo es la fórmula de cálculo de interpolación (clave -a [baja]) / (a [alto] -a [bajo])
3. Búsqueda de Fibonacci (Búsqueda de Fibonacci):
utilizando el principio de la sección áurea para lograr;
Cuatro: Búsqueda de índice lineal:
1. El índice es el proceso de asociar una palabra clave con su registro correspondiente.
Un índice se compone de varios índices. Cada elemento del índice debe contener al menos la palabra clave y su registro correspondiente en la memoria. Ubicación y otra información .
La tecnología de indexación es una tecnología importante para organizar grandes bases de datos y archivos de disco.
El índice se clasifica según la estructura:
* Índice lineal:
* Índice de árbol:
* Índice multinivel:
Tres índices lineales:
* Índice denso:
* Índice de bloque:
* Índice invertido:
Cinco: Implementación del código:
/*
本篇文章参考的是《大话数据结构》，感谢作者程杰先生。
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include "bigtalk_data_structure.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100 /* 存储空间初始分配量 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
int Fibo[MAXSIZE]; /* 斐波那契数列 */
/* 无哨兵顺序查找，a为数组，n为要查找的数组个数，key为要查找的关键字 */
int Sequential_Search(int *a,int n,int key)
{
int i;
for(i = 1; i <= n; i++)
{
if (a[i] == key)
{
return i;
}
}
return 0;
}
/* 有哨兵顺序查找 */
int Sequential_Search2(int *a,int n,int key)
{
int i;
a[0] = key;
i = n;
while(a[i] != key)
{
i--;
}
return i;
}
/* 折半查找 */
int Binary_Search(int *a,int n,int key)
{
int low,high,mid;
low = 1; /* 定义最低下标为记录首位 */
high = n; /* 定义最高下标为记录末位 */
while (low <= high)
{
mid=(low+high)/2; /* 折半 */
if (key<a[mid]) /* 若查找值比中值小 */
{
high=mid-1; /* 最高下标调整到中位下标小一位 */
}
else if (key>a[mid])/* 若查找值比中值大 */
{
low=mid+1; /* 最低下标调整到中位下标大一位 */
}
else
{
return mid; /* 若相等则说明mid即为查找到的位置 */
}
}
return 0;
}
/* 插值查找 */
int Interpolation_Search(int *a,int n,int key)
{
int low,high,mid;
low = 1; /* 定义最低下标为记录首位 */
high = n; /* 定义最高下标为记录末位 */
while (low <= high)
{
mid = low + (high-low)*(key-a[low])/(a[high]-a[low]); /* 插值 */
if (key<a[mid]) /* 若查找值比插值小 */
{
high=mid-1; /* 最高下标调整到插值下标小一位 */
}
else if (key>a[mid])/* 若查找值比插值大 */
{
low=mid+1; /* 最低下标调整到插值下标大一位 */
}
else
{
return mid; /* 若相等则说明mid即为查找到的位置 */
}
}
return 0;
}
/* 斐波那契查找 */
int Fibonacci_Search(int *a,int n,int key)
{
int low,high,mid,i,k=0;
low = 1; /* 定义最低下标为记录首位 */
high = n; /* 定义最高下标为记录末位 */
while(n > Fibo[k]-1)
{
k++;
}
for (i = n; i < Fibo[k]-1; i++)
{
a[i] = a[n];
}
while(low <= high)
{
mid = low + Fibo[k-1] - 1;
if (key < a[mid])
{
high = mid-1;
k = k-1;
}
else if (key > a[mid])
{
low = mid+1;
k = k-2;
}
else
{
if (mid <= n)
{
return mid; /* 若相等则说明mid即为查找到的位置 */
}
else
{
return n;
}
}
}
return 0;
}
//查找:静态查找
void test_main_8_1()
{
printf("[%s:%d]:[yang] ******************* 我是分割线******************* \n",__FUNCTION__,__LINE__);
int a[MAXSIZE+1],i,result;
int arr[MAXSIZE]={
0,1,16,24,35,47,59,62,73,88,99};
for(i = 0; i <= MAXSIZE; i++)
{
a[i] = i;
//printf("[%s:%d]:[yang] a[%d] = %d\n",__FUNCTION__,__LINE__,i, a[i]);
}
result = Sequential_Search(a, MAXSIZE, MAXSIZE);
printf("[%s:%d]:[yang] Sequential_Search: result = %d\n",__FUNCTION__,__LINE__,result);
result = Sequential_Search(a, MAXSIZE, 50);
printf("[%s:%d]:[yang] Sequential_Search: result = %d\n",__FUNCTION__,__LINE__,result);
result = Sequential_Search(a, MAXSIZE, 150);
printf("[%s:%d]:[yang] Sequential_Search: result = %d\n",__FUNCTION__,__LINE__,result);
printf("[%s:%d]:[yang] ******************* 我是分割线******************* \n",__FUNCTION__,__LINE__);
result = Sequential_Search2(a, MAXSIZE, 1);
printf("[%s:%d]:[yang] Sequential_Search2: result = %d\n",__FUNCTION__,__LINE__,result);
result = Sequential_Search2(a, MAXSIZE, 50);
printf("[%s:%d]:[yang] Sequential_Search2: result = %d\n",__FUNCTION__,__LINE__,result);
printf("[%s:%d]:[yang] ******************* 我是分割线******************* \n",__FUNCTION__,__LINE__);
result = Binary_Search(a, MAXSIZE, 50);
printf("[%s:%d]:[yang] Binary_Search: result = %d\n",__FUNCTION__,__LINE__,result);
result = Binary_Search(arr, 10, 62);
printf("[%s:%d]:[yang] Binary_Search: result = %d\n",__FUNCTION__,__LINE__,result);
printf("[%s:%d]:[yang] ******************* 我是分割线******************* \n",__FUNCTION__,__LINE__);
result = Interpolation_Search(arr, 10, 62);
printf("[%s:%d]:[yang] Interpolation_Search: result = %d\n",__FUNCTION__,__LINE__,result);
result = Interpolation_Search(arr, 10, 99);
printf("[%s:%d]:[yang] Interpolation_Search: result = %d\n",__FUNCTION__,__LINE__,result);
printf("[%s:%d]:[yang] ******************* 我是分割线******************* \n",__FUNCTION__,__LINE__);
Fibo[0] = 0;
Fibo[1] = 1;
for (i = 2; i < 100; i++)
{
Fibo[i] = Fibo[i-1] + Fibo[i-2];
}
result = Fibonacci_Search(arr,10,62);
printf("[%s:%d]:[yang] Fibonacci_Search: result = %d\n",__FUNCTION__,__LINE__,result);
result = Fibonacci_Search(arr,10,99);
printf("[%s:%d]:[yang] Fibonacci_Search: result = %d\n",__FUNCTION__,__LINE__,result);
#if 0
#endif
}
impresión:
[main:14]:[yang] *****************************************
[test_main_8_1:170]:[yang] ******************* 我是分割线*******************
[test_main_8_1:182]:[yang] Sequential_Search: result = 100
[test_main_8_1:185]:[yang] Sequential_Search: result = 50
[test_main_8_1:188]:[yang] Sequential_Search: result = 0
[test_main_8_1:191]:[yang] ******************* 我是分割线*******************
[test_main_8_1:195]:[yang] Sequential_Search2: result = 1
[test_main_8_1:198]:[yang] Sequential_Search2: result = 50
[test_main_8_1:201]:[yang] ******************* 我是分割线*******************
[test_main_8_1:204]:[yang] Binary_Search: result = 50
[test_main_8_1:207]:[yang] Binary_Search: result = 7
[test_main_8_1:209]:[yang] ******************* 我是分割线*******************
[test_main_8_1:213]:[yang] Interpolation_Search: result = 7
[test_main_8_1:216]:[yang] Interpolation_Search: result = 10
[test_main_8_1:219]:[yang] ******************* 我是分割线*******************
[test_main_8_1:231]:[yang] Fibonacci_Search: result = 7
[test_main_8_1:234]:[yang] Fibonacci_Search: result = 10