四 查找

最新推荐文章于 2024-07-06 17:08:12 发布
最新推荐文章于 2024-07-06 17:08:12 发布
阅读量286 收藏
点赞数
文章标签： 二叉树

阅读目录

说是七种，其实二分查找、插值查找以及斐波那契查找都可以归为一类——插值查找。插值查找和斐波那契查找是在二分查找的基础上的优化查找算法。

　查找定义：根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）。

　　 查找算法分类：
　　1）静态查找和动态查找；
　　　　注：静态或者动态都是针对查找表而言的。动态表指查找表中有删除和插入操作的表。
　　2）无序查找和有序查找。
　　　　无序查找：被查找数列有序无序均可；
　　　　有序查找：被查找数列必须为有序数列。

1. 顺序查找

　　 说明：顺序查找适合于存储结构为顺序存储或链接存储的线性表。
　　 基本思想：顺序查找也称为线形查找，属于无序查找算法。从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。
　　 复杂度分析：　
　　查找成功时的平均查找长度为：（假设每个数据元素的概率相等） ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;
　　当查找不成功时，需要n+1次比较，时间复杂度为O(n);
　　所以， 顺序查找的时间复杂度为O(n)。
　　C++实现源码： 
int Sequential_Search2(int *a, int n, int key)
{
	int i;
	a[0] = key;//设置a[0]为关键字值，我们称之为哨兵
	i = n;//循环从数组尾部开始
	while (a[i] != key)//设置哨兵，可以不用检查i是否越界
	{
		i--;
	}
	return i;//查找失败
}

2. 二分查找

　　说明：元素必须是有序的，如果是无序的则要先进行排序操作。

　　基本思想：也称为是折半查找，属于有序查找算法。用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，这样递归进行，直到查找到或查找结束发现表中没有这样的结点。

　　复杂度分析：最坏情况下，关键词比较次数为log2(n+1)，且期望时间复杂度为O(log2n)；

　　注：折半查找的前提条件是需要有序表顺序存储，对于静态查找表，一次排序后不再变化，折半查找能得到不错的效率。但对于需要频繁执行插入或删除操作的数据集来说，维护有序的排序会带来不小的工作量，那就不建议使用。——《大话数据结构》

C++代码

/*二分查找 
      非递归算法*/  
  
int Binary_Search(int *a,int low,int high,int key)  
  
{  
int mid;  
  
while(low<=high)//必须写成low<=high,不能写low!=high ,因为当key为第一个或者最后一个数据时，high==low  
  
{  
mid=(low+high)/2;//折半  
  
if(key<a[mid])  
  
high=mid-1;  
  
else if(key>a[mid])  
  
low=mid+1;  
  
else return mid;  
  
}  
return -1;  
  
}  
[cpp] view plain copy
/*二分查找 
 
    递归算法*/  
  
int Binary_Search(int *a,int low,int high,int key)  
  
{  
  
     int mid;  
  
      if(low>high)   
  
     return -1;//没找到，递归结束  
  
      else{  
        mid=(low+high)/2;  
        if(a[mid]==key)   
  
       return mid;//找到了，递归结束  
  
        else if(a[mid]<key)    
  
       return Binary_Search(a,mid+1,high,key);//右递归  
  
        else  
  
       return  Binary_Search(a,low,mid-1,key);//左递归  
  
    }  
}

3. 插值查找

　　在介绍插值查找之前，首先考虑一个新问题，为什么上述算法一定要是折半，而不是折四分之一或者折更多呢？
　　打个比方，在英文字典里面查“apple”，你下意识翻开字典是翻前面的书页还是后面的书页呢？如果再让你查“zoo”，你又怎么查？很显然，这里你绝对不会是从中间开始查起，而是有一定目的的往前或往后翻。
　　同样的，比如要在取值范围1 ~ 10000 之间 100 个元素从小到大均匀分布的数组中查找5， 我们自然会考虑从数组下标较小的开始查找。
　　经过以上分析，折半查找这种查找方式，不是自适应的（也就是说是傻瓜式的）。二分查找中查找点计算如下：
　　mid=(low+high)/2, 即mid=low+1/2*(high-low);
　　通过类比，我们可以将查找的点改进为如下：
　　mid=low+(key-a[low])/(a[high]-a[low])*(high-low)，
　　也就是将上述的比例参数1/2改进为自适应的，根据关键字在整个有序表中所处的位置，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。
　　 基本思想：基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，插值查找也属于有序查找。
　　注： 对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。
　　复杂度分析：查找成功或者失败的时间复杂度均为O(log2(log2n))。
　　 C++实现源码：将折半查找的mid更改即可

4. 斐波那契查找

　 斐波那契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、····，在数学上，斐波那契被递归方法如下定义：F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2) （n>=2）。该数列越往后相邻的两个数的比值越趋向于黄金比例值（0.618）。

基本算法：

 1、斐波那契查找就是在二分查找的基础上根据斐波那契数列进行分割的。

 2、在斐波那契数列找一个等于略大于查找表中元素个数的数F[n]，将原查找表扩展为长度为F[n](如果要补充元素，则补充重复最后一个元素，直       到满足F[n]个元素)，完成后进行斐波那契分割，即F[n]个元素分割为前半部分F[n-1]个元素，后半部分F[n-2]个元素，找出要查找的元素在那一       部分并递归，直到找到。

复杂度分析：最坏情况下，时间复杂度为O(log2n)，且其期望复杂度也为O(log2n)。

与折半查找相比，斐波那契查找的优点是它只涉及加法和减法运算，而不用除法，而除法比加减法要占用更多的时间，因此，斐波那契查找的运行时间理论上比折半查找小，但是还是得视具体情况而定。

举例分析该算法：

对于斐波那契数列：1、1、2、3、5、8、13、21、34、55、89……（也可以从0开始），前后两个数字的比值随着数列的增加，越来越接近黄金比值0.618。比如这里的89，把它想象成整个有序表的元素个数，而89是由前面的两个斐波那契数34和55相加之后的和，也就是说把元素个数为89的有序表分成由前55个数据元素组成的前半段和由后34个数据元素组成的后半段，那么前半段元素个数和整个有序表长度的比值就接近黄金比值0.618，假如要查找的元素在前半段，那么继续按照斐波那契数列来看，55 = 34 + 21，所以继续把前半段分成前34个数据元素的前半段和后21个元素的后半段，继续查找，如此反复，直到查找成功或失败，这样就把斐波那契数列应用到查找算法中了。


/*斐波那契数列查找*/
int Fibonnacci_search(int *a, int n, int key)
{
	int low, high, mid, i, k;
	low = 1;//定义最低下标为记录首位
	high = n;//定义最高下标为记录末位
	k = 0;
	while (n > F[k] - 1)//计算n位于斐波那契数列的位置
		k++;
	for (i = n; i < F[k] - 1; i++)//将不满的数值补齐，其中F数组为斐波那契数列
		a[i] = a[n];
	while (low < =high)
	{
		mid = low + F[k - 1] - 1;//计算当前分割的下标
		if (key < a[mid])
		{
			high = mid - 1;
			// （全部元素） = （前半部分）+（后半部分）  
			// f[k] = f[k-1] + f[k-2]  
			// 因为前半部分有f[k-1]个元素，所以 k = k-1  
			k = k - 1;//斐波那契数列下标减一位
		}
		else if (key > a[mid])

		{
			low = mid + 1;
			// 因为后半部分有f[k-2]个元素，所以 k = k-2  
			k = k - 2;//斐波那契下标减两位
		}
		else {
			if (mid <= n)
				return mid;//若相等，说明mid即为查找到的位置
			else return n;//若mid>n说明是补全数值，返回n
		}
	}
	return 0;
}

5. 树表查找

　　5.1 最简单的树表查找算法——二叉树查找算法。

　　基本思想：二叉查找树是先对待查找的数据进行生成树，确保树的左分支的值小于右分支的值，然后在就行和每个节点的父节点比较大小，查找最适合的范围。 这个算法的查找效率很高，但是如果使用这种查找方法要首先创建树。 

二叉树：

每个结点最多有两个子树的树结构且左子树和右子树是有顺序的，不能颠倒，即使树中某结点只有一颗子树，也要区分它是左子树还是右子树

1、已知前序遍历序列和中序遍历序列，可以唯一确定一颗二叉树

2、已知后序遍历序列和中序遍历序列，可以唯一确定一颗二叉树。

但是已知前序遍历和后序遍历，是不能确定一颗二叉树的。因为无法确定左子树和右子树。比如前序遍历是ABC,后序遍历是CBA.

则有以下四种情形：


前序遍历（根，左，右）、中序遍历（左，根，右）、后序遍历（左，右，根）都是针对根结点而言的。

二叉查找树（排序树、搜索树）：

1、性质：

    1、可以是空树

    2、若左子树不空，则左子树上所有结点的值均严格小于它的根结点的值

     若右子树不空，则右子树上所有结点的值均严格大于它的根结点的值

    3、它的左右子树也是二叉排序树。

    4、对它进行中序排列时，可以得到一个从小到大排列的有序序列

    5、没有键值相等的点

    二叉搜索树是以链接的方式存储，当需要插入或者删除元素时，只需修改链接指针即可。

2、数据结构

typedef struct  node
{
    KeyType  key ; /*关键字的值*/
    struct node  *lchild,*rchild;/*左右指针*/
}BSTNode, *BSTree;

3、二叉排序树的创建 
可以将树结点逐个插入到二叉排序树（一开始可以是一颗空树）中，只要保证插入后，依然满足二叉排序树的特点，就可以创建一个二叉排序树。 
设树结点的关键字值为key 
算法思想： 
1）若二叉排序树是空树，则将key结点成为二叉排序树的根结点。 
2）若二叉排序树非空树，则将key与二叉排序树的根进行比较： 
a.如果key的值等于根结点的值，则停止插入。 
b.如果key的值小于根结点的值，则将key所在结点插入左子树。 
c.如果key的值大于根结点的值，则将key所在结点插入右子树。 
算法实现:

void InsertBST(BSTree *bst, KeyType key)
/*若在二叉排序树中不存在关键字等于key的元素，插入该元素*/
{ 
    BSTree s;
    if (*bst == NULL)/*递归结束条件*/
    {
        s=(BSTree)malloc(sizeof(BSTNode));/*申请新的结点s*/
        s-> key=key;
        s->lchild=NULL; 
        s->rchild=NULL;
        *bst=s;
    }
    else {
        if (key < (*bst)->key)
            InsertBST(&((*bst)->lchild), key);/*将s插入左子树*/
        else 
            if (key > (*bst)->key)
                InsertBST(&((*bst)->rchild), key); /*将s插入右子树*/
    }
}

4、二叉查找树的查找

因为二叉排序树是可以看作是一个有序表，所以其查找过程和折半查找类似。 

算法思想： 
首先将待查关键字key与根节点关键字t进行比较： 
a.如果key = t, 则返回根节点指针。 
b.如果key < t,则进一步查找左子树。 
c.如果key > t,则进一步查找右子树。 
1）递归算法实现：

/*在根指针bst所指二叉排序树中，递归查找某关键字等于key的元素，若查找成功，返回指向该元素结点指针，否则返回空*/
BSTree  SearchBST(BSTree bst, KeyType key) {
    if (!bst) 
        return NULL;
    else 
        if (bst->key == key)
            return bst;/ *查找成功* /
        else {
            if (bst->key > key)
                return SearchBST(bst->lchild, key); /*在左子树继续查找*/
            else 
                return SearchBST(bst->rchild, key); /*在右子树继续查找*/
    }
}

2）非递归实现

BSTree  SearchBST(BSTree bst, KeyType key)
/*在根指针bst所指二叉排序树bst上，查找关键字等于key的结点，若查找成功，返回指向该元素结点指针，否则返回空指针*/
{ 
    BSTree q;
    q=bst;
    while(q)
    {
        if (q->key == key) 
            return q;  /*查找成功*/
        if (q->key > key)  
            q=q->lchild;  /*在左子树中查找*/
        else  
            q=q->rchild;  /*在右子树中查找*/
    }
    return NULL; /*查找失败*/
}

4、二叉排序树的插入：

/*递归写法*/
BSTNode * insertNode(BSTNode * root, BSTNode * node) {  
        BSTNode*pre=root;  
        if(pre==NULL)  
        { pre=node;  
          return pre;}  
        if(pre->val<node->val)  
        pre->rchild=insertNode(pre->rchild,node);  
        else    
        pre->lchild=insertNode(pre->lchild,node);  
        return root;  
    }  
/*非递归写法*/
BSTNode * InsertNode(BSTNode * root, BSTNode * node) {  
       if(root==NULL)  
       {    
         root=node;  
         return root;  
       }  
       TreeNode*cur=root;  
        while(cur!=NULL)  
       {  
          if(cur->val<node->val)  
          {   if(cur->rchild==NULL)  
                {  cur->rchild=node;  
                   return root;  }//必须写return root不然将陷入无限循环中   
                cur=cur->rchild;  
          }  
          else   
          {    if(cur->lchild==NULL)  
               {  cur->lchild=node;  
                  return root; } 
                  cur=cur->lchild;   
          }  
       }  
       return root;  
    }

5、二叉查找树的删除：

思路：

1、先找到待删除点p
2  如果p不存在，则返回原二叉树
3、p存在
   p无左子树：1、p的父节点f为NULL,则p为根结点，直接返回p的右子树
         2、p不是根结点
            p是f的左子树，将p的右子树链到f的左链上
            p是f的右子树，将p的右子树链到f的右链上

   p有左子树：1、在p的左子树中查找最右结点

                          1、如果p的左子树的右子树不存在（p==q） 

                          2、如果p的左子树的右子树存在（p!=q）

BSTNode  * DelBST(BSTree t, KeyType  k) /*在二叉排序树t中删去关键字为k的结点*/
{
    BSTNode  *p, *f,*s ,*q;
    p=t; 
    f=NULL;
    while(p)  /*查找关键字为k的待删结点p*/
    { 
        if(p->key==k )  break;  /*找到则跳出循环*/
        f=p;   /*f指向p结点的双亲结点*/
        if(p->key>k)  
            p=p->lchild;
        else 
            p=p->rchild;
    } 
    if(p==NULL)  return t;  /*若找不到，返回原来的二叉排序树*/
    if(p->lchild==NULL)  /*p无左子树*/
    { 
        if(f==NULL) 
            t=p->rchild;  /*p是原二叉排序树的根*/
        else 
            if(f->lchild==p)  /*p是f的左孩子*/
                f->lchild=p->rchild ;  /*将p的右子树链到f的左链上*/
            else  /*p是f的右孩子*/
                f->rchild=p->rchild ;  /*将p的右子树链到f的右链上*/
            free(p);  /*释放被删除的结点p*/
    }
    else  /*p有左子树*/
    { 
        q=p; 
        s=p->lchild;
        while(s->rchild)  /*在p的左子树中查找最右结点*/
        {
            q=s; 
            s=s->rchild;
        }
        if(q==p) 
            q->lchild=s->lchild ;  /*重接q的左子树*/
        else 
            q->rchild=s->lchild;/*重接q的右子树*/
        p->key=s->key;  /*将s的值赋给p*/
        free(s);
    }
    return t;
}  /*DelBST*/

6、完整代码描述：

#include <stdio.h>
#include <stdlib.h>

#define ENDKEY 0

typedef int KeyType;

typedef struct  node
{
    KeyType  key ; /*关键字的值*/
    struct node  *lchild,*rchild;/*左右指针*/
}BSTNode, *BSTree;

void InsertBST(BSTree *bst, KeyType key)
/*若在二叉排序树中不存在关键字等于key的元素，插入该元素*/
{ 
    BSTree s;
    if (*bst == NULL)/*递归结束条件*/
    {
        s=(BSTree)malloc(sizeof(BSTNode));/*申请新的结点s*/
        s-> key=key;
        s->lchild=NULL; 
        s->rchild=NULL;
        *bst=s;
    }
    else 
        if (key < (*bst)->key)
            InsertBST(&((*bst)->lchild), key);/*将s插入左子树*/
        else 
            if (key > (*bst)->key)
                InsertBST(&((*bst)->rchild), key); /*将s插入右子树*/
}

void  CreateBST(BSTree  *bst)
/*从键盘输入元素的值，创建相应的二叉排序树*/
{ 
    KeyType key;
    *bst=NULL;
    scanf("%d", &key);
    while (key!=ENDKEY)   /*ENDKEY为自定义常量*/
    {
        InsertBST(bst, key);
        scanf("%d", &key);
    }
}

void  PreOrder(BSTree root) 
/*先序遍历二叉树, root为指向二叉树根结点的指针*/
{
    if (root!=NULL)
    {
        printf("%d  ",root->key);  /*输出结点*/
        PreOrder(root->lchild);  /*先序遍历左子树*/
        PreOrder(root->rchild);  /*先序遍历右子树*/
    }
}

/*
BSTree  SearchBST(BSTree bst, KeyType key)
/ *在根指针bst所指二叉排序树中，递归查找某关键字等于key的元素，若查找成功，返回指向该元素结点指针，否则返回空指针* /
{ 
    if (!bst) 
        return NULL;
    else 
        if (bst->key == key)
            return bst;/ *查找成功* /
        else
            if (bst->key > key)
                return SearchBST(bst->lchild, key);/ *在左子树继续查找* /
            else 
                return SearchBST(bst->rchild, key);/ *在右子树继续查找* /
}*/


BSTree  SearchBST(BSTree bst, KeyType key)
/*在根指针bst所指二叉排序树bst上，查找关键字等于key的结点，若查找成功，返回指向该元素结点指针，否则返回空指针*/
{ 
    BSTree q;
    q=bst;
    while(q)
    {
        if (q->key == key) 
            return q;  /*查找成功*/
        if (q->key > key)  
            q=q->lchild;  /*在左子树中查找*/
        else  
            q=q->rchild;  /*在右子树中查找*/
    }
    return NULL; /*查找失败*/
}/*SearchBST*/

BSTNode  * DelBST(BSTree t, KeyType  k) /*在二叉排序树t中删去关键字为k的结点*/
{
    BSTNode  *p, *f,*s ,*q;
    p=t; 
    f=NULL;
    while(p)  /*查找关键字为k的待删结点p*/
    { 
        if(p->key==k )  break;  /*找到则跳出循环*/
        f=p;   /*f指向p结点的双亲结点*/
        if(p->key>k)  
            p=p->lchild;
        else 
            p=p->rchild;
    } 
    if(p==NULL)  return t;  /*若找不到，返回原来的二叉排序树*/
    if(p->lchild==NULL)  /*p无左子树*/
    { 
        if(f==NULL) 
            t=p->rchild;  /*p是原二叉排序树的根*/
        else 
            if(f->lchild==p)  /*p是f的左孩子*/
                f->lchild=p->rchild ;  /*将p的右子树链到f的左链上*/
            else  /*p是f的右孩子*/
                f->rchild=p->rchild ;  /*将p的右子树链到f的右链上*/
            free(p);  /*释放被删除的结点p*/
    }
    else  /*p有左子树*/
    { 
        q=p; 
        s=p->lchild;
        while(s->rchild)  /*在p的左子树中查找最右下结点*/
        {
            q=s; 
            s=s->rchild;
        }
        if(q==p) 
            q->lchild=s->lchild ;  /*将s的左子树链到q上*/
        else 
            q->rchild=s->lchild;
        p->key=s->key;  /*将s的值赋给p*/
        free(s);
    }
    return t;
}  /*DelBST*/


void main()
{
    BSTree T;
    int k;
    BSTree result;
    printf("建立二叉排序树，请输入序列:\n");
    CreateBST(&T);
    printf("先序遍历输出序列为:");
    PreOrder(T);
    printf("\n请输入要查找的元素:");
    fflush(stdin);
    scanf("%d",&k);
    result = SearchBST(T,k);
    if (result != NULL)
        printf("要查找的元素为%d\n",result->key);
    else
        printf("未找到!\n");
    result = DelBST(T,k);
    PreOrder(result);
}

复杂度分析：它和二分查找一样，插入和查找的时间复杂度均为O(logn)，但是在最坏的情况下仍然会有O(n)的时间复杂度。原因在于插入和删除元素的时候，树没有保持平衡（比如，我们查找上图（b）中的“93”，我们需要进行n次查找操作）。我们追求的是在最坏的情况下仍然有较好的时间复杂度，这就是平衡查找树设计的初衷。

6、平衡二叉树（AVL树）

性质：

（1）一棵空树是平衡二叉树

（2）如果树不为空，它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

（3）是一种二叉排序树

平衡因子BF: 对于任意节点 x ，其平衡因子定义为该节点右子树和左子树高度差，即 bf（x）=h（x-left）-h（x-right）。

平衡二叉树上所有结点的平衡因子只可能是-1、0、1

只要二叉树上有一个结点的平衡因子的绝对值大于1，则该二叉树就不是平衡的

最小不平衡子树：距离插入结点最近的，且平衡因子的绝对值大于1的结点为根的子树 

1. AVL树数据结构

为了方便计算每个节点的平衡因子，对二叉树的数据结构进行修改，增加一个数据单元用于记录以该节点为root的子树高度，重新定义数据结构如下：

[cpp]  view plain  copy
  1. struct BinaryTreeNode {  
  2.     keyType key;  
  3.     int height; //记录以该节点为root的树高度  
  4.     BinaryTreeNode* left; // left child  
  5.     BinaryTreeNode* right; // right child  
  6. };  
  7.   
  8. // define AVL node  
  9. typedef BinaryTreeNode avlnode;  
  10.   
  11. // define AVL tree  
  12. typedef BinaryTreeNode avltree;  
  13.   
  14.   
  15. // 比较左右子树高度，取最大的  
  16. int maxh(int ha, int hb) {  
  17.     return ha > hb ? ha : hb;  
  18. }  
  19.   
  20. // 计算树的高度  
  21. int height(avltree* tree) {  
  22.     if (NULL == tree) return 0;   
  23.     return tree->height;  
  24. }  

2. AVL树旋转操作

AVL在插入和删除节点造成不平衡的时候需要对发生不平衡的节点及时调整，调整方法为旋转操作。根据造成不平衡的节点出构型可分为：LL 、RR 、LR 、RL型，对应的操作则为单旋和双旋，下面分析一下各种构型具体操作方法。

旋转规律：当最小不平衡子树根结点的平衡因子BF是大于1时，就对最小不平衡子树 右旋

                                                                      小于-1时，就对最小不平衡子树 左旋

               插入结点后，最小不平衡子树的BF与它的子树的BF符号相反时，就需要对它的子树先进行一次旋转（与BF符号对应）以使得符号相同后，再反向旋转一次才能够完成平衡操作。

单右旋：


/*对以p为根的二叉排序树作右旋处理*/
/*处理之后p指向新的树根结点，即旋转处理之前的左子树的根结点*/
void R_Rotate(BiTree *p)
{
	BiTree L;
	L = (*p)->lchild;//L指向P的左子树根结点
	（*p)->lchild = L->rchild;//L的右子树挂接为P的左子树
	L->rchild = (*p);
	*p = L;//p指向新的根结点
}

单左旋：

/*对以p为根的二叉排序树作左旋处理*/
/*处理之后p指向新的树根结点，即旋转处理之前的右子树的根结点*/
void L_Rotate(BiTree *p)
{
	BiTree R;
	R = (*p)->rchild;//L指向P的右子树根结点
	（*p)->rchild = R->lchild;//R的左子树挂接为P的右子树
	R->Lchild = (*p);
	*p =R;//p指向新的根结点
}

双旋（先左后右）：

void LR_Rotate(BiTree *p)
{
	 L_Rotate(&(*p)->lchild);
         R_Rotate(p);
}

双旋（先右后左）：

void RL_Rotate(BiTree *p)
{
	 L_Rotate(&(*p)->rchild);
         R_Rotate(p);
}


practicePLUS
关注
专栏目录
Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构的简介、最强学习路线(逻辑结构【数组-链表-栈和队列/树-图-哈希】、物理结构【元素/关系】、数据运算【十大排序/四大查找-图三大搜索-
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
08-05 6000
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构的简介、最强学习路线(逻辑结构【数组-链表-栈和队列/树-图-哈希】、物理结构【元素/关系】、数据运算【十大排序/四大查找-图三大搜索-树三大遍历】、高级算法【枚举/回溯/递归/分治/动规/贪心】)、问题为导向的十大类刷题算法总结之详细攻略 目录 相关文章 数据结构思维导图 基本术语 一、数据结构的概述 二、数据的逻辑结构 三、数据的物理结构 四、数据的运算
数据结构实验之查找四：二分查找
qq_45885219的博客
12-14 380
数据结构实验之查找四：二分查找 Description 在一个给定的无重复元素的递增序列里，查找与给定关键字相同的元素，若存在则输出找到的位置,不存在输出-1。 Input 一组输入数据，输入数据第一行首先输入两个正整数n ( n < = 10^6 )和m ( m < = 10^4 )，n是数组中数据元素个数，随后连续输入n个正整数，输入的数据保证数列递增。 随后m行输入m个待查找的关键字key Output 若在给定的序列中能够找到与关键字key相等的元素，则输出位序(序号从0开始)，否则输出
#数据结构 二叉排序树查找关键字key
qq_42368203的博客
06-16 3163
常见的七种查找算法JAVA
最新发布
weixin_65752158的博客
07-06 1146
也叫做顺序查找说明：顺序查找适合于存储结构为数组或者链表。：顺序查找也称为线形查找，属于无序查找算法。从数据结构线的一端开始，顺序扫描，依次将遍历到的结点与要查找的值相比较，若相等则表示查找成功；若遍历结束仍没有找到相同的，表示查找失败。
头歌-查找的实现及其应用
toptopniba的博客
11-29 2587
第一关、顺序查找第2关：折半查找。
查找算法（基于二叉排序树的查找）
weimeng809的专栏
09-01 1万+
1.二叉排序树的定义与描述 二叉排序树又称为二叉查找树，它是一种特殊的二叉树。 定义：二叉排序树是一颗空树或者是具有一下性质的二叉树。 1）若它的左子树非空，则左子树上所有的结点值均小于根结点的值。 2）若它的右子树非空，则右子树上所有的结点的值均大于（或等于）根结点的值。 3）它的左右子树也分别是二叉排序树。2.数据结构typedef struct node { KeyType
数据结构与算法—二叉排序(查找)树
bigsai
08-19 1万+
再数据结构中`树`、`图`才是数据结构标志性产物，(线性表大多都现成api可以使用),因为树的`难度相比线性表大一些`并且树的`拓展性很强`，你所知道的树、二叉树、**二叉排序树**，**AVL树**，线索二叉树、**红黑树**、B数、线段树等等高级数据结构。然而二叉排序树是所有的基础，所以彻底搞懂二叉排序树也是非常重要的。
四大查找方法
wangzhijie302的博客
12-11 679
@[toc] 查找方法 java 中常用的查找的四种 1.顺序查找 2.二分查找 3.插值查找 4.斐波那契查找 顺序查找 /** * 顺序查找 * * @param arr * @param value * @return */ public static int seqSearch(int[] arr, int value) { //找到返回下标,没找到返回 -1 for (int i = 0;
python每日算法|实现四大查找算法，生动形象，保证一看就会！
REPCHAOCHAO的博客
08-29 1057
python每日算法（8.29）：举例教你如何用用python实现四大查找算法（顺序查找、二分查找、插值查找、斐波那契查找）！
广东工业大学汇编实验四查找电话号码
01-25
题目：查找电话号码phone 二、 实验内容 （1） 要求程序建立一个可存放50项的电话号码表，每项包括人名（20个字符）及电话号码（8个字符）两部分； （2） 程序可接受输入人名及相应的电话号码，并把它们加入电话号码...
数据结构实验四：查找和排序算法实现
weixin_44014654的博客
12-06 4912
一、实验目的 1、各种排序算法的实现 2、各种查找算法实现 二、使用仪器、器材 微机一台 操作系统：WinXP 编程软件：C++ 三、实验内容及原理 1、各种排序算法的实现 用随机函数生成16个2位正整数（10~99），实现插入排序、选择排序、冒泡排序、双向冒泡、快速排序、二路归并排序等多种排序算法，输出排序中间过程、统计关键字的比较次数和记录的移动次数。 2、各种查找算法实现 （1）顺序查找：使...
Educoder头歌数据结构-二叉排序树的查找
qq_50848214的博客
11-30 8012
二叉排序树的查找 第1关：顺序查找 /************************************************************* 顺序查找 实现文件 更新于2020年6月23日 **************************************************************/ int Search_Seq(SSTable L, KeyType key) {/*在静态查找表L中采用顺序查找法，查找其关键字等于key的记录
Java 查找方法
小旺财的博客
02-20 633
但是排序之后，会改变原有数据的顺序，查找出来元素位置跟原来的元素可能是不一样的，所以排序之后再查找只能判断当前数据是否在容器当中，返回的索引无实际的意义。：对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。：也称为是折半查找，属于有序查找算法。说明：元素必须是有序的，从小到大，或者从大到小都是可以的。代码跟二分查找类似，只要修改一下mid的计算方式即可。说明要查找的数字在中间节点左边。
数据结构之查找（五）——二叉查找树
BackkomCoder的博客
12-22 358
二叉查找树（Binary Search Tree）,又称为二叉排序树。它或者是一颗空树，或者是具有下列性质的二叉树： 1.若它的左子树不空，则左子树所有结点的值均小于它的根结点的值； 2.若它的右子树不空，则右子树所有结点的值均大于它的根结点的值； 3.它的左右子树也分别为二叉查找树。
通过代码快速上手C语言数据结构-查找
aiqq136的博客
05-11 506
8.1设置监视哨的顺序查找法 8.2不设置监视哨的顺序查找法 8.3折半查找法 8.4二叉排序树查找的递归 8.5二叉排序树查找的非递归 8.6二叉排序树插入的递归 8.7二叉排序树插入的非递归 8.8创建二叉排序树 8.9在二叉排序树中删除结点 8.10平衡二叉排序树的插入操作 8.11在B_树中查找关键字为k的元素 8.12在B_树中寻找小于等于关键字k的关键字序号 8.13B 树的插入 8.14在B_树的指定位置插上key 8.15B_树的分裂 8.16哈希表的查找曲型题
如何发明新算法（一）
langzizhixin的博客
01-06 3933
如何发明新算法 算法一直是计算机科学的核心，这篇文章我主要从复杂化、简单化、随机化等几个方面进行算法发明。 一、复杂化 把简单的算法想复杂点，得到新的算法。： 排序算法： 查找算法： 直接查找———二分查找———三分查找———四分查找 神经网络： 感知机———二维全连接神经网络———三维全连接神经网络 二、简单化 把复杂的算法简化，丢弃一部分结构，得到新的算法。： 排序算法： 冒泡排序———选择排序———丢弃排序 神经网络： 全连接神经网络———dropdo——— 递归算
[Data Structure & Algorithm] 七大查找算法
weixin_34128839的博客
08-09 3266
　　查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算，例如编译程序中符号表的查找。本文简单概括性的介绍了常见的七种查找算法，说是七种，其实二分查找、插值查找以及斐波那契查找都可以归为一类——插值查找。插值查找和斐波那契查找是在二分查找的基础上的优化查找算法。树表查找和哈希查找会在后续的博文中进行详细介绍。 　　查找定义：根据给定的某个值，在查找表中确定一个其关键字...
七大查找算法
热门推荐
Jibert的博客
02-26 4万+
1. 顺序查找 2. 二分查找 3. 插值查找 4. 斐波那契查找 5. 树表查找 6. 分块查找 7. 哈希查找 查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算，例如编译程序中符号表的查找。本文简单概括性的介绍了常见的七种查找算法，说是七种，其实二分查找、插值查找以及斐波那契查找都可以归为一类——插值查找。插值查找和斐波那契查找是在...
11/29上课内容
cyh
11-29 303
int *p,a[10],p=a 表示数组第3个元素地址的形式：p+2    &a[2]    a+2    &p[2] 指针法数组删除指定元素代码#include main() { char a[]="abcdef23",*p=a,n,*t=p; int i=0,j; scanf("%c",&n); for (p=a; *p; p++) { if (*p==n) {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值