精华内容
下载资源
问答
  • vector类的ADT定义

    2018-12-22 17:08:00
    vector类的ADT定义 /****************************************************************************************** * Data Structures in C++ * Junjie Mao maxmalmap@qq.com * Computer Science & ...

    vector类的ADT定义

    /******************************************************************************************
     * Data Structures in C++
     * Junjie Mao maxmalmap@qq.com
     * Computer Science & Technology, Tsinghua University
     * Copyright (c) 2018. All rights reserved.
    ******************************************************************************************/
    
    #pragma once
    
    typedef int Rank; //秩
    #define DEFAULT_CAPACITY  3 //默认的初始容量(实际应用中可设置为更大)
    
    template <typename T> class Vector { //向量模板类
    protected:
       Rank _size; int _capacity;  T* _elem; //规模、容量、数据区
       void copyFrom ( T const* A, Rank lo, Rank hi ); //复制数组区间A[lo, hi)
       void expand(); //空间不足时扩容
       void shrink(); //装填因子过小时压缩
       bool bubble ( Rank lo, Rank hi ); //扫描交换
       void bubbleSort ( Rank lo, Rank hi ); //起泡排序算法
       Rank max ( Rank lo, Rank hi ); //选取最大元素
       void selectionSort ( Rank lo, Rank hi ); //选择排序算法
       void merge ( Rank lo, Rank mi, Rank hi ); //归并算法
       void mergeSort ( Rank lo, Rank hi ); //归并排序算法
       Rank partition ( Rank lo, Rank hi ); //轴点构造算法
       void quickSort ( Rank lo, Rank hi ); //快速排序算法
       void heapSort ( Rank lo, Rank hi ); //堆排序(稍后结合完全堆讲解)
    public:
    // 构造函数
       Vector ( int c = DEFAULT_CAPACITY, int s = 0, T v = 0 ) //容量为c、规模为s、所有元素初始为v
       { _elem = new T[_capacity = c]; for ( _size = 0; _size < s; _elem[_size++] = v ); } //s<=c
       Vector ( T const* A, Rank n ) { copyFrom ( A, 0, n ); } //数组整体复制
       Vector ( T const* A, Rank lo, Rank hi ) { copyFrom ( A, lo, hi ); } //区间
       Vector ( Vector<T> const& V ) { copyFrom ( V._elem, 0, V._size ); } //向量整体复制
       Vector ( Vector<T> const& V, Rank lo, Rank hi ) { copyFrom ( V._elem, lo, hi ); } //区间
    // 析构函数
       ~Vector() { delete [] _elem; } //释放内部空间
    // 只读访问接口
       Rank size() const { return _size; } //规模
       bool empty() const { return !_size; } //判空
       int disordered() const; //判断向量是否已排序
       Rank find ( T const& e ) const { return find ( e, 0, _size ); } //无序向量整体查找
       Rank find ( T const& e, Rank lo, Rank hi ) const; //无序向量区间查找
       Rank search ( T const& e ) const //有序向量整体查找
       { return ( 0 >= _size ) ? -1 : search ( e, 0, _size ); }
       Rank search ( T const& e, Rank lo, Rank hi ) const; //有序向量区间查找
    // 可写访问接口
       T& operator[] ( Rank r ) const; //重载下标操作符,可以类似于数组形式引用各元素
       Vector<T> & operator= ( Vector<T> const& ); //重载赋值操作符,以便直接克隆向量
       T remove ( Rank r ); //删除秩为r的元素
       int remove ( Rank lo, Rank hi ); //删除秩在区间[lo, hi)之内的元素
       Rank insert ( Rank r, T const& e ); //插入元素
       Rank insert ( T const& e ) { return insert ( _size, e ); } //默认作为末元素插入
       void sort ( Rank lo, Rank hi ); //对[lo, hi)排序
       void sort() { sort ( 0, _size ); } //整体排序
       void unsort ( Rank lo, Rank hi ); //对[lo, hi)置乱
       void unsort() { unsort ( 0, _size ); } //整体置乱
       int deduplicate(); //无序去重
       int uniquify(); //有序去重
    // 遍历
       void traverse ( void (* ) ( T& ) ); //遍历(使用函数指针,只读或局部性修改)
       template <typename VST> void traverse ( VST& ); //遍历(使用函数对象,可全局性修改)
    }; //Vector
    
    #include "vector_implementation.h"
    

    转载于:https://www.cnblogs.com/mbath/p/10161692.html

    展开全文
  • 相关ADT定义

    2014-09-25 08:52:27
    开干 成绩表  Da

    开干 成绩表

        数据相关:

            学生成绩为数据元素;符合线性表所具备特征。

        操作

            初始化该表

                   前置:线性表不存在

                   输入:无

                   功能:线性表的初始化

                   输出:无

                   后置:空的线性表

            填充

                   前置:表存在

                   输入:学号及其成绩值

                   功能:填充该表

                   输出:无

                   后置:一个非空表

            获取

                   前置:表存在

                   输入:学号

                   功能:查找获取选取学生信息 

                   输出:合法,返回学号对应值;否则抛出

                   后置:表不变

                定位

                            .........

            插入

                            .........

            删除

                            .........

    终结

              



    相关废话:

            我的第一个数据结构相关的帖子,选了一个简单无脑的作业开干。在选帖子属性的时候我点了“原创”,于是抛弃了原本要大部分复制粘贴的想法。又鉴于本人在作业方面比较懒,于是在后面的相关语句用"......"代替了。

            .........



        

    展开全文
  • 本代码中涉及的是一些常见基础的数据结构C语言结构体定义,及相关数据初始和运算,本代码的初衷是方便大家在练习考研编程题缩减不必要的时间,比如一系列的ADT初始化问题。这样大家就可以有较多时间花在思考算法而...
  • 线性表的最简单理解,线性表ADT定义,求两个集合的并集,合并两个集合并且合并之后有序线性表的最简单理解线性表ADT定义求两个集合的并集合并两个集合并且合并之后有序上面只是一个线性表的开端,我想要把线性表详细...

    线性表的最简单理解,线性表ADT定义,求两个集合的并集,合并两个集合并且合并之后有序

    线性表的最简单理解

    线性表是应用广泛最常见并且比较简单的数据结构
    我们在这里不只是对于线性表进行这样的分析,每学习一种数据结构我们都会用抽象数据类型进行分析。
    在这里我们所用到的抽象数据结构和面向对象的类是非常相似的,只不过侧重点不一样,例如我们在C++中我们研究类会经常考虑它的数据和成员对外的可见不可见等等,而DAT更加侧重于他们的关系,所以一般的线性表作为是抽象数据类型是一个很好的研究。
    不同的表示方法也就适用于不同更多范围,所以会对不同存储类型进行对比,由于实现具体细节不一样,所以在应用场合之下,我们就要选择比较合适的表示方法。
    线性表的定义

    文字定义:一个线性表是n个数据元素的有限序列。
    在这里我们有两个关键点,一个是有限,一个是序列
    有限及就是元素个数确定,序列就是说元素之间有顺序
    形式定义:(a1,2,…………ai-1,ai,ai+1…………,an)

    我们举简单的例子:
    ①:26个英文字母组成的字母表(A,B,C,D,E,……,Z)
    数据元素是字符,所有字母前后有顺序,字母表的元素个数有限为26个。

    ②:学生成绩表:(90,97,60,75……,86)
    数据元素为整型,数据元素之间有顺序,学生数量一定是一个确定的值。

    ③:一个数据元素可以由若干个数据项组成,这时,也可以称数据元素为记录。含有大量记录的线性表又称“文件”。

    在这里插入图片描述

    上面的整张表格我们就可以称之为文件
    数据元素(有时候成为结点或者记录):由5个数据项(字段、域)组成
    每一行的数据元素类型相同,并且数据元素个数确定,有顺序
    同一线性表中的元素必定具有相同的特性(属于同一数据对象)
    线性表中的元素之间存在着序偶关系<ai-1,ai>

    在这里插入图片描述

    特点:4个”惟一”
    当线性表的元素是若干个,也就是说数据元素的非空有限集:
    ①存在惟一的被称为第一个的元素
    ②存在惟一的被成为最后一个元素
    ③除第一个之外的数据元素均只有一个前驱
    ④除最后一个元素外的数据元素均只有一个后继。

    这里的四个特点是非常重要的
    ①②决定了数据表是有限的,③④决定了数据表是有序的。
    例如:
    在这里插入图片描述

    线性表ADT定义

    ADT List {
    数据对象:D={ ai | ai ∈ElemSet, i=1,2,…,n, n≥0 }
    数据关系:R1={ <ai-1 ,ai >|ai-1 ,ai∈D, i=2,…,n }
    (线性表是我们数据结构说明的第一个抽象数据类型,那么我们就直接给出抽象)
    基本操作
    结构初始化操作(类似与定义一个变量)
    结构销毁操作(对于已经存在的线性表进行销毁释放存储空间)
    引用型操作(既不改变元素的值,也不改变元素的关系的操作,例如查找)
    加工型操作 (改变元素的值或者改变元素的关系,例如修改元素值,删除元素等)
    } ADT List

    { 结构初始化 }
    InitList ( &L )

    (参数就是既要传值,也要把操作之后的变化结果保留下来,所以&表示为引用)
       操作结果:构造一个空的线性表 L 。

    { 销毁结构 }
      DestroyList( &L )

       初始条件:线性表 L 已存在。
       操作结果:销毁线性表 L 。

    { 引用型操作 }

    操作的结果不改变线性表中的数据元
    素,也不改变数据元素之间的关系。

    ListEmpty( L )
       初始条件:线性表 L 已存在。
       操作结果:若 L 为空表,则返回 TRUE,
    否则返回 FALSE。
    ListLength( L )
     初始条件:线性表 L 已存在。
      操作结果:返回 L 中元素个数。

    PriorElem( L, cur_e, &pre_e )
      初始条件:线性表 L 已存在。
      操作结果:若 cur_e 是 L 中的数据元素,则用 pre_e 返回
    它的前驱,否则操作失败,pre_e 无定义。

    NextElem( L, cur_e, &next_e )
      初始条件:线性表 L 已存在。
      操作结果:若 cur_e 是 L 中的数据元素,则用 next_e 返回
    它的后继,否则操作失败,next_e 无定义。

    GetElem( L, i, &e )
      初始条件:线性表 L 已存在,1≤i≤LengthList(L)。
      操作结果:用 e 返回 L 中第 i 个元素的值。

    LocateElem( L, e, compare( ) )
      初始条件:线性表 L 已存在,compare( ) 是判定函数。
    操作结果:返回 L 中第 1 个与 e 满足关系 compare( ) 的
    元素的位序。若这种元素不存在,则返回 0。

    ListTraverse(L, visit( ))
      初始条件:线性表 L 已存在,visit( ) 为访问函数。
      操作结果:依次对 L 的每个元素调用函数 visit( )。
      一旦 visit( ) 失败,则操作失败。

    { 加工型操作 }
    操作的结果或修改表中的数据
    元素,或修改元素之间的关系
    思考:ClearList(L) 操作与DestroyList(L) 操作 的区别

    ClearList( &L )
      初始条件:线性表 L 已存在。
      操作结果:将 L 重置为空表。

    PutElem( &L, i, e )
      初始条件:线性表 L 已存在,1≤i≤LengthList(L)。
      操作结果:L 中第 i 个元素赋值为 e 的值。

    ListInsert( &L, i, e )
      初始条件:线性表 L 已存在,1≤i≤LengthList(L)+1。
      操作结果:在 L 的第 i 个元素之前插入新的元素 e,
    L 的长度增 1。
    ListDelete( &L, i, &e )
      初始条件:线性表 L 已存在且非空,1≤i≤LengthList(L)。
      操作结果:删除 L 的第 i 个元素,并用 e 返回其值,
    L 的长度减 1。
    } ADT List

    再次强调上面的定义与实现没有任何关系只是对于基本功能的抽象。

    求两个集合的并集

    现在我们对于基本操作举一个例子:
    List myList; //定义一个变量为myList
    //其他代码省略
    ListEmpty(myList); //引用型操作 (判断线性表是否为空)
    ListInsert(myList,3,12); //加工型操作 (在第三个位置之前插入元素12)

    上面的操作简单理解起来就是进行函数调用,然后根据是实现的时候设计的形参进行传递之后操作。

    我们接下来再给出来一个具体的简单应用:
    例如:已知集合A和B,求这两个集合的并集使得A = A∪B 且B不再单独存在。
    现在我们还是不关心实现,假设是ADT的实现我们已经完成,接下来我们就可以直接对于线性表进行操作:
    首先我们考虑如何表示 数据,那么在现在当然是我们说的线性表来表示,那么我们就使用线性表来表示集合。
    那么我们以线性表LA,LB分别表示集合A,B两个线性表的数据元素分别为集合A和集合B中的成员。
    那么我们实际解决的问题就变成了现在要扩大线性表LA,将存于线性表LB中而不存在于线性表LA中的数据元素插入到线性表LA中去。

    那么接下来我们给出具体操作说明:
    ①从LB中取出一个元素数据
    GetElem ( Lb, i, &e )
    ListDelete (&Lb, i, &e )
    ②依次在LA中进行查询 LocateElem ( La, e, equal())
    ③若不存在,则插入LA ListInsert ( &La, n + 1, e )
    重复上述三步直到LB中的数据元素取完为止。
    最终LA就是我们最终的结果。

    接下来我们给出伪代码:

    void union(List &La, List Lb)
    {  La_len = ListLength(La);        Lb_len =ListLength(Lb); 
        for (i = 1; i <= Lb_len; i ++) 
        {   GetElem (Lb, i, &e);        // 取 Lb 中第 i 个数据元素赋给 e  
             if(!LocateElem (La, e, equal())) 
                 ListInsert (La, ++La_len, e);   
                  // La 中不存在和 e  相同的数据元素,则插入之 
        } 
     DestroyList (Lb); // 销毁线性表 Lb 
    } // union 
    

    我们还是认为所有的ADT已经实现
    上面的伪代码逻辑理解并不难,读者有疑惑的话可以停下来多看几遍进行理解。
    时间复杂度:O(ListLength (La)  ListLength (Lb))

    合并两个集合并且合并之后有序

    我们再给出一个例子:
    合并两个有序表:
    LA = (3,5,8,11)
    LB = (2,6,8,9,11,15,20)
    LC = (2,3,5,6,8,8,9,11,11,15,20)

    思路:
    1.分别从 La 和 Lb 中取得当前元素 ai 和 bj ;
    2.若 ai ∩bj,则将 ai 插入到 Lc 中,否则将 bj 插入到 Lc 中。

    我们接下来给出算法:

    void MergeList(List La, List Lb, List &Lc) {
       InitList(Lc);
       i = j = 1; k = 0;
       La_len = ListLength(La);     Lb_len = ListLength(Lb);
       while ((i  La_len) && ( j  Lb_len)) {   // La 和 Lb 均未取完 
            GetElem(La, i, ai ); GetElem(Lb, j, bj );
            if (ai  bj ) {ListInsert(Lc, ++k, ai ); ++i; }
            else { ListInsert(Lc, ++k, bj  ); ++j; }
       }
       while (iLa_len) {GetElem(La, i++, ai);  ListInsert(Lc, ++k, ai);} 
       while (jLb_len) {GetElem(Lb, j++, bj);  ListInsert(Lc, ++k, bj);} 
    }  
    

    时间复杂度:O(ListLength(La) + ListLength(Lb))

    在实际的程序设计中要使用线性表的基本操作,
    必须先实现线性表类型:
    ①:确 定 存 储 结 构
    ②:实 现 基 本 操 作

    本篇总结

    上面只是一个线性表的开端,我想要把线性表详细的给读者说清楚,说明白,所以可能文章会比较长所以分成比较小的博客,所有阶段我都将会分顺序,读者可以根据顺序进行阅读随时那块有任何问题都可以在评论区提出来,一起交流学习。

    展开全文
  • ADT 竞赛  A


    ADT 竞赛

             Data:

                      每个数据元素类型相同。相邻元素具有前驱与后继关系,且第一个元素与最后一个元素互为前驱或后继。

             Operation:

                      Initlist:

                                 前置条件:线性表不存在

                                 输入:人数n,密码m

                                 功能:线性表的初始化

                                 输出:无

                                 后继条件:创建一个有N个元素的循环链表

                     Delete:

                                 前置条件:线性表存在

                                 输入:无

                                 功能:删除特定的元素

                                 输出:无

                                 后继条件:循环链表减少一个元素

                     Count:

                                 前置条件:线性表存在

                                 输入:

                                 功能:计数

                                 输出:

                                 后继条件:循环链表不变

                     Judgement:

                                 前置条件:线性表存在

                                 输入:无

                                 功能:比赛的执行与结果的判断

                                 输出:优胜者

                                 后继条件:循环链表不变

    AND ADT


    展开全文
  • 线性表的ADT定义(学生信息表)

    千次阅读 2014-09-27 13:14:04
    ADT Class Date  线性表中的数据元素具有相同的
  • /** link_list.h** Created on: Nov 1, 2010* Author: jenson*/#ifndef LINK_LIST_H_#define LINK_LIST_H_typedef int elem_type;typedef struct _sq_list_node_ * sq_list;struct _sq_list_n...
  • /** list.h** Created on: Oct 31, 2010* Author: jenson*/#ifndef LIST_H_#define LIST_H_#define TRUE 1;#define FALSE 0;typedef int elem_type;typedef struct _sq_list * sq_list;#defin...
  • /** list.h** Created on: Nov 1, 2010* Author: jenson*/#ifndef LIST_H_#define LIST_H_typedef int elem_type;typedef struct _node_ * node;typedef struct _dr_list_ *dr_list;struct _d...
  • adt

    2010-03-24 08:43:00
    ADT定义:一个ADT是一个仅由保存的数据类型和可能在这个数据类型上进行的操作定义的。开发者们只能通过ADT的操作方法来访问ADT的属性,而且他们不会知道这个数据类型内部各种操作是如何实现的。那么访问ADT就需要出...
  • aeson-typescript:从您的ADT生成TypeScript定义文件
  • ADT

    2018-03-26 10:59:00
    需要读的reading MIT6.031 12,13,14 ADT:abstract data type 抽象数据类型 抽象类型:强调“ ...是由操作定义的,与其内部如何实现无关! AF:abstraction functions 抽象函数 RI:repr...
  • 抽象数据类型定义ADT

    万次阅读 多人点赞 2014-03-16 16:03:56
    一、抽象数据类型定义ADT) 作用:抽象数据类型可以使我们更容易描述现实世界。例:用线性表描述学生成绩表,用树或图描述遗传关系。 定义:一个数学模型以及定义在该模型上的一组操作。 关键:使用它的人...
  • 二叉查找树ADT

    2019-02-13 10:15:00
    二叉查找树ADT  定义:是一个二叉树,其中每一个节点的值大于左子树的所有值而小于右子树的所有值  平衡二叉树:平衡是指一个二叉树的任何节点的深度均不得过深 AVL树  定义:是一个二叉查找树,每个节点的左子树...
  • 1)ADT定义:是指一个数学模型以及定义在该模型上的一组操作。包括:数据对象、数据关系、基本操作。 2)ADT表示:就是要将该类型映射到计算机中,确定存储结构以及该存储结构之上基本操作的函数原型。 3)ADT实现...
  •  基本语言定义ADT  抽象数据类型由两部分组成:一组数据和对这些数据的操作。  使用C++也能定义抽象数据类型,最常见的方式是采用结构体加全局函数;结构体描述数据,全局函数描述对这些数据的操
  • 第六章 树的定义ADT

    2017-04-19 11:36:00
    树的定义树(Tree)是n(n>=0)个结点的有限集。n=0时为空树,在任何一棵非空树中: 1. 有且仅有一个特定的根(Root)结点; 2. 当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1、T2、…Tm,其中每一个集合...
  • 栈的抽象数据类型ADT

    千次阅读 2016-12-29 10:46:00
    对于栈来讲,理论上线性表的操作特性它都具备,可由于它的特殊性,所以针对它在操作上会有些变化。特别是插入和删除操作,我们改名为push和pop,英文直译的话是压和弹,更容易...栈的抽象数据类型ADT定义如下:ADT 栈
  • Array ADT ...ADT 定义: Array(size): 创建一个长度为 size 的一维数组,并且将每个元素初始化成 None length(): 返回数组中的元素个数 getitem(index): 返回指定下标的元素 setitem(index, val...
  • ADT总结

    2021-06-06 23:37:04
    ADT一、ADT是什么?...在客户的视角,一个设计优秀的ADT应当是"公理化定义"的,在使用时不需关注"它是什么",而是关注"它能做什么"。 二、ADT的特性 1.抽象函数 首先介绍两个概念: 1.表示值构成的空间R:实现者.
  • 线性表的定义(一)–概念和ADT 什么是线性表? 线性关系 线性表的抽象数据类型 DestroyList将表中的存储空间都释放掉 而ClearList没有将存储空间释放掉 对表中元素的查找操作 GetElem按位序查找并返回位序的值 ...
  • 上一篇我们说了ADT定义,应该遵循的一些原则,表示独立性,不变性,防止表示泄露。这回我认为我们侧重于ADT设计的一些具体内容。 二.RI与AF 一个ADT是定义在一组操作上的数据类型,操作有了以后,我们要实现rep,而...
  • 栈模型 栈(stack)是限制插人和删除只能在一个位置上进行的表,该位置是表的未端,...对空栈进行的Pop或Top一般被认为是栈ADT的错误。另一方面,当运行Push时空间用尽是一个实现错误,但不是ADT错误。(所以在运行Pu...
  • Head@@3PAUpeople@@A) 已经在 hus_coole.obj 中定义 error LNK2005: "struct people * Ns" (?Ns@@3PAUpeople@@A) 已经在 hus_coole.obj 中定义 error LNK2005: "struct people * Next" (?Next@@3PAUpeople@@A) ...
  • 【数据结构与算法】多项式ADT

    千次阅读 2018-06-13 10:06:00
    多项式ADT 定义一种一元(具有非负次幂)多项式的抽象数据类型, F(X)=∑i=0NAiXiF(X)=∑i=0NAiXi F(X) = \sum_{i=0}^NA_iX^i 对于大部分系数为0的多项式,可以使用一个简单数组来储存这些系数.之后进行加减乘除等...
  • ADT OOP

    2018-06-13 19:32:00
    抽象数据类型(Abstract Data Type,ADT)是是指一个数学模型以及定义在该模型上的一组操作;即包括数据数据元素,数据关系以及相关的操作。 ADT具有以下几个能表达抽象思想的词: 抽象化:用更简单、更高级的...

空空如也

空空如也

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

adt定义