精华内容
下载资源
问答
  • 线性表查找元素
    千次阅读
    2020-04-28 19:17:52

    在线性表中查找特定元素是线性表的常用操作之一。要求补全函数search,实现在一个链表中搜索包含指定数据的结点。如果链表中有多个结点包含该数据,则返回第一个。

    相关知识

    由于链表结点都是动态内存分配得到的,在内存中不是连续存储,没法使用二分法之类的算法来实现信息检索,但可以使用顺序查找的方法。
    顺序查找需要遍历整个链表,逐个检查每个结点是否满足条件。程序中的printList函数已实现了遍历功能,可以参照其来实现查找函数。其中printList函数的实现代码如下:

    // 函数printList:输出链表,每个数据之间用一个空格隔开
    // 参数:h-链表头指针
    void printList(node *h)
    {
        cout << "List:";
        while(h)
        {// h为真,即h指向的结点存在,则输出该结点的数据
            cout << " " << h->data;  // 输出结点数据
            h=h->next;  // 将该结点的指针域赋值给h,h就指向了下一个结点
        }
        cout << endl; // 输出换行符
    }
    #include <iostream>
    //#include "linearList.h"
    using namespace std;
    // 定义结点结构
    struct node
    {
        int data;  // 数据域
        node * next;  // 指针域,指向下一个结点
    };
    // 函数search:在链表中查找包含数据num的结点
    // 参数:h-链表头指针,num-要查找的数据
    // 返回值:找到了返回该结点的地址,否则返回NULL
    node * search(node * h, int num);
    // 函数insertSort:链表排序插入
    // 参数:h-链表头指针,t-指向要插入的结点
    // 返回值:插入结点后链表的首结点地址
    node * insertSort(node *h, node *t);
    // 函数insertHead:链表头部插入
    // 参数:h-链表头指针,t-指向要插入的结点
    // 返回值:插入结点后链表的首结点地址
    node * insertHead(node *h, node *t);
    // 函数printList:输出链表,每个数据之间用一个空格隔开
    // 参数:h-链表头指针
    void printList(node *h);
    // 函数insertTail:链表尾部插入
    // 参数:h-链表头指针,t-指向要插入的结点
    // 返回值:插入结点后链表的首结点地址
    node *insertTail(node *h, node *t);
    // 函数delList:删除链表,释放空间
    // 参数:h-链表头指针
    void delList(node *h);
    int main()
    {
     int n,i,num;
     node *t;
     node *head=NULL; //头指针为NULL,表示线性表为空,结点数为0
     //输入结点数
     cin>>n;
     for(i=0;i<n;i++)
     {
      //为新节点动态分配空间
      t = new node;
      cin>>t->data; //输入结点数据
      t->next=NULL;  //结点指针域值为空
      //构建有序链表
      head = insertSort(head, t);
     }
     //输入要查找的数
     cin>>num;
     //在链表中查找num
     node *np = search(head,num);
     //输出从np开始的后半截链表(如果np为NULL,则输出空链表)
     printList(np);
     //删除结点,释放空间
     delList(head);
     return 0;
    }
    //函数delList:删除链表,释放空间
    //参数:h-链表头指针
    void delList(node *h)
    {
     node *p=h; //指针p指向头结点,第一个要删除的结点
     while(p) //这个结点是存在的
     {
      h = h->next; //头指针h指向下一个结点(下一个结点的地址存在当前结点的指针域中,即h->next中
      delete p; //删除p指向的结点
      p = h; //p指向当前的头结点,即下一个要删除的结点
     }
    }
    //函数printList:输出链表,每个数据之间用一个空格隔开
    //参数:h-链表头指针
    void printList(node *h)
    {
     cout<<"List:"; 
     while(h)
     {//h为真,即h指向的结点存在,则输出该结点的数据
      cout<<" "<<h->data;  //输出结点数据
      h=h->next;  //将该结点的指针域赋值给h,h就指向了下一个结点
     }
     cout<<endl; //输出换行符
    }
    //函数insertTail:链表尾部插入
    //参数:h-链表头指针,t-指向要插入的结点
    //返回值:插入结点后链表的首结点地址
    node *insertTail(node *h, node *t)
    {
     if(h==NULL) //空链表单独处理
     {
      t->next=NULL; //链表尾指针置为NULL
      return t; //返回第一个结点的地址(即链表头指针)
     }
     //非空链表的情况
     node *p=h;
     //让p指向最后一个结点
     while(p->next)
     {
      p=p->next;
     }
     p->next = t; //让最后一个结点的指针域指向结点t
     t->next=NULL; //链表尾指针置为NULL
     return h;  //返回第一个结点的地址(即链表头指针)
    }
    //函数insertHead:链表头部插入
    //参数:h-链表头指针,t-指向要插入的结点
    //返回值:插入结点后链表的首结点地址
    node * insertHead(node *h, node *t)
    {
     t->next=h;
     return t;
    }
    //函数insertSort:链表排序插入
    //参数:h-链表头指针,t-指向要插入的结点
    //返回值:插入结点后链表的首结点地址
    node * insertSort(node *h, node *t)
    {
          node *p=NULL,*q=h; //定位第一个插入点:链首
          while(q && q->data<t->data) //查找插入点
          {//两个指针并行后移
                p=q;
                q=q->next;
          }
          if(p==NULL) //插入链首
          {
                t->next = h;
                return t;
          }
          if(q==NULL) //插入链尾
          {
                p->next = t;
      	    t->next = NULL;
      	    return h;
          }
          //插入p、q之间
          t->next=q;
          p->next=t;
          return h;
    }
    node * search(node * h, int num)
    {
        while(h)
        {// h为真,即h指向的结点存在
            if(h->data == num)
            {
                  return h;
            } 
            h = h->next;  // 将该结点的指针域赋值给h,h就指向了下一个结点
        }
        return NULL; // 没找到包含num的结点
    }
    更多相关内容
  • 数据结构——线性表查找

    千次阅读 2022-02-21 14:17:05
    查找查找的概念线性表查找顺序查找(线性查找)折半查找(二分或对分查找)分块查找 查找的概念 主关键字:可唯一地标识一个记录的关键字就是主关键字 次关键字:用以识别若干记录的关键字就是次关键字 对查找表...

    查找的概念

    主关键字:可唯一地标识一个记录的关键字就是主关键字
    次关键字:用以识别若干记录的关键字就是次关键字

    对查找表经常进行的操作

    1. 查询某个“特定的”数据元素是否在查找表中;
    2. 检索某个“特定的”数据元素的各种属性;
    3. 在查找表中插入一个数据元素;
    4. 删除查找表中的某个数据元素;

    查找表可以分为两类:

    • 静态查找表:
        仅作“查询”(检索)操作的查找表;
    • 动态查找表:
        作“插入”和“删除”操作的查找表;
        有时在查询之后,还需要将“查询”结果为“不在查找表中”的数据元素插入到查找表中;或者,从查找表中删除其“查询”结果为“在查找表中”的数据元素,此类为动态查找表;

    查找算法的评价指标:
    关键字的平均比较次数,也称平均查找长度ASL(Average Search Length)

    A S L = ∑ i = 1 n p i c i   ( 关 键 字 比 较 次 数 的 期 望 值 ) ASL= \sum_{i=1}^n {p_i}{c_i}\,(关键字比较次数的期望值) ASL=i=1npici()
    n n n:记录的个数;
    p i p_i pi:查找第i个记录的概率(通常认为 p i p_i pi = 1 / n 1/n 1/n);
    c i c_i ci:找到第i个记录所需的比较次数;

      查找的方法取决于查找表的结构,即表中数据元素是依何种关系组织在一起的;
      因为“查询”或“检索”在计算机应用系统中使用频度都很高,因此需要设法提高查找表的查找效率
      为提高查找效率,一个办法就是在构造查找表时,在集合中的数据元素之间认为地加上某种确定的约束关系

    线性表的查找

    顺序查找(线性查找)

    顺序查找的特点:
    优点:算法简单,逻辑次序无要求,且不同存储结构均适用;
    缺点:ASL太长,时间效率低;

    应用范围:

    • 顺序或线性链表表示的静态查找表
    • 表内元素之间无序

    顺序表的表示:

    //数据元素类型定义
    typedef struct{
    	KeyType key;	//关键字域
    	......			//其他域
    }ElemType;
    
    //顺序表结构定义类型
    typedef struct{
    	ElemType *R;	//表基址
    	int length;		//表长
    }SStable;			//Sequential Search Table
    SStable ST;			//定义顺序表ST
    

    在这里插入图片描述
    算法:

    int Search_Seq(SSTable ST, KeyType key){
    	//若成功返回其位置信息,否则返回0
    	for(i = ST.length; i >= 1; --i){
    		if(ST.R[i].key == key)	return i;
    		else return 0;
    	}
    }
    

    其他形式:

    int Search_Seq(SSTable ST, KeyType key){
    	for(i = ST.length; i >= 1;ST.R[i].key != key; --i)
    		if(i <= 0) break;
    	if(i > 0) return i;
    	else return 0;
    }
    

    改进:把待查关键字key存入表头(“哨兵”、“监视哨”),从后往前逐个比较,可免去查找过程中每一个都要检测是否完毕,加快速度

    在这里插入图片描述

    //设置监视哨的顺序查找
    int Search_Seq(SSTable ST, KeyType key){
    	ST.R.key = key;
    	for(i = ST.length; ST.R[i].key != key; --i);
    	return i;
    }
    

    时间复杂度: O ( n ) O(n) O(n)
    A S L s ( n ) = ( 1 + 2 + . . . + n ) / n = ( n + 1 ) / 2 ASL_s(n)=(1+2+...+n) /n= (n+1)/2 ASLs(n)=(1+2+...+n)/n=(n+1)/2

    1、记录的查找概率不相等时如何提高查找效率

    查找表存储记录原则——按查找概率高低存储:
    1)查找概率越高,比较次数越少;
    2)查找概率越低,比较次数越多;


    2、记录的查找概率无法测定时如何提高查找效率

    方法——按查找概率动态调整记录顺序
    1)在每个记录中设一个访问频度域;
    2)始终保持记录按非递增有序的次序排列;
    3)每次查找后均将刚查到的记录直接移至表头;

    折半查找(二分或对分查找)


    折半查找:每次将待查记录所在区间缩小一半

    折半查找的特点:
    优点:效率比顺序查找高;
    缺点:只适用于有序表,且限于顺序存储结构(对线性链表无效);

    在这里插入图片描述

    在这里插入图片描述
    算法:

    int Search_Binary(SSTable St, KeyType key){
    	low = 1;
    	high = ST.length;					//置区间初值
    	while(low <= high){
    		mid = (low + high)/2;
    		if(ST.R[mid].key == key)
    			return mid;					//找到待查元素
    		else if(key < ST.R[mid].key)	//缩小查找区间
    			high = mid - 1;				//继续在前半区间进行查找
    		else low = mid +1;				//继续在后半区间进行查找
    	}
    	return 0;		//顺序表中不存在待查元素
    }//Search_Binary
    

    递归算法:

    int Search_Binary(SStable ST, keyType key, int low, int high){
    	if(low > high) return 0;			//查找不到时返回0
    	mid = (low + high)/2;
    	if(key == ST.elem[mid].key)
    		return mid;
    	else if(key < ST.elem[mid].key)
    	......	//递归,在前半区间进行查找
    		else......	//递归,在后半区间进行查找
    }
    


    在这里插入图片描述
    在这里插入图片描述
    如果为顺序查找,则 A S L = ( 11 + 1 ) / 2 = 6 ASL= (11+1)/2 = 6 ASL=(11+1)/2=6

    平均查找长度ASL(成功时):
    设表长 n = 2 h − 1 n = 2^h - 1 n=2h1, 则 h = l o g 2 ( n + 1 ) h = log_2(n+1) h=log2(n+1)(此时,判定树为深度 = h的满二叉树),且表中每个记录的查找概率相等: P i = 1 / n P_i = 1/n Pi=1/n,则:
    A S L = ∑ i = 1 n p i c i = 1 n ∑ i = 1 n c i = n ∑ j = 1 h j ⋅ 2 j − 1 ASL=\sum_{i=1}^{n} p_ic_i = \frac{1}{n}\sum_{i=1}^{n}c_i= {n}\sum_{j=1}^{h}j·2^{j-1} ASL=i=1npici=n1i=1nci=nj=1hj2j1
    = n + 1 n l o g 2 ( n + 1 ) − 1 = \frac{n+1}{n}log_2(n+1)-1 =nn+1log2(n+1)1
    ≈ l o g 2 ( n + 1 ) − 1 ( n > 50 ) ≈log_2(n+1)-1(n > 50) log2(n+1)1n>50
    j j j 为第 j j j 层的每个结点要比较的次数; 2 j − 1 2^{j-1} 2j1 为第 j j j 层结点数

    分块查找


    在这里插入图片描述
    在这里插入图片描述
    优点:插入和删除比较容易,无需进行大量移动;
    缺点:要增加一个索引表的存储空间并对初始索引表进行排序运算;
    适用情况:如果线性表既要快速查找又经常动态变化,则可采用分块查找;

    查找方法的比较:
    在这里插入图片描述

    展开全文
  • ElemType在数据结构中通常指element type(元素的类型),本文使用typedef自定义ElemType和Status为int类型... Status(*compare)(ElemType , ElemType )) //查找顺序表中的特定元素 { int i = 1; int *p = L.elem;

    ElemType在数据结构中通常指element type(元素的类型),本文使用typedef自定义ElemType和Status为int类型。

    typedef int ElemType;
    typedef int Status;

    查找:

    int LocateElem(SqList L, ElemType e,
    	Status(*compare)(ElemType , ElemType )) //查找顺序表中的特定元素
    {		
        int i = 1;
    	int *p = L.elem;    //p的初值为第一个元素的存储位置
    	while (i <= L.length && !(*compare)(*p++, e)) ++i;
    	if (i <= L.length) return i;    //若存在,返回元素的位置
    	else return 0;    //若不存在,返回假
    }
    int IsEqual(ElemType a, ElemType b) //两个变量的比较,相同返回真
    {
    	if (a == b) return 1;
    	else return 0;
    }

    插入:

    Status ListInsert(SqList& L, int i, ElemType e) //顺序表的元素插入
    {	
    	int j;
    	for (j = L.length - 1; j >= i - 1; --j)
    		L.elem[j + 1] = L.elem[j];    //插入位置及之后的元素向右移
    	L.elem[i - 1] = e;                //在指定位置插入新的元素
    	++L.length;
    	return 0;
    }

    考虑移动元素的平均情况,线性表长度为n。则:

    (1)在第i个元素之前插入的概率为Pi,插入一个元素所需要移动元素次数的期望值为

    (2)在任何一个位置上插入的概率相等, 插入一个元素所需要移动元素次数的期望值为

                      Pi=1/(n+1),Eis=n/2

    删除:

    Status ListDelete(SqList& L,int i,ElemType &e)    //顺序表的元素删除 
    {		
    	if((i<1)||(i>L.length )) //所选择的删除位置不合法
    		return 0;
    	int *p=&(L.elem [i-1]);  //删除元素对应地址
    	e=*p;                    //删除位置上的元素,可以添加输出语句,增加可读性
    	int *q=L.elem+L.length-1;//顺序表尾的地址
    	for(++p;p<=q;++p) *(p-1)=*p;
    	--L.length;              //表长减一
    	return 1;
    }

    考虑移动元素的平均情况,线性表长度为n。则:

    (1)删除第i个元素的概率为Qi,删除一个元素所需移动元素次数的期望值为:

    (2)删除任何一个位置上的元素概率相等,移动元素的期望值为:

           Qi=1/n,Edl=(n-1)/2 

    主函数:

    int main(void) {
    	int i,j;
    	SqList L;
    	InistSqList(L);
    	CreateSqList(L);
    	i=LocateElem(L, 12, IsEqual);	//查找顺序表中特定元素12 
    	cout << i << endl;
    	ListInsert(L,2,9);				//在顺序表中第2位插入元素9 
    	PrintSqList(L);
    	ListDelete(L,2,j);				//在顺序表中删除第2位元素 
    	PrintSqList(L);
    }

    关于SqList,InistSqList,CreateSqList,PrintSqList函数,代码和用法都在《线性表的基本创建和输入输出》一文中

    https://blog.csdn.net/qq_56805519/article/details/120061213?spm=1001.2014.3001.5501

    展开全文
  • 线性表查找

    2021-08-24 20:31:20
    线性表查找 查找就是根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素(或记录) 查找表的例子 1.顺序表查找算法

    线性表的查找

    下面图片来自教材《大话数据结构》

    查找就是根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素(或记录)
    查找表的例子

    静态查找表(Static Search Table):只作查找操作的查找表。
    主要操作有:

    1. 查询某个“特定的”数据元素是否在查找表中
    2. 检索某个“特定的”数据元素和各种属性

    动态查找表(Dynamic Search Table):在查找过程中同时插入查找表中不存在的数据元素或从查找表中删除已经存在的某个数据元素
    主要操作:

    1. 查找时插入数据元素
    2. 查找时删除数据元素

    1.顺序表查找算法(静态查找)

    查找基于集合(逻辑结构),集合中的记录之间没有本质关系。如同散落的图书,现将图书排列整齐,就如同将集合构成一个线性表

    顺序查找方法既适用于线性表的顺序存储结构,又适用于线性表的链式存储结构

    以下介绍基于顺序存储结构的顺序查找方法

    数据元素类型定义

    typedef struct{
    	KeyType key;	//关键字域
    	InfoType otherinfo; //其他域
    }ElemType;
    

    顺序表的定义

    typedef struct{
    	Elemtype *R;	//存储空间基地址
    	int length;		//当前线性表的长度
    }SSTable;
    

    顺序算法描述

    int Search_Seq(SSTable ST, KeyType key){
    	for(i=ST.length; i>=1; --i)	//从线性表的尾部开始搜索查找
    		if(ST.R[i].key==key)	//要搜索的关键词为key
    			return i;
    	return 0;
    }
    

    为减少每次进行循环变量的判断,改进程序,从而免去此判断

    int Search_Seq(SSTable ST, KeyType key){
    	ST.R[0].key=key;	//哨兵,设置R[0]的关键词和要查找的关键词一致,如果查找失败就会使得循环退出并返回0,如果成功则返回具体某个i值
    	for(i=ST.length; ST.R[i].key!=key; --i);
    	return i;
    }
    

    2.折半查找(静态查找)

    表中元素已经按从小到大排列好了
    如果目标值小于中间值,则将mid移动至前半部分
    如果目标值大于中间值,则将mid移动至后半部分

    int Search_Bin(SSTable ST,KeyType key){	//关键字key
    	low=1;	
    	high=ST.length;
    	while(low<=high){ //low在high的左侧
    		mid=(low+high)/2;	//折半
    		if(key==ST.R[mid].key)	//查找到了关键字key
    			return mid;	//返回关键词所在数组的下标
    		else if(key<ST.R[mid].key)	//当前关键字小于目标关键字
    			high=mid-1;	//将high移动至mid的前一个
    		else
    			low=mid+1;	//将low移动至mid的后一个
    	}
    	return 0; 
    }
    




    3.分块查找

    稠密索引
    将数据集中的每个记录对应一个索引项

    分块索引
    把数据集的记录分成若干块

    块内无序:每块中的关键码大小无序
    块间有序:第一块中所有关键码都小于第二块,后面的块类似

    展开全文
  • 线性表查找 C语言

    千次阅读 2020-11-09 10:44:50
    我这里先写折半查找(又名二分查找),是一种效率较高的查找方法,就是有个前提,查找数据的前提是数据本身是从小到大的有序排列的。只适用于有序表。时间复杂度为: 代码如下: int SearchList3(SSTable ST,int key...
  • //查找元素x的位置,找到返回指向该结点指针,否则返回NULL int InsertLinkList(LinkList H, int i, ElemType x);//在链表H的第i个位置上插入值为x的元素,成功返回TRUE,否则FALSE int DeleteLinkList(LinkList H, ...
  • 顺序查找线性表查找

    千次阅读 2022-03-25 18:46:43
    顺序查找方法既适用于线性表的顺序存储结构,又适用于线性表的链式存储结构。下面只介绍以顺序表作为存储结构时实现的顺序查找算法。 数据元素类型定义如下: typedef struct { KeyType key; //关键字域 InfoType
  • 二、线性表的初始化以及根据输入的元素建立线性表 1.线性表的初始化,初始化一个空的线性表 2.根据用户需求,向线性表中添加元素 三、顺序查找 Search1函数(没有设置哨兵,需要比较两次) 四、顺序查找(设置哨兵,...
  • 3.在顺序表ST中查找值为key的数据元素 4.设置监视哨的顺序查找 哨兵算法 时间效率的分析 顺序查找的性能分析 1.数据元素类型定义 typedef struct{ KeyType key;//关键字域 ...//其他域 }ElemType; 2....
  • 线性表查找第i个元素

    千次阅读 2021-05-17 01:32:24
    // 删除.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 //群:970353786 #include <stdio.h> #include <malloc.h>...#define Maxsize 100 ...//初始化线性表 void Initlist(Sql
  • 线性表(linear list) )线性表是n个类型相同数据元素的有限序列,通常记作(a 0 , a 1 , …a i-1 , a i , a i+1 …,a n-1 )。1.相同数据类型在线性表的定义中,我们看到从a 0 到a n-1 的n个数据元素是具有相同属性的...
  • 时间与空间复杂度及线性表 序:本文适合刚接触数据结构的小白。 一。时间复杂度 1.概念:对于我们日常写一个算法,对代码运行所消耗的时间的计算。 2.常见的几个时间复杂度: 常见的时间复杂度有O(1) ,O(logn) , O...
  • 线性表查找操作:线性表l查找第一个与元素e满足compare()元素的位置。若在,返回其在l中的次序。若不存在则输出不存在 。  int locateelem_sq(sqlist *l,elemtype e,status (*compare)(elemtype, elemtype)) ...
  • 线性表中数据操作的时间复杂度分析

    千次阅读 多人点赞 2018-09-12 22:42:35
    数据操作的时间复杂度主要由磁盘寻道所消耗的时间所决定,同时在磁盘中通过寻道查找相应数据所需要的时间又由数据在磁盘中的存储形式所影响。想要更加透彻的了解时间复杂度问题,就需要对磁盘的存储原理有一个清楚...
  • 这里介绍几种基于线性表的查找方法: ...1、顺序查找基本思想:从数据的一端开始查找,比较元素是否与查找元素相同,若有则查找成功,直到另一端结束。既适用于线性表的顺序存储结构,也适用于线性表的链式存储结构,但
  • 线性表查找

    2021-04-11 14:42:01
    直接遍历线性表或设置监视哨进行顺序查找。 int Search(int a[],int key,int length) { int i; a[0]=key;//监视哨 for(i=length;a[i]!=key;i--); return i; } 时间复杂度:O(n) 设置监视哨,免去查找过程中每...
  • 获取线性表元素

    千次阅读 2019-08-26 20:39:44
    实现GetElem的具体操作,即将线性表L中的第i个位置的元素返回 。 //得到线性表第i个元素 //得到线性表第i个元素 typedef int Status; Status GetElem(sqlist l,int i,Status *e) { if((l.length==0)||(i<1)||(i&...
  • /*数据结构--线性表 算法函数的实现文件名称:在顺序线性表L中查找第1个值与e满足compare()的元素的位序问题描述:在顺序线性表L中查找第1个值与e满足compare()的元素的位序若找到,则返回其在L中的位序,否则返回0*...
  • PTA 6-4 查找元素(*)

    2021-03-31 14:32:48
    6-4 查找元素(*)添加链接描述 已知顺序表的结构定义如下: typedef struct { int size, length; int *element; } ALIST; 说明:element 为存储数据元素的动态数组的起始地址,size 为动态数组的尺寸,length 为顺序...
  • 查找的对象--查找表 ... 查找表是一类数据的集合,数据元素之间存在着松散的关系(不一定有前驱和后继关系) 关键字: 主关键字:可以唯一的找到一个记录的关键字 次关键字:用于识别若干条记录的关键字 ...
  • java实现线性表的增删改查1线性表的增加1.1 线性表的尾部插入指定元素value1.2 线性表的头部插入指定元素value1.3 线性表中间位置插入指定元素value 1线性表的增加 线性表增加的时候,一定要先判断数组是否已满,...
  • #define InitSize 10 //顺序表的初始长度 ...//按位查找 int GetElem(SeqList L,int i){ return L.data[i-1]; //按值查找(并返回位序) int LocationElem(SeqList L,int e){ for(int i=0;i<L
  • /* Description:线性表查找_顺序查找(C语言源代码) /* Date:2021/9/1 * Author:汝南城 /****************************************************/ #include <stdio.h> #include<stdlib.h> #define ...
  • 线性表查找算法-C语言

    千次阅读 2019-12-05 20:57:07
    了解查找的基本概念,理解顺序查找、折半查找和分块查找的思想,掌握折半查找过程的判定树构造方法,实现线性表查找算法。
  • 数据结构之各数据结构操作的时间复杂度 之 线性表 和 树一、线性表(1)顺序结构(2)链式结构二、二叉树(1)普通二叉树树表的查找(1)二叉排序树结构(2)平衡二叉树(3)红黑树 一、线性表 (1)顺序结构 #...
  • 一、线性表的顺序查找

    千次阅读 2020-07-05 15:45:15
    线性表的顺序查找 1、定义查找表的顺序存储结构 2、定义创建函数(CreateSTable),实现查找表数据元素的输入 3、定义包含有监视哨的顺序查找函数(Search_Seq) 4、在主函数中调用CreateSTable函数和Search_Seq...
  • 线性表查找操作:线性表l查找第一个与元素e满足compare()元素的位置。若在,返回其在l中的次序。若不存在则输出不存在 。 int locateelem_sq(sqlist *l,elemtype e,status (*compare)(elemtype, elemtype)) 第一...
  • 在有序线性表查找x元素

    千次阅读 2018-04-25 00:19:31
    要求设计以算法完成用最少时间在表中查找数值为x的元素,若找到将其与后继元素位置相交换,若找不到将其插入表中并使表中元素仍递增有序。 分析:顺序存储的线性表递增有序,结合题目要求,故可以使用折半查找法...
  • 是一个线性表,表中的数据元素是单个字母。在稍复杂的线性表中,一个数据元素可以包含若干个数据项。 由n(n>=0)个数据特性相同的元素构成的有限序列称为线性表线性表元素的个数n(n>=0)定义为线性表的长度...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,829
精华内容 19,931
关键字:

线性表查找元素