精华内容
下载资源
问答
  • 实现顺序查找的算法

    千次阅读 2019-01-29 16:23:42
    * 实现顺序查找的算法 * 实验目的: * 领会顺序查找的过程和算法设计 * 实验内容: * 设计程序,输出在顺序表(3, 6, 2, 10, 1, 8, 5, 7, 4, 9)中采用 * 顺序查找方法查找关键字5的过程 * */ #include <stdio.h...

    /**
    *    实验题目:
    *        实现顺序查找的算法
    *    实验目的:
    *        领会顺序查找的过程和算法设计
    *    实验内容:
    *        设计程序,输出在顺序表(3, 6, 2, 10, 1, 8, 5, 7, 4, 9)中采用
    *    顺序查找方法查找关键字5的过程
    *
    */

    #include <stdio.h>

    #define MAX_LEN (100)

    typedef int key_type;                // 定义关键字类型为int
    typedef char info_type;

    typedef struct
    {
        key_type key;                    // 关键字项
        info_type data;                  // 其他数据项,类型为InfoType
    }rec_type;                           // 声明查找顺序表元素类型


    /*-------------------创建顺序表---------------------*/
    void create_list(rec_type records[], key_type keys[], int n)
    {
        int i;

        for(i = 0; i < n; i++)                  // records[0...n - 1]存放排序记录
            records[i].key = keys[i];
    }

    /*-------------------输出顺序表---------------------*/
    void disp_list(rec_type records[], int n)
    {
        int i;

        for(i = 0; i < n; i++)
            printf("%d ", records[i].key);
        printf("\n");
    }

    /**
    *   采用顺序查找方法在顺序表keys(含有n各个元素)中查找
    *   关键字为key的记录位置
    */
    static int seq_search(rec_type keys[], int n, key_type key)
    {
        int i = 0;

        while(i < n && keys[i].key != key)
        {
            printf("%d ", keys[i].key);
            i++;                                // 从表头往后查找
        }
        if(i >= n)
            return 0;
        else
        {
            printf("%d", keys[i].key);
            return (i + 1);
        }
    }

    int main(void)
    {
        rec_type records[MAX_LEN];
        int i;
        int n = 10;
        key_type key = 5;
        int a[] = {3, 6, 2, 10, 1, 8, 5, 7, 4, 9};

        create_list(records, a, n);                 // 建立顺序表
        printf("关键字序列:");
        disp_list(records, n);
        printf("查找%d所比较的关键字:\n\t", key);
        i = seq_search(records, n, key);
        if(i != 0)
            printf("\n元素%d的位置是%d\n", key, i);
        else
            printf("\n元素%d不在表中\n", key);

        return 0;
    }

    测试结果:

    关键字序列:3 6 2 10 1 8 5 7 4 9
    查找5所比较的关键字:
            3 6 2 10 1 8 5
    元素5的位置是7

    展开全文
  • 1、编写一个程序exp9-1.cpp,输出在顺序表(3,6,2,10,1,8,5,7,4,9)中采用顺序查找方法查找关键字5过程。 2、编写一个程序exp9-2.cpp,输出在顺序表(1,2,3,4,5,6,7,8,9,10)中采用折半查找方法查找关键字9过程...

    实验内容

    1、编写一个程序exp9-1.cpp,输出在顺序表(3,6,2,10,1,8,5,7,4,9)中采用顺序查找方法查找关键字5的过程。
    2、编写一个程序exp9-2.cpp,输出在顺序表(1,2,3,4,5,6,7,8,9,10)中采用折半查找方法查找关键字9的过程。
    3、编写一个程序bst.cpp,包含二叉顺序树的创建、查找和删除算法,在此基础上编写exp9-4.cpp程序完成以下功能。
    (1)由关键字序列(4,9,0,1,8,6,3,5,2,7)创建一棵二叉排bt并以括号表示法输出。
    (2)判断bt是否为一棵二叉排序。
    (3)采用递归和非递归两种方法查找关键字为6的结点,并输出其查找路径。
    (4)分别删除bt中关键字为4和5的结点,并输出删除后的二叉排序。

    代码实现

    1、

    #include <stdio.h>
    #define MAXL 100     //定义表中最多记录个数
    Typedef int KeyType;
    typedef char InfoType[10];
    typedef struct 
    { 
     		KeyType key;                  //KeyType为关键字的数据类型
       	 	InfoType data;                //其他数据
    }NodeType;
    typedef NodeType SeqList[MAXL];    //顺序表类型
    int SeqSearch(SeqList R,int n,KeyType k) //顺序查找算法
    {
        	int i=0;
        	while (i<n && R[i].key!=k) 
     		{
      			printf("%d ",R[i].key);
      			i++;     //从表头往后找
     		}
        	if (i>=n) 
      			return -1;
        	else 
     		{
      			printf("%d",R[i].key);
      			return i;
     		}
    }
    int main()
    {
     		SeqList R;
     		int n=10,i;
     		KeyType k=5;
     		int a[]={3,6,2,10,1,8,5,7,4,9};
     		for (i=0;i<n;i++)    //建立顺序表
      			R[i].key=a[i];
     			printf("关键字序列:");
     		for (i=0;i<n;i++)
      			printf("%d ",R[i].key);
     		printf("\n");
     		printf("查找%d所比较的关键字:",k);
     		if ((i=SeqSearch(R,n,k))!=-1)
      			printf("\n元素%d的位置是:%d\n",k,i);
     		else
      			printf("\n元素%d不在表中\n",k);
     		printf("\n");
    		return 0;
    } 
    

    结果截图:
    在这里插入图片描述
    2、

    #include <stdio.h>
    #define MAXL 100     //定义表中最多记录个数
    typedef int KeyType;
    typedef char InfoType[10];
    typedef struct 
    { 
     	KeyType key;                 //KeyType为关键字的数据类型
        InfoType data;               //其他数据
    }NodeType;
    typedef NodeType SeqList[MAXL];    //顺序表类型
    int BinSearch(SeqList R,int n,KeyType k) //二分查找算法
    {
     	int low=0,high=n-1,mid,count=0;
     	while (low<=high) 
     	{ 
      		mid=(low+high)/2;
      		printf("  第%d次比较:在[%d,%d]中比较元素R[%d]:%d\n",++count,low,high,mid,R[mid].key);
       		if (R[mid].key==k)    //查找成功返回
       			return mid;
      		if (R[mid].key>k)      //继续在R[low..mid-1]中查找
       			high=mid-1;
      		else
       			low=mid+1;        //继续在R[mid+1..high]中查找
     	}
     	return -1;
    }
    
    int main()
    {
     	SeqList R;
     	KeyType k=9;
     	int a[]={1,2,3,4,5,6,7,8,9,10},i,n=10;
     	for (i=0;i<n;i++)    //建立顺序表
      		R[i].key=a[i];
     		printf("关键字序列:");
     	for (i=0;i<n;i++)
      		printf("%d ",R[i].key);
     		printf("\n");
     		printf("查找%d的比较过程如下:\n",k);
     	if ((i=BinSearch(R,n,k))!=-1)
      		printf("元素%d的位置是:%d\n",k,i);
     	else
      		printf("元素%d不在表中\n",k);
    	return 0;
    }
    

    结果截图:
    在这里插入图片描述
    3、

    #include <stdio.h>
    #include <malloc.h>
    #define MaxSize 100
    typedef int KeyType;     //定义关键字类型
    typedef char InfoType;
    typedef struct node                 //记录类型
    { 
     	KeyType key;                    //关键字项
        InfoType data;                 //其他数据域
        struct node *lchild,*rchild;  //左右孩子指针
    }BSTNode;
    int path[MaxSize];      //全局变量,用于存放路径
    void DispBST(BSTNode *b);    //函数说明
    int InsertBST(BSTNode *&p,KeyType k) //在以*p为根节点的BST中插入一个关键字为k的节点
    {
        if (p==NULL)      //原树为空, 新插入的记录为根节点
     	{
      		p=(BSTNode *)malloc(sizeof(BSTNode));
      		p->key=k;p->lchild=p->rchild=NULL;
      		return 1;
     	}
     	else if (k==p->key) 
      		return 0;
     	else if (k<p->key) 
      		return InsertBST(p->lchild,k); //插入到*p的左子树中
     	else  
      		return InsertBST(p->rchild,k);  //插入到*p的右子树中
    }
    BSTNode *CreatBST(KeyType A[],int n)    
    //由数组A中的关键字建立一棵二叉排序树
    {
       	BSTNode *bt=NULL;            //初始时bt为空树
        int i=0;
        while (i<n) 
        { 
      		if (InsertBST(bt,A[i])==1)  //将A[i]插入二叉排序树T中
      		{
       			printf("    第%d步,插入%d:",i+1,A[i]);
       			DispBST(bt);printf("\n");
       			i++;
      		}
      	} 
        return bt;                  //返回建立的二叉排序树的根指针
    }
    void Delete1(BSTNode *p,BSTNode *&r)
    //当被删*p节点有左右子树时的删除过程
    {
     	BSTNode *q;
     	if (r->rchild!=NULL)
      		Delete1(p,r->rchild); //递归找最右下节点
     	else      //找到了最右下节点*r
     	{
      		p->key=r->key;   //将*r的关键字值赋给*p
      		q=r;     
      		r=r->lchild;   //将*r的双亲节点的右孩子节点改为*r的左孩子节点
      		free(q);    //释放原*r的空间
     	}
    }
    void Delete(BSTNode *&p)
    //从二叉排序树中删除*p节点
    {
     	BSTNode *q;
     	if (p->rchild==NULL)  //*p节点没有右子树的情况
     	{
      		q=p;p=p->lchild;free(q);
     	}
     	else if (p->lchild==NULL) //*p节点没有左子树的情况
     	{
      		q=p;p=p->rchild;free(q);
     	}
     	else 
    	 	Delete1(p,p->lchild); //*p节点既有左子树又有右子树的情况
    }
    int DeleteBST(BSTNode *&bt,KeyType k) 
    //在bt中删除关键字为k的节点
    {
     	if (bt==NULL) return 0;  //空树删除失败
     	else 
     	{
      		if (k<bt->key) 
       			return DeleteBST(bt->lchild,k);  //递归在左子树中删除关键字为k的节点
      		else if (k>bt->key) 
       			return DeleteBST(bt->rchild,k);  //递归在右子树中删除关键字为k的节点
      		else         //k=bt->key的情况
      		{
       			Delete(bt);  //调用Delete(bt)函数删除*bt节点
       			return 1;
      		}
     	}
    }
    void SearchBST1(BSTNode *bt,KeyType k,KeyType path[],int i) 
    //以非递归方式输出从根节点到查找到的节点的路径
    { 
     	int j;
     	if (bt==NULL)
      		return;
     	else if (k==bt->key) //找到了节点
     	{
      		path[i+1]=bt->key; //输出其路径
      		for (j=0;j<=i+1;j++)
       		printf("%3d",path[j]);
      		printf("\n");
     	}
     	else
     	{
      		path[i+1]=bt->key;
      		if (k<bt->key)
       			SearchBST1(bt->lchild,k,path,i+1);  //在左子树中递归查找
      		else
       			SearchBST1(bt->rchild,k,path,i+1);  //在右子树中递归查找
     	}
    }
    int SearchBST2(BSTNode *bt,KeyType k) 
    //以递归方式输出从根节点到查找到的节点的路径
    { 
     	if (bt==NULL)
      		return 0;
     	else if (k==bt->key)
     	{
      		printf("%3d",bt->key);
      		return 1;
     	}
     	else if (k<bt->key)
      		SearchBST2(bt->lchild,k);  //在左子树中递归查找
     	else
      		SearchBST2(bt->rchild,k);  //在右子树中递归查找
     		printf("%3d",bt->key);
    }
    
    void DispBST(BSTNode *bt) 
    //以括号表示法输出二叉排序树bt
    {
     	if (bt!=NULL)
     	{
      		printf("%d",bt->key);
      		if (bt->lchild!=NULL || bt->rchild!=NULL)
      		{
       			printf("(");
       			DispBST(bt->lchild);
       			if (bt->rchild!=NULL) 
    	   			printf(",");
       				DispBST(bt->rchild);
       				printf(")");
      		}
     	}
    }
    KeyType predt=-32767; //predt为全局变量,保存当前节点中序前趋的值,初值为-∞
    int JudgeBST(BSTNode *bt) //判断bt是否为BST
    {
     	int b1,b2;
     	if (bt==NULL)
      		return 1;
     	else 
     	{
      		b1=JudgeBST(bt->lchild);
      		if (b1==0 || predt>=bt->key)
       			return 0;
      			predt=bt->key;
      			b2=JudgeBST(bt->rchild);
      			return b2;
     	}
    }
    int main()
    {
     	BSTNode *bt;
     	KeyType k=6;
     	int a[]={4,9,0,1,8,6,3,5,2,7},n=10;
     	printf("(1)创建一棵BST树:");
     	printf("\n");
     	bt=CreatBST(a,n);
     	printf("    括号表示BST:");DispBST(bt);printf("\n");
     	printf("(2)判断:bt%s\n",(JudgeBST(bt)?"是一棵BST":"不是一棵BST"));
     	printf("(3)a.查找%d关键字(递归,顺序):",k);SearchBST1(bt,k,path,-1);
    	printf("   b.查找%d关键字(非递归,逆序):",k);SearchBST2(bt,k);
     	printf("\n(4)删除并输出操作:\n");
     	printf("   原BST:");DispBST(bt);printf("\n");
     	printf("   删除节点4:");
     	DeleteBST(bt,4);
     	DispBST(bt);printf("\n");
     	printf("   删除节点5:");
     	DeleteBST(bt,5);
     	DispBST(bt);
     	printf("\n");
     	return 0; 
    }
    

    结果截图:
    在这里插入图片描述

    展开全文
  • 主要介绍了基于JavaScript实现的顺序查找算法,结合实例形式分析了javascript顺序查找的原理、实现技巧与相关注意事项,需要的朋友可以参考下
  • 本文主要实现查找算法二分查找算法顺序查找,插入查找算法以及fibonacci查找算法,个人认为以上查找算法本质不同其实就是缩小区间方式不一样罢了。二分查找算法采用二分缩小区间方法;顺序查找算法每次...

    本文主要实现查找算法中的二分查找算法,顺序查找,插入查找算法以及fibonacci查找算法,个人认为以上查找算法本质的不同其实就是缩小的区间方式不一样罢了。二分查找算法采用二分缩小区间的方法;顺序查找算法每次缩小一个单位区间;而插入查找算法则通过数据的分布特征来重新计算区间:

    ,就是二分查找的升级版本;最后的fibonacci查找算法的缩小区间的方法则是通过fibonacci数列来确定。同样是本文只给出代码和少量的注释的理论理解,具体理论请参考reference。

    1.二分查找算法

    二分查找算法真的算是最有用的算法了,各种刷题中二分算法的思想简直无所不能啊,如旋转数组的最小值,求数组的前k个数等,都是采用二分查找缩小区间的方法。以下给出递归和非递归的二分算法的三种不同方式的代码。

    def bin_serach(lst, value, low , high):

    #递归出口

    if low > high:

    return -1

    mid = low + ((high - low)>>1) #避免大数溢出

    if lst[mid] > value:

    return bin_serach(lst, value, low , mid-1)

    elif lst[mid] < value:

    return bin_serach(lst, value, mid+1, high)

    else:

    return mid

    def binary_search(lis, left, right, num):

    if left > right: #递归结束条件

    return -1

    mid = low + ((high - low)>>1)

    if num < lis[mid]:

    right = mid -1

    elif num > lis[mid]:

    left = mid + 1

    else:

    return mid

    return binary_search(lis, left, right, num)

    def bin_search1(nums, target):

    low = 0

    high = len(nums)-1

    while(low <= high):

    mid = low + ((high - low)>>1) # +优先级比》大

    if nums[mid] > target:

    high = mid -1

    elif nums[mid] < target:

    low = mid + 1

    else:

    return mid

    return -1

    2.顺序查找

    def sequence_search(nums, target):

    for i in range(len(nums)):

    if nums[i] == target:

    return i

    return -1

    3.插入查找

    插入查找算法需要注意while循环中的条件判断,真的治学要严谨,分母是不可以等于0。具体参考reference的wiki和博客。

    def interpolation_search(nums, key):

    low = 0

    high = len(nums) -1

    while(nums[low]<= key <=nums[high] and nums[low] !=nums[high]):

    mid = low + int((key - nums[low])*(high - low)/(nums[high]-nums[low]))

    if nums[mid] < key:

    low = mid + 1

    elif nums[mid] > key:

    high = mid - 1

    else:

    return mid

    if key == nums[low]:

    return low

    else:

    return -1

    4.fibo查找算法

    class Fibo_serach:

    def make_fibo_arry(self, nums):

    first = 1

    sec = 1

    third =2

    fblength = 2

    while(third < len(nums)):

    third = first + sec

    first = sec

    sec = third

    fblength += 1

    fb = [1,1]

    for i in range(2, fblength):

    fb.append(fb[i-1] + fb[i-2])

    return fb

    def search(self, nums, key):

    fibo_arry = self.make_fibo_arry(nums)

    last_value_fibo_arry = fibo_arry[-1]

    filled_array = nums

    last_value_nums = nums[-1]

    for j in range(len(nums), last_value_fibo_arry):

    filled_array.append(last_value_nums)

    low = 0

    high = len(nums)

    k = len(fibo_arry) - 1

    while(low <=high):

    mid = low + fibo_arry[k-1] -1 #减去1是因为数组从0 开始

    if key < filled_array[mid]:

    high = mid -1

    k = k - 1

    elif key > filled_array[mid]:

    low = mid + 1

    k = k - 2

    else:

    if mid > high:

    return high

    else:

    return mid

    return -1

    reference:

    标签:return,nums,Python,mid,算法,查找,low

    展开全文
  • 顺序查找顺序查找是按照序列原有顺序对数组进行遍历比较查询基本查找算法顺序查找是最简单搜索算法,其实现如下:def sequential_search(items, item):for i in items:if i == item:return ielse:return False...

    顺序查找

    顺序查找是按照序列原有顺序对数组进行遍历比较查询的基本查找算法,顺序查找是最简单的搜索算法,其实现如下:

    def sequential_search(items, item):

    for i in items:

    if i == item:

    return i

    else:

    return False

    适用于线性表的顺序存储结构和链式存储结构,该算法的时间复杂度为O(n)。

    缺点:是当n 很大时,平均查找长度较大,效率低;

    优点:是对表中数据元素的存储没有要求。另外,对于线性链表,只能进行顺序查找。

    哈希查找算法

    哈希查找算法,依赖哈希表这种数据结构,它是以键值对的形式存储数据,对于哈希查找算法来说,其时间复杂度为O(1),Redis数据表中也有哈希存储,储存形式是键值对。

    python实现哈希数据结构及其哈希查找算法:

    class HashTable:

    def __init__(self, size):

    self.elem = [None for i in range(size)] # 使用list数据结构作为哈希表元素保存方法

    self.count = size # 最大表长

    def hash(self, key):

    return key % self.count # 散列函数采用除留余数法

    def insert_hash(self, key):

    """插入关键字到哈希表内"""

    address = self.hash(key) # 求散列地址

    while self.elem[address]: # 当前位置已经有数据了,发生冲突。

    address = (address + 1) % self.count # 线性探测下一地址是否可用

    self.elem[address] = key # 没有冲突则直接保存。

    def search_hash(self, key):

    """查找关键字,返回布尔值"""

    star = address = self.hash(key)

    while self.elem[address] != key:

    address = (address + 1) % self.count

    if not self.elem[address] or address == star: # 说明没找到或者循环到了开始的位置

    return False

    return True

    哈希查找的产生有这样一种背景——有些数据本身是无法排序的(如图像),有些数据是很难比较的(如图像)。如果数据本身是无法排序的,就不能对它们进行比较查找。

    如果数据是很难比较的,即使采用折半查找,要比较的次数也是非常多的。因此,哈希查找并不查找数据本身,而是先将数据映射为一个整数(它的哈希值),并将哈希值相同的数据存放在同一个位置一即以哈希值为索引构造一个数组。

    在哈希查找的过程中,只需先将要查找的数据映射为它的哈希值,然后查找具有这个哈希值的数据,这就大大减少了查找次数。

    如果构造哈希函数的参数经过精心设计,内存空间也足以存放哈希表,查找一个数据元素所需的比较次数基本上就接近于一次。

    image

    展开全文
  • 顺序查找顺序查找是按照序列原有顺序对数组进行遍历比较查询基本查找算法顺序查找是最简单搜索算法,其实现如下:defsequential_search(items,item):foriinitems:ifi==item:returnielse:returnFalse适用于...
  • 顺序查找是按照序列原有顺序对数组进行遍历比较查询基本查找算法顺序查找是最简单搜索算法,其实现如下: defsequential_search(items,item): foriinitems: ifi==item: returni else: ret...
  • 顺序查找是按照序列原有顺序对数组进行遍历比较查询基本查找算法顺序查找是最简单搜索算法,其实现如下: defsequential_search(items,item): foriinitems: ifi==item: returni else: ret...
  • 折半查找算法带哨兵站顺序查找算法冒泡排序含有顺序查找算法、带哨兵站顺序查找、折半查找算法、冒泡排序 #include #include #define MAX 100 #define MaxSize 100 typedef int DataType; typedef ...
  • 例如:arr = [12,46,25,43,58,7,37,5,80,34,105,82]v = int(input("输入你要查找的数"))ok = Falsefor e in arr:if e==v:ok = Truebreakif ok:print('查找成功!')else:print('查找失败!')执行:输入你要查找的数46...
  • 主要介绍了C++ 实现带监视哨的顺序查找算法,本文通过实例代码给大家介绍非常详细,对大家学习或工作具有一定参考借鉴价值,需要朋友可以参考下
  • 顺序查找---O(n)无序列表查找def sequentialSearch(alist,item):pos = 0found = Falsewhile pos < len(alist) and not found:if alist[pos] == item:found = Trueelse:pos = pos + 1return foundlist = [2,3,1,4,...
  • 顺序查找顺序查找是按照序列原有顺序对数组进行遍历比较查询基本查找算法顺序查找是最简单搜索算法,其实现如下:def sequential_search(items, item): for i in items: if i == item: return i else: ...
  • 通过前面对静态查找表的介绍,...顺序查找的实现静态查找表用顺序存储结构表示时,顺序查找的查找过程为:从表中的最后一个数据元素开始,逐个同记录的关键字做比较,如果匹配成功,则查找成功;反之,如果直到表中...
  • 36 顺序查找算法及程序实现;顺序查找算法的处理过程 假定在数组d中有n个数据查找键已经存储在变量key中其处理过程是从数组d第1个元素d(1)开始依次判断各元素值是否与查找键key相等若某个数组元素d(i)值等于key...
  • 顺序查找顺序查找是按照序列原有顺序对数组进行遍历比较查询基本查找算法顺序查找是最简单搜索算法,其实现如下:def sequential_search(items, item): for i in items: if i == item: return i else: ...
  • 通过前面对静态查找表的介绍,静态查找表...顺序查找的实现静态查找表用顺序存储结构表示时,顺序查找的查找过程为:从表中的最后一个数据元素开始,逐个同记录的关键字做比较,如果匹配成功,则查找成功;反之,如...
  • 顺序查找二分查找练习一、顺序查找data=[1,3,4,5,6]value=1def linear_search(data,value):flag=Falsefor i in range(0,len(data)):if data[i]==value:# return iflag=Trueprint('找到了,在第%s个位置'%i)if not ...
  • 顺序查找又称线性查找:基本思想:从查找表一端开始,向另一端逐个按给定值K与关键字进行比较,若找到,查找成功;并给出记录在表中位置;若整个表检测完,仍未找到与K值相同关键字,则查找失败;优点:对表中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,705
精华内容 1,082
关键字:

实现顺序查找的算法