// 测试顺序查找
//
void test_sequential_search()
{
const int length = 11;
int array[length] = {65, 32, 49, 10, 18, 72, 27, 42, 18, 58, 91};
int key1 = 72;
int key2 = 55;
int pos;
print_array(array, length, " data: ");
pos = sequential_search(array, length, key1);
printf(" try searching %d, index is %d\n", key1, pos);
pos = sequential_search(array, length, key2);
printf(" try searching %d, index is %d\n", key2, pos);
}
int main()
{
/* 我的第一个 C 程序 */
printf("Hello, World! \n");
int a[] = {1, 2, 3};
int result = sequential_search(a, 3, 2);
printf("%d\n", result);
return 0;
}
int main()
{
int *a;
int i;
a = (int *) malloc(sizeof(int) * N_ELEMENTS);
a[0] = 0;
for (i = 1; i < N_ELEMENTS; i++) {
if (rand() % 2)
a[i] = a[i - 1];
else
a[i] = a[i - 1] + 3;
}
#if 0
for (i = 0; i < 10000; i++) {
int r1, r2, r3;
printf("s%d\n", i);
r1 = sequential_search(i, a, N_ELEMENTS);
printf("b%d\n", i);
r2 = binary_search(i, a, N_ELEMENTS);
printf("t%d\n", i);
r3 = ternary_search(i, a, N_ELEMENTS);
if (r1 != -1 && a[r1] != i) {
printf("error!");
exit(0);
}
if (r2 != -1 && a[r2] != i) {
printf("error!");
exit(0);
}
if (r3 != -1 && a[r3] != i) {
printf("error!");
exit(0);
}
}
#endif
START_TIME;
printf("%d\n", SEARCH(120000000, a, N_ELEMENTS));
printf("%d\n", SEARCH(1000, a, N_ELEMENTS));
printf("%d\n", SEARCH(0, a, N_ELEMENTS));
printf("%d\n", SEARCH(3, a, 1));
printf("%d\n", SEARCH(6, a, 2));
printf("%d\n", SEARCH(9, a, 4));
printf("%d\n", SEARCH(9, a, 20));
END_TIME;
return 0;
}
/*
* Test binary search on array a of size n
*/
static void test_binary_search(int32_t *a, uint32_t n) {
int32_t x, k, j, top;
print_array(a, n);
top = 5 * n + 12;
for (x=-12; x <top; x ++) {
k = binary_search(a, n, x);
j = sequential_search(a, n, x);
printf("index of %4"PRId32" = %"PRId32"\n", x, k);
if (j != k || (k>=0 && a[k] != x)) {
printf("*** BUG ***\n");
}
}
}
/*
* Speed test: sequential search
*/
static void speed_test_sequential_search(int32_t *a, uint32_t n) {
double start, done;
uint32_t i;
int32_t x, top;
top = 5 * n + 12;
printf("Sequential search: size = %"PRIu32" (10000*%"PRId32" searches)\n", n, top+12);
start = get_cpu_time();
for (i=0; i<10000; i++) {
for (x = -12; x<top; x++) {
(void) sequential_search(a, n, x);
}
}
done = get_cpu_time();
printf("Total time: %.4f\n", done - start);
}
int main(void)
{
out("starting ...\n");
std::cout << " SubString search " << std::endl;
char haystack[10000] = {0};
char needle[256] = {0};
scanf("%s\n",&haystack);
out("searching in %s \n", &haystack);
while(scanf("%s\n",&needle) != EOF)
{
int counter = 0;
int loc = sequential_search(haystack, needle, counter);
if(loc >=0 ) printf("found in location %d after %d probes\n", loc, counter);
else printf("NOT found after %d probes\n",counter);
}
return 0;
}
void search_index_data(SCHEMA *schema) {
int i, test_count, search_return, n_elements;
long int location, offset;
void *aux;
char *filename_index, *search_term, *filename_data, *print_field, *search_key;
NODE *node = schema->sentry;
FILE *fp_index, *fp_data;
// Sao lidos da stdin o campo a ser analisado na busca, a chave desejada e o campo a ser impresso apos a busca
search_term = my_get_line(stdin, &i);
search_key = my_get_line(stdin, &i);
print_field = my_get_line(stdin, &i);
// test_count armazena o numero de iteracoes de busca e offset armazena o offset do tipo sendo analisado em relação á posição do elemento
// como um todo
test_count = 0;
offset = 0;
// Sao analizados todos os elementos ate ser encontrado o que deseja-se para a busca
for(i = 0; i < schema->n_elements; i++) {
node = node->next;
if(strcmp(search_term, node->name) == 0 && node->order) {
// O arquivo .idx é aberto para leitura
filename_index = (char*)malloc(sizeof(char) * (strlen(schema->name) + 6 + strlen(node->name)));
strcpy(filename_index, schema->name);
strcat(filename_index, "-");
strcat(filename_index, node->name);
strcat(filename_index, ".idx");
fp_index = fopen(filename_index, "rb");
if(fp_index != NULL) {
// Analisa-se quantos elementos estão presentes no .idx
fseek(fp_index, 0, SEEK_END);
location = ftell(fp_index);
n_elements = (int)(location/(sizeof(long int) + node->size));
fseek(fp_index, 0, SEEK_SET);
// É realizada a busca binaria
search_return = binary_search(fp_index, schema, node, search_key, 0, n_elements-1, &test_count);
// E o arquivo é fechado
fclose(fp_index);
if(search_return == -1) {
// Caso não tenha sido encontrado o item desejado no indice, realiza-se a busca sequencial
// nos itens que foram adicionados no fim do .data
search_return = sequential_search(schema, node, search_key, &test_count, offset);
}
} else {
fprintf(stderr, "could not open file\n");
exit(1);
}
// Liberacao da memoria alocada
free(filename_index);
// Imprime o numero de iteracoes da busca realizadas
printf("%d\n", test_count);
// Caso nao tenha sido encontrado o item, imprime a mensagem de erro
if(search_return == -1) {
printf("value not found\n");
} else {
// Caso o item tenha sido encontrado, procura o offset do item a ser impresso em relação
// ao elemento como um todo
node = schema->sentry;
offset = 0;
for(i = 0; i < schema->n_elements; i++) {
node = node->next;
if(strcmp(print_field, node->name) == 0) {
break;
}
offset += node->size;
}
// O arquivo .data é aberto para leitura
filename_data = (char*)malloc(sizeof(char) * (strlen(schema->name)+6));
strcpy(filename_data, schema->name);
strcat(filename_data, ".data");
fp_data = fopen(filename_data, "rb");
if(fp_data == NULL) {
fprintf(stderr, "could not open file\n");
exit(1);
}
// A variavel aux armazena o conteudo do item a ser impresso
fseek(fp_data, search_return+offset, SEEK_SET);
aux = malloc(node->size);
fread(aux, node->size, 1, fp_data);
// E o arquivo é fechado
fclose(fp_data);
// A impressao é feita de acordo com o tipo sendo analisado
if(node->id == INT_T) {
printf("%d\n", *((int*)aux));
} else if(node->id == DOUBLE_T) {
printf("%.2lf\n", *((double*)aux));
} else if(node->id == STRING_T) {
printf("%s\n", (char*)aux);
}
// E a memoria alocada é liberada
free(aux);
free(filename_data);
}
// caso o item seja encontrado, o valor de i é alterado para que saia do loop
i = schema->n_elements+1;
}
// O valor de offset é incrementado com o tamanho do item anterior analisado
if(i <= schema->n_elements) {
offset += node->size;
}
}
// Caso não tenha sido realizada nenhuma iteracao de busca, não foi encontrado nenhum arquivo .idx do campo buscado
if(test_count == 0) {
printf("index not found\n");
}
// Libera a memoria alocada
free(search_term);
free(search_key);
free(print_field);
}
main()
{
int list[] = {54, 2, 40, 22, 17, 22, 60, 35};
printf("%d", sequential_search(list, 8, 22));
getchar();
}
