查找算法

转载 2007年09月26日 15:04:00
// search.cpp : Defines the entry point for the console application.
//

#include 
"stdafx.h"
#include 
"LinkTable.h"
#define        MAX_KEY  500

//------------------------------数组实现部分----------------------------------
/**//*
    无序数组顺序查找算法函数nsq_Order_Search<用数组实现>
    参数描述:
        int array[]    :被查找数组
        int n        :被查找数组元素个数
        int key        :被查找的关键值
    返回值:
        如果没有找到:    nsq_Order_Search = -1
        否则:            nsq_Order_Search = key数组下标
*/

int nsq_Order_Search(int array[],int n,int key)
...{
    
int i;
    array[n] 
= key;
    
/**//*for循环后面的分号必不可少*/
    
for(i=0;key!=array[i];i++);
    
return(i<n?i:-1);
}

/**//*
    有序数组顺序查找算法函数sq_Order_Search<用数组实现>
    参数描述:
        int array[]    :被查找数组
        int n        :被查找数组元素个数
        int key        :被查找的关键值
    返回值:
        如果没有找到:    sq_Order_Search = -1
        否则:            sq_Order_Search = key数组下标
*/

int sq_Order_Search(int array[],int n,int key)
...{
    
int i;
    array[n] 
= MAX_KEY;
    
/**//*for循环后面的分号必不可少*/
    
for(i=0;key>array[i];i++);
    
if(i<&& array[i] == key)
        
return(i);
    
else
        
return(-1);
}

/**//*
    有序数组二分查找算法函数sq_Dichotomy_Search0<用数组实现>
    参数描述:
        int array[]    :被查找数组
        int n        :被查找数组元素个数
        int key        :被查找的关键值
    返回值:
        如果没有找到:    sq_Dichotomy_Search0 = -1
        否则:            sq_Dichotomy_Search0 = key数组下标
*/

int sq_Dichotomy_Search0(int array[],int n,int key)
...{
    
int low,high,mid;
    low 
= 0;
    high 
= n - 1;
    
    
while(low<=high)
    
...{
        mid 
= (high+low)/2;
        
if(array[mid] == key)
            
return(mid);
        
/**//*key>array[mid] 表明要求查找的值在[mid+1,high]*/
        
/**//*否则,在[low,mid-1]*/
        
if(key > array[mid])
            low 
= mid + 1;
        
else
            high 
= mid - 1;
    }

    
return(-1);
}

/**//*
    有序数组插值查找算法函数sq_Dichotomy_Search1<用数组实现>
    (插值查找算法是二分查找算法的改进)
    参数描述:
        int array[]    :被查找数组
        int n        :被查找数组元素个数
        int key        :被查找的关键值
    返回值:
        如果没有找到:    sq_Dichotomy_Search1 = -1
        否则:            sq_Dichotomy_Search1 = key数组下标
*/

int sq_Dichotomy_Search1(int array[],int n,int key)
...{
    
int low,high,        //二分数组的上,下标
        pos;            //查找码的大致(估算)位置
    low = 0;
    high 
= n-1;
    
while(low <= high)
    
...{
        pos 
= (key-array[low])/(array[high]-array[low])*(high-low)+low;
        
/**//*找到关键值,中途退出*/
        
if(key == array[pos])
            
return(pos);
        
if(key > array[pos])
            low 
= pos + 1;
        
else
            high 
= pos - 1;
    }

    
/**//*没有找到,返回-1*/
    
return(-1);
}

//------------------------------数组实现部分----------------------------------
//------------------------------链表实现部分----------------------------------
/**//*
    无序链表顺序查找算法函数nlk_Order_Serach<用链表实现>
    [查找思想:遍历链表的所有节点]
    参数描述:
        Node *head    :被查找链表的首指针
        int key        :被查找的关键值
    返回值:
        如果没有找到:    nlk_Order_Serach = NULL
        否则:            nlk_Order_Serach = 键值为key的节点的指针
*/

Node 
*nlk_Order_Serach(Node *head,int key)
...{
    
for(;head!=NULL && head->data != key;head = head->link);
    
return(head);
}

/**//*
    有序链表顺序查找算法函数lk_Order_Serach<用链表实现>
    [查找思想:依次遍历链表的节点,发现节点不在key的范围时提前结束查找]
    参数描述:
        Node *head    :被查找链表的首指针
        int key        :被查找的关键值
    返回值:
        如果没有找到:    lk_Order_Serach = NULL
        否则:            lk_Order_Serach = 键值为key的节点的指针
*/

Node 
*lk_Order_Search(Node *head,int key)
...{
    
for(;head!=NULL && head->data < key;head=head->link);
    
/**//*当遍历指针为NULL或没有找到键值为key的节点,返回NULL(表明没有找到)*/
    
/**//*否则,返回head(表明已经找到)*/
    
return(head==NULL || head->data != key ? NULL : head);
}

/**//*
    有序链表动态查找算法函数lk_Dynamic_Search<用链表实现>
    [查找思想:依次遍历链表的节点,发现节点不在key的范围时提前结束查找]
    参数描述:
        Node *head:    被查找链表的首指针
        Node **p;    键值为key的节点的前驱指针(回传参数)
        Node **q:    键值为key的节点指针(回传参数)
        int key    :    被查找的关键值
    注意:
        当 *p == NULL 且 *q != NULL,链表的首节点键值为key    
        当 *p != NULL 且 *q != NULL,链表的中间(非首,尾)节点键值为key
        当 *p != NULL 且 *q == NULL,链表的尾节点键值为key
        当 *p == NULL 且 *q == NULL,链表是空链表
*/

void lk_Dynamic_Search(Node *head,Node **p,Node **q,int key)
...{
    Node 
*pre,*cur;
    pre 
= NULL;
    cur 
= head;
    
for(;cur != NULL && cur->data < key;pre = cur,cur = cur->link)
    
*= pre;
    
*= cur;
}

/**//*
    有序链表动态插入算法函数lk_Dynamic_Insert<用链表实现>
    参数描述:
        Node *head:    被插入链表的首指针
        int key    :    被插入的关键值
    返回值:
        lk_Dynamic_Search = 插入键值为key的节点后的链表首指针
*/

Node 
*lk_Dynamic_Insert(Node *head,int key)
...{
    Node 
        
*x,        //插入节点的前驱节点
        *y,        //插入节点的后续节点
        *p;        //插入的节点
    p = (Node *)malloc(sizeof(Node));
    p
->data = key;
    p
->link = NULL;
    lk_Dynamic_Search(head,
&x,&y,key);
    
if(x==NULL)
    
...{
        p
->link = x;
        head 
= p;
    }

    
else
    
...{
        p
->link = x->link;
        x
->link = p;    
    }

    ListLinkTable(head,
"插入节点");
    
return(head);
}

/**//*
    有序链表动态删除算法函数lk_Dynamic_Delete<用链表实现>
    参数描述:
        Node *head:    被删除链表的首指针
        int key    :    被删除的关键值
    返回值:
        lk_Dynamic_Delete = 删除键值为key的节点后的链表首指针
*/

Node 
*lk_Dynamic_Delete(Node *head,int key)
...{
    Node    
*x,        //删除节点的前驱节点
            *y;        //删除的节点
    lk_Dynamic_Search(head,&x,&y,key);
    
if(x==NULL)
        
/**//*因为x=NLLL时,y指向首指针*/
        head 
= y->link;
    
else
        x
->link = y->link;
    free(y);
    ListLinkTable(head,
"删除节点");
    
return(head);
}

//------------------------------链表实现部分----------------------------------
int main(int argc, char* argv[])
...{
    Node 
*head;
    
//Node *p,*x,*y;
    int KEY;
    
int count,i;
    
//int result;
    KEY = 11;
    
//PrintArrayValue(TestArray2,DEFAULT_ARRAY_SIZE,"原始");
    
//result = sq_Dichotomy_Search1(TestArray2,DEFAULT_ARRAY_SIZE,KEY);
    
//printf("查找结果是:数组[%d] = %d ",result,TestArray2[result]);
    head = CreateLinkTable(DEFAULT_ARRAY_SIZE,TestArray2);
    ListLinkTable(head,
"原始");
    
/**//*
    p = lk_Order_Search(head,KEY);
    if(p==NULL)
        printf(" 查找结果是:指定链表中没有[数据域 = %d]的节点! ",KEY);
    else
        printf(" 查找结果是:节点.Data = %d 节点.Link = %d 节点.Addr = %d ",p->data,p->link,p);
    
*/

    printf(
"输入插入节点的个数: ");
    scanf(
"%d",&count);
    
for(i=0;i<count;i++)
    
...{
        printf(
"输入插入节点的数据域: ");
        scanf(
"%d",&KEY);
        lk_Dynamic_Insert(head,KEY);
    }

    
do
    
...{
        printf(
"输入删除节点的数据域: ");
        scanf(
"%d",&KEY);
        lk_Dynamic_Delete(head,KEY);
    }
while(head!=NULL);
    printf(
" 应用程序正在运行...... ");
    
return 0;
}
 

杨氏矩阵查找算法

一、杨氏矩阵说白了,杨氏矩阵就是一个二维数组,不过这个二维数组有点特别:数组的每行从左到右是递增的,每列从上到下是递增的。比如说: 1 2 3 4 5 6 7 8 9二、查找算法知道了杨氏矩阵,...
  • jhcconan614
  • jhcconan614
  • 2016年11月24日 20:31
  • 189

面试常见算法-排序查找算法

算法是程序员必被的一个技能,在面试中常常出现,下面总结了面试中出现的常见算法,这些算法程序员应该牢记在心中,要非常熟练。...
  • DERRANTCM
  • DERRANTCM
  • 2015年06月22日 07:37
  • 3575

常见查找算法总结

静态查找结构主要有两种:顺序查找、折半查找 一、顺序查找:这个就不用说了,一个一个的差吧,很差劲的算法了,时间复杂度是O(n)      public int shunXuSear...
  • zengtian006
  • zengtian006
  • 2014年04月18日 17:22
  • 5032

7种查找算法解析

查找成功时的平均查找长度为:(假设每个数据元素的概率相等) ASL = 1/n(1+2+3+…+n) = (n+1)/2 ; 当查找不成功时,需要n+1次比较,时间复杂度为O(n); 所以, 顺...
  • chinabhlt
  • chinabhlt
  • 2015年08月11日 15:03
  • 30360

三、线性查找算法,BFPRT 算法 《转》

|举报|字号 订阅 http://ds.fzu.edu.cn/fine/resources/FlashContent.asp?id=82 这个是一个很好的视频教...
  • ckpckp
  • ckpckp
  • 2014年03月26日 20:30
  • 1703

常见查找算法(Java实现)

查找的性能分析: 对于查找算法而言,常用“其关键字和给定值进行过比较的记录个数的平均值”作为衡量查找算法的依据。 定义:为了确定记录在查找表中的位置,需要和给定的值进行比较的关键字个数的期望值称为...
  • wqc_CSDN
  • wqc_CSDN
  • 2016年09月29日 17:33
  • 4048

查找算法(一)顺序查找

顺序查找比较适合顺序文件,后者是指文件中所包含的记录在物理结构和逻辑结构中的排列顺序是一致的。 顺序查找算法描述,若顺序文件中有n条连续纪录,可以将这些纪录读到内存的一个顺序中进行操作。顺序查找就是...
  • hushiwei1993
  • hushiwei1993
  • 2016年06月08日 17:36
  • 420

各种查找算法效率比较

给定一个已经排好序的N个整数的序列(数据从1到N),在该序列中查找指定的整数,并观察不同算法的运行时间。考查3类查找算法:折半查找,平衡二叉排序树的查找,B-树的查找。 要求: (1)构造树表的算...
  • u014427196
  • u014427196
  • 2015年03月24日 21:24
  • 1757

[Java]各种基础的查找和排序算法总结

查找方法: 1.顺序查找。 按数组的顺序从前往后一直比较,直到找到目标值返回。 优点:对数组的结构没有特定的要求,算法简单。 缺点:当数组个数n较大时,效率低下。 时间复杂度:最大时间复杂度是O(n)...
  • qq284565035
  • qq284565035
  • 2014年12月02日 16:30
  • 1839

排序算法和查找算法

查找操作是数据处理中使用最频繁的一项操作。在本章中,会介绍两种查找算法:顺序查找和折半查找,并带大家实现这两种算法。除了介绍算法本身,还会介绍比较算法性能的一个重要指标:平均查找长度。并教大家分析不同...
  • Stand1210
  • Stand1210
  • 2016年08月30日 20:21
  • 633
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:查找算法
举报原因:
原因补充:

(最多只允许输入30个字)