查找算法的实现

 

/**chazhao.h****/
typedef int key;
typedef char data;

typedef struct
{
    key _key;
    data _data;
} element;

typedef struct node
{
    key _key;
    char _data [ 1000 ];
    node * next;
} * list , * pNode;

int array_shunxu( element * a , key k , int n);        //数组的顺序查找
int list_shunxu( list a , key k , int n);            //链表的顺序查找
int zheban1( element * a , key k , int n);            //数组的折半查找(非递归)
int zheban2( element * a , key k , int low , int high);    //数组的折半查找（递归）               
void listAdd( list a , key _key);                    //增加链表元素
void listCreate( list * a);                        //创建链表
void listPrint( list a);                            //打印链表
void shellSort( element * a , int n);                //进行希尔排序


/***chazhao_fun.h****/
#include "chazhao.h"
#include <stdlib.h>
#include <stdio.h>

void shellSort( element * a , int n)                //进行希尔排序
{
    int i , j , Increment;
    element temp;
    for( Increment = n / 2; Increment > 0; Increment /= 2)
        for( i = Increment; i < n; i ++)
        {
            temp = a [ i ];
            for( j = i; j >= Increment; j -= Increment)
                if( temp . _key < a [ j - Increment ]. _key)
                    a [ j ] = a [ j - Increment ];
                else
                    break;
            a [ j ] = temp;
        }
}

void listCreate( list * a)                        //创建链表
{
    ( * a) = ( list) malloc( sizeof( node));
    ( * a) -> next = NULL;
}

void listPrint( list a)                            //打印链表元素
{
    while( a = a -> next)
    {
        printf( "%d " , a -> _key);
    }
}

void listAdd( list a , key _key)                    //往链表插入元素
{
    pNode p = ( pNode) malloc( sizeof( node));
    while( a -> next)
    {
        a = a -> next;
    }
    p -> _key = _key;
    p -> next = a -> next;
    a -> next = p;
}

int list_shunxu( list a , key k , int n)                //链表的顺序查找
{
    int i;
    list b = ( list) malloc( sizeof( node));
    b = a -> next;
    for( i = 0; i < n; i ++)
    {
        if(b -> _key == k)
            return i;
        b = b -> next;
    }
    return - 1;
}

int array_shunxu( element * a , key k , int n)        //数组实现的顺序查找
{
    int i;
    for( i = 0; i < n; i ++)
    {
        if( a [ i ]. _key == k)
            return i;
    }
    return - 1;
}

int zheban1( element * a , key k , int n)                //数组的折半查找(非递归)
{
    int Low , Mid , High;
    Low = 0;
    High = n - 1;
    while( Low <= High)
    {
        Mid = ( Low + High) / 2;
        if( a [ Mid ]. _key < k)
            Low = Mid + 1;
        else
        if( a [ Mid ]. _key > k)
            High = Mid - 1;
        else
            return Mid;
    }
    return - 1;
}

int zheban2( element * a , key k , int low , int high)    //数组的折半查找（递归）
{
    int Low , Mid , High;
    Low = low;
    High = high;
    Mid = ( Low + High) / 2;
    if( Low > High)
    {
        return - 1;
    }
    else if( a [ Mid ]. _key < k)
    {
        Low = Mid + 1;
        zheban2( a , k , Low , High);
    }
    else if( a [ Mid ]. _key > k)
    {
        High = Mid - 1;
        zheban2( a , k , Low , High);
    }
    else
        return Mid;
}