zoukankan      html  css  js  c++  java
  • 查找算法集:顺序查找、二分查找、插值查找、动态查找(数组实现、链表实现)

       //判断数组是否重复
                int[] n = { 1, 2, 3, 1, 0 };
                bool flag = true;   //假设不重复
                for (int i = 0; i < n.Length - 1; i++)
                { //循环开始元素
                    for (int j = i + 1; j < n.Length; j++)
                    { //循环后续所有元素
                        //如果相等,则重复
                        if (n[i] == n[j])
                        {
                            flag = false; //设置标志变量为重复
                            break;      //结束循环
                        }
                    }
                }
                //判断标志变量
                if (flag)
                {
                    Response.Write("不重复");
                }
                else
                {
                    Response.Write("重复");
                }

    // 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;
    }


  • 相关阅读:
    MDX Step by Step 读书笔记(六) Building Complex Sets (复杂集合的处理) Filtering Sets
    在 Visual Studio 2012 开发 SSIS,SSAS,SSRS BI 项目
    微软BI 之SSIS 系列 在 SSIS 中读取 SharePoint List
    MDX Step by Step 读书笔记(五) Working with Expressions (MDX 表达式) Infinite Recursion 和 SOLVE_ORDER 原理解析
    MDX Step by Step 读书笔记(五) Working with Expressions (MDX 表达式)
    使用 SQL Server 2012 Analysis Services Tabular Mode 表格建模 图文教程
    MDX Step by Step 读书笔记(四) Working with Sets (使用集合) Limiting Set and AutoExists
    SQL Server 2012 Analysis Services Tabular Model 读书笔记
    Microsoft SQL Server 2008 MDX Step by Step 学习笔记连载目录
    2011新的开始,介绍一下AgileEAS.NET平台在新的一年中的发展方向
  • 原文地址:https://www.cnblogs.com/aaa6818162/p/1540582.html
Copyright © 2011-2022 走看看