抽象数据类型（ADT)

最新推荐文章于 2023-05-25 19:55:13 发布
最新推荐文章于 2023-05-25 19:55:13 发布
阅读量1.7k 收藏 11
点赞数 3
文章标签： adt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kobewwf24/article/details/51187638
版权

一、什么是抽象数据类型？用来做什么？
ADT是指一个数学模型以及定义在该模型上的操作（即数学模型+数学模型的操作）。难理解，那就先说说类型。一个类型指两类信息：一个属性集+一个操作集），比如，int类型的属性表示它是一个整数，它允许的操作包括加减乘除，取模，改变符号：1+1，那么1是类型，+ - * /等是操作。假设想定义一个新的数据类型，第一，需要提供数据存储的方式；第二，需要提供数据的操作方式。那么，在创建一个新的数据类型需要哪些步骤呢？
1.为类型的属性和可对类型的操作提供一个抽象的描述，比如1是对整数的抽象描述，+ - * /是对类型操作的抽象描述；
2.开发一个实现ADT的编程接口：比如定义一个结构和写一个操作结构的函数；
3.具体编写代码来实现这个接口。

二、构造、使用&实现接口
1.列表：列表是按照一定的线性顺序排列而成的数据。简单列表的接口有两部分：描述数据和描述实现ADT操作的函数。

1.1代码（代码来自《C Primer Plus》）：

（1）构造接口：

/* list.h 接口头文件 */
#ifndef LIST_H_       //防止重复包含list.h文件
#define LIST_H_          
#include <stdbool.h>     /* C99 feature         */

#define TSIZE  45    

struct film
{
    char title[TSIZE];
    int rating;
};

typedef struct film Item;    
typedef struct node
{
    Item item;
    struct node * next;
} Node;
typedef Node * List;     //取个别名，List是指向Node节点的指针

void InitializeList(List * plist);
//初始化列表

bool ListIsEmpty(const List *plist);
//判断列表是否为空，不想因为判断而改变列表的内容，用const修饰List

bool ListIsFull(const List *plist);
//判断列表是否为满

unsigned int ListItemCount(const List *plist);
//列表项目计数，返回值为int型

bool AddItem(Item item, List * plist);
//往列表中增加项目，增加成功返回true，失败返回false


void Traverse (const List *plist, void (* pfun)(Item item) );
//把函数作用于列表的每一项，pfun指向一个函数，该函数接受Item类型的参数

void EmptyTheList(List * plist);
//清空列表

#endif

（2）使用接口：


/* 与list.c 一块编译  */
#include <stdio.h>
#include <stdlib.h>     /* 为 exit()提供原型 */
#include "list.h"      /* list.h定义lIst,Item，提供接口函数原型*/

void showmovies(Item item);

int main(void)
{
    List movies;
    Item temp;

    InitializeList(&movies);    //传递movies的地址，movies本
                                //身是一个指向Node的指针
    if (ListIsFull(&movies))
    {
        fprintf(stderr,"No memory available! Bye!\n");
        exit(1);
    }

    puts("Enter first movie title:");
    while (gets(temp.title) != NULL && temp.title[0] != '\0')
    {
        puts("Enter your rating <0-10>:");
        scanf("%d", &temp.rating);
        while(getchar() != '\n')   //把换行符处理完再结束循环
            continue;
        if (AddItem(temp, &movies)==false)  //增加项目失败
        {
            fprintf(stderr,"Problem allocating memory\n");
            break;
        }
        if (ListIsFull(&movies))
        {
            puts("The list is now full.");
            break;
        }
        puts("Enter next movie title (empty line to stop):");
    }

    if (ListIsEmpty(&movies))
        printf("No data entered. ");
    else
    {
        printf ("Here is the movie list:\n");
        Traverse(&movies, showmovies);
    }
    printf("You entered %d movies.\n", ListItemCount(&movies));

    EmptyTheList(&movies);
    printf("Bye!\n");

    return 0;
}

void showmovies(Item item)
{
    printf("Movie: %s  Rating: %d\n", item.title, item.rating);
}

（3）实现接口：

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

static void CopyToNode(Item item, Node * pnode);
//使用static函数具有内部链接属性

void InitializeList(List * plist)
{
    * plist = NULL;
}

bool ListIsEmpty(const List * plist)
{
    if (*plist == NULL)
        return true;
    else
        return false;
}


bool ListIsFull(const List * plist)  
//这个函数比较奇怪，明明参数，函数定义中却没有使用
{
    Node * pt;
    bool full;

    pt = (Node *) malloc(sizeof(Node));
    if (pt == NULL)
        full = true;
    else
        full = false;
    free(pt);

    return full;
}


unsigned int ListItemCount(const List * plist)
{
    unsigned int count = 0;
    Node * pnode = *plist;    

    while (pnode != NULL)
    {
        ++count;
        pnode = pnode->next;  
    }

    return count;
}



bool AddItem(Item item, List * plist)
{
    Node * pnew;
    Node * scan = *plist;

    pnew = (Node *) malloc(sizeof(Node));
    if (pnew == NULL)
        return false;     

    CopyToNode(item, pnew);
    pnew->next = NULL;
    if(scan == NULL)          
        *plist = pnew;         
    else
    {
        while (scan->next != NULL)
            scan = scan->next;  
        scan->next = pnew;      
    }

    return true;
}


void Traverse  (const List * plist, void (* pfun)(Item item) )
{
    Node * pnode = *plist;   

    while (pnode != NULL)
    {
        (*pfun)(pnode->item); 
        pnode = pnode->next;  
    }
}


void EmptyTheList(List * plist)
{
    Node * psave;

    while (*plist != NULL)
    {
        psave = (*plist)->next; 
        free(*plist);          
        *plist = psave;        
    }
}


static void CopyToNode(Item item, Node * pnode)
{
    pnode->item = item;
}

1.2部分重点代码分析

struct film{
    char title[TSIZE];
    int rating;
};  //定义一个项目，项目包含题目和评分

typedef struct film Item;   //给结构取个别名Item

typedef struct node{
        Item item;
        struct node *next;
}Node;  //定义一个节点，节点包含项目和指向下一个节点的指针

typedef Node *List; //给节点取个别名*List,这样以后List定义的变量    
                    //就是指向节点的指针，稍后会对此着重分析




列表增加项目步骤：
（1）为新节点分配空间；
（2）把项目复制到新节点，新节点的next指针设置为NULL;
（3）如果新节点是添加到列表的第一项，将列表头指针指向新节点；否则，遍历列表找到当前列表最后一个节点（其成员next为NULL），将next改为指向新节点。


bool AddItem(Item item,List *plist) 
/*因为List为指向节点的指针的类型,plist则为指向这种类型的指针*/
{
    Node *pnew;       //定义一个新节点
    List *scan=*plist;  //scan用来遍历列表

    pnew=(Node *)malloc(sizeof(Node);  //为新节点分配内存
    if(pnew==NULL)
        return false;
    CopyToNode(item,pnew);     //复制项目到新节点中
    pnew->next=NULL;    //新节点的next指针指向NULL，表明为最后一个节点

    if(scan==NULL)
        *plist=pnew;     //*plist为指向节点的指针
    else
        {
        while(scan->next!=NULL)  //遍历列表，直到当前列表最后一个项目
            scan=scan->next;
        scan->next=pnew;         //当前列表最后节点的指针指向新节点
        }

    return true;
}



注意到在头文件 list.h中，函数的原型声明：
void InitializeList(List * plist);
bool ListIsEmpty(const List *plist);

再来看看函数在代码段中的应用：
InitializeList(&movies); 
ListIsEmpty(&movies)；

都是传递movies的地址，但是bool ListIsEmpty(const List *plist)加了const,而void InitializeList(List * plist)没加，其原因是初始化List需要修改List的内容，而判断List是否为空并不需要修改内容。

2.队列：队列有两个属性，一增加项目只能在队尾，二删除项目只能在队首，即“先进先出”。

2.1代码：

（1）构造接口：

/* queue.h -- 队列接口 */
#pragma c9x on
#ifndef _QUEUE_H_
#define _QUEUE_H_
#include <stdbool.h>


typedef struct item {    
    int gumption;
    int charisma;
} Item;

#define MAXQUEUE 10    //队列的最大长度

typedef struct node {     //定义结点
    Item item;
    struct node * next;
} Node;

typedef struct queue {    //定义队列
    Node * front;  //指向队列首的指针
    Node * rear;   //指向队列尾的指针
    int items;  //队列中项目的个数
} Queue;

// 描述：初始化队列,将一个队列初始化为空队列
// 输入：pq：指向一个队列‘
// 返回：无
void InitQueue (Queue * pq);

// 描述：检查队列是否已满 
// 输入：pq：指向一个已初始化后的队列
// 返回：ture: 已满   false: 未满
bool QueueIsFull (Queue * pq);

// 描述：检查队列是否为空
// 输入：pq：指向一个已初始化后的队列
// 返回：ture: 已空 false: 未空
bool QueueIsEmpty (Queue * pq);

// 描述：确定队列中项目的个数
// 输入：pq：指向一个已初始化后的队列
// 返回：队列中项目的个数
int QueueItemCount (Queue * pq);

// 描述：向队列尾端添加一个项目
// 输入：pq：指向一个已初始化后的队列 item：项目
// 返回：ture: 成功 false: 失败（队列已满或其它）
bool EnQueue (Queue * pq, Item item);

// 描述：从队列首端删除一个项目
// 输入：pq：指向一个已初始化后的队列 *pitem：删除时将待删除的项目保存到*pitem中
// 输出：ture: 成功（如果队列为空 则将该队列重置为空队列） false: 失败（队列未改变）
bool DeQueue (Queue * pq, Item *pitem);

// 描述：清空队列
// 输入：pq：指向一个已初始化后的队列 
// 输出：无
void EmptyTheQueue (Queue * pq);

#endif

（2）实现接口：

/* queue.c -- 队列类型的实现文件 */
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"


static void CopyToNode (Item item, Node * pn);                   //将项目中的内容保存到结点中
static void CopyToItem (Item *pi, Node * pn);                    //将结点中的内容保存到项目中

void InitQueue (Queue * pq)
{
    pq->front = pq->rear = NULL;
    pq->items = 0;
}

bool QueueIsFull (Queue * pq)
{
    return pq->items == MAXQUEUE;
}

bool QueueIsEmpty (Queue * pq)
{
    return pq->items == 0;
}

int QueueItemCount (Queue * pq)
{
    return pq->items;
}

bool EnQueue (Queue * pq, Item item)
{
    Node *pnew;

    if(QueueIsFull(pg))
        return false;
    pnew=(Node *)malooc(sizeof(Node));
    if(pnew==NULL)
    {
        fprintf(stderr,"Unable to allocate menmory!n");
        eixt(1);
    }

    CopyToNode(item,pnew);
    pnew->next=NULL;

    if(QueueIsEmpty(pg))
        pg->front=pnew;
    else
        pg->rear->next=pnew;
    pg->rear=pnew;
    pg->items++;

    retunrn true;   
}

bool DeQueue (Queue * pq, Item *pitem)
{
    Node * pt;

    if(QueueIsEmpty(pq))
        return false;
    CopyToItem(pitem,pq->front);
    pt = pq->front;
    pq->front = pq->front->next;
    free(pt);
    pq->items--;
    if(pq->items == 0)
        pq->rear = NULL;
    return true;
}

void EmptyTheQueue (Queue * pq)
{
    Item dummy;
    while(!QueueIsEmpty(pq))
        DeQueue(pq,&dummy);
}

static void CopyToNode (Item item, Node * pn)
{
    pn->item = item;
}

static void CopyToItem (Item *pi, Node * pn)
{
    *pi = pn->item;
}

2.2部分代码分析：

typedef struct item {    
    int gumption;
    int charisma;
} Item;

typedef struct node {     //定义结点
    Item item;
    struct node * next;
} Node;

typedef struct queue {    //定义队列
    Node * front;   //指向队列首的指针
    Node * rear;    //指向队列尾的指针
    int items;     //队列中项目的个数
} Queue;

向队列增加项目步骤：
（1）新建一个节点；
（2）将项目复制到新节点；
（3）将新节点的next指针置为NULL，表明该节点是最后一个节点；
（4）将当前节点的next指针指向新节点，把新节点链接到队列中；
（5）如果队列为空，队列的front指针和rear指针都指向新节点；不为空，rear指针指向新节点；
（6）项目数加1。

bool EnQueue(Item item,Queue *pg)
{
    Node *pnew;

    if(QueueIsFull(pg))  //如果队列是的，返回false，增加失败
        return false;
    pnew=(Node *)malooc(sizeof(Node));  //给新节点分配内存
    if(pnew==NULL)
    {
        fprintf(stderr,"Unable to allocate menmory!n");
        eixt(1);
    }

    CopyToNode(item,pnew);  //将项目复制到新节点中
    pnew->next=NULL;        //新节点的next置为NULL

    if(QueueIsEmpty(pg))  //如果队列为空队列首指针指向新节点
        pg->front=pnew;
    else
        pg->rear->next=pnew; //不为空next指针指向新节点
    pg->rear=pnew;      //rear指针指向新节点，表明队尾
    pg->items++;        //项目数加1

    retunrn true;       
}

从队列删除项目步骤：
（1）将要删除项目复制到给定变量中；
（2）释放头指针指向节点的内存；
（3）将头指针指向队列下一个节点；
（4）如果删除的是最后一项，头尾指针都置为NULL。

bool DeQueue(Item *pitem,Queue *pg)
{
    Node *pt;

    if(QueueIsEmpty(pg))   //如果队列为空，返回false删除失败
        return false;
    CopyToItem(pg->front,pitem); //要删除项目复制到给定变量
    pt=pg->front;//头结点指针复制到pt中以释放内存，即删除节点
    pg->front=pg->front->next;//头结点front指针指向下一个节点
    free(pt);        //释放原来头结点的内存
    pg->items--;     //项目数减一
    if(pg->items==0)  //如果最后一项被删除，尾指针置NULL
        pg->rear=NULL;

    return true;

}

3.二叉树：二叉树有两个特点：（1）频繁插入和删除元素，（2
）快速访问元素。

二叉树的实现：

首先定义二叉树：

typedef struct item{
        char petname[20];
        char petkind[20];
}Item;

typedef struct node{
        Item item;
        Node *left;
        Node *right;
}Node;

typedef struct tree{
        Node *root;
        int size;
}Tree;

3.1添加项目：
（1）检查：a.二叉树是否有空位给新节点；b.二叉树中是否有已经有添加的项目；
（2）创建新节点，将项目复制到新节点中，将新节点的左右指针置为NULL；
（3）更新Tree结构的size成员，以记录增加了一个项目；
（4）找出新节点在树中的位置：如果树为空，将根节点指针指向新节点；否则，在树中查找到放置新节点的位置。

bool AddItem(const Item *pi,Tree *ptree)
{
    Node *new_node;

    if(TreeIsFull(ptree))
    {
        fprintf(stderr,"Tree is full\n");
        return false;   
    }
    if(SeekItem(pi,ptree)!=NULL)
    {
        fprintf(stderr,"Attempted to add duplicate items\n");
        retunr false;
    }
    new_node=Makenode(pi);
    ptree->size++;

    if(TreeIsEmpty(ptree))
        ptree->root=new_node;
    else
        AddNode(new_node,ptree->root);
    return true;            
}




static Node *Makenode(const Item *pi)
{
    Node *new_node;

    new_node=(Node *)malloc(sizeof(Node));
    if(new_node!=NULL)
    {
        new_node->item=*pi;
        new_node->left=NULL;
        new_node->rignt=NULL;   
    }

    return new_node;
}



增加的节点有三个可能：向左去，向右去和增加节点失败。假设新增加的节点向左去，如果当前节点的左子树为空，则把左指针指向新节点，否则将递归执行AddNode（）这个函数直到遇到左子树为空的情况。节点向右去的情况也类似。
static void AddNode(Node *new_node,Node *root)
{
    if(ToLeft(&new_node->item,&root->item))
    {
        if(root->left==NUll)
            root->left=new_node;
        else
            AddNode(new_node,root->left);
    }
    else if(ToRignt(&new_node->item,&root->item))
    {
        if(root->right==NUll)
            root->right=new_node;
        else
            AddNode(new_node,root->rignt);
    }
    else
    {
        fprintf(stderr,"location error in Addnode()\n");
        exit(1);
    }

}


static bool ToLeft(const Item *i1,const Item *i2)
{
    int comp1;

    if((comp1=strcmp(i1->petname,i2->petname)z)<0)
        return true;
    else if((comp1==0 && strcmp(i1->petkind,i2->petkind))<0) 
        return true;
    else 
        return false;
}

3.2查找项目：

typedef pair struct{
    Node *parent;
    Node *child;
}Pair;

static Pair SeekItem(const Item *pi,const Tree *ptree)
{
    Pair look;
    look.prent=NULL;
    look.child=ptree->root;

    if(look.child==NULL)
        return look;
    while(look.child!=NULL)
    {
        if(ToLeft(pi,&(look.child->item))
        {
            look.parent=look.child;
            look.child=look.child->left;
        }
        else if(ToLeft(pi,&(look.child->item))
        {
            look.parent=look.child;
            look.child=look.child->right;
        }
        else 
            break;
    }
    return look;        
}

3.3删除项目：

（1）删除节点
删除节点有三种情况：a.待删除的节点无左子树；b.无右子树；c.有两个子树。

static void DeleteNode(Node **ptr)
{
    Node *temp;

    if((*ptr)->left==NULL)
    {
        temp=*ptr;
        *ptr=(*ptr)->rignt;
        free(temp); 
    }

}
kobewwf24
关注
抽象数据类型ADT
weixin_45707270的博客
06-28 1042
什么是抽象数据类型？ 根据百度百科：抽象数据类型（Abstract Data Type，ADT）是计算机科学中具有类似行为的特定类别的数据结构的数学模型；或者具有类似语义的一种或多种程序设计语言的数据类型。抽象数据类型是描述数据结构的一种理论工具，其目的是使人们能够独立于程序的实现细节来理解数据结构的特性。抽象数据类型的定义取决于它的一组逻辑特性，而与计算机内部如何表示无关。 这个定义听起来确实很抽象 0.0 换种方法说，我们知道一些固定的数据类型比如int、float、char、double。。。。。。巴
数据结构课程(共40课) 第二课 抽象数据类型的表示与实现
weixin_30263277的博客
01-25 1732
本课主题： 抽象数据类型的表示与实现 教学目的： 了解抽象数据类型的定义、表示和实现方法 教学重点： 抽象数据类型表示法、类C语言语法 教学难点： 抽象数据类型表示法 授课内容： 一、抽象数据类型定义（ADT） 作用：抽象数据类型可以使我们更容易描述现实世界。例：用线性表描述学生成绩表，用树或图描述遗传关系。 定义：一个数学模型以及定义在该模型上的一组操作。 关键：使用它的人可...
抽象数据类型（ADT）
hit_zjx的博客
06-01 1104
关于面向对象编程ADT的思考
抽象数据类型 (ADT)
weixin_60151280的博客
06-04 1248
一、Abstraction and User-Defined Types二、Classifying Types and Operations不可变数据类型： 其操作不可改变内部值，而是构造新的对象 六、Testing an Abstract Data TypeHow to test an ADT:测试creators, producers, and mutators：调用observers来观察这些operations的结果是否满足spec；测试observers：调用creators, produce
抽象数据类型(ADT)
Thierryxc的博客
08-07 1367
抽象数据类型(ADT)理论基础定义新的类型什么是类型？类型特指两类信息：属性和操作。 假设要定义一个新的数据类型： 首先，必须提供存储数据的方法，例如设计一个结构。 其次，必须提供操控数据的方法。 计算机科学领域已开发了一种定义新类型的好方法，用3个步骤完成抽象到具体的过程。 提供类型属性和相关操作的抽象描述。这些描述既不能依赖特定的实现，也不能依赖特定的编程语言。这种正式的抽象描述被
DataStructures-ADT:抽象数据类型（ADT）算法的实现
03-25
抽象数据类型（ADT）是某种编程语言中与实现无关的数据类型的规范。 ADT的接口是根据类型和对该类型的一组操作定义的。 每个操作的行为取决于其输入和输出。 ADT没有指定如何实现数据类型。 这些实现细节对ADT的...
c语言写报告抽象数据类型,C语言抽象数据类型ADT
weixin_42354108的博客
05-19 915
根据编程的问题匹配合适的数据类型。数据项连接构成了链表，定义了一个结构代表单独的项。设计了一些方法把一系列结构构成一个链表。本质上，我们使用C语言的功能设计了一种符合程序要求的新的数据类型。但是上述的做法不系统。我们要使用更系统的方法定义数据类型。类型指两种信息：属性和操作。定义一个新的数据类型，首先必须提供储存数据的方法。其次必须提供操控数据的方法。计算机科学领域已开发了一种定义新类型的好方法，...
抽象数据类型ADT(栈与队列)
Hulk
06-04 3559
抽象数据类型 abstract data type,ADT:指只通过接口进行访问的数据类型，我们将那些使用ADT的程序叫做客户，将那些确定数据类型的程序叫做实现。数据的表示和实现操作函数都在接口的实现里面，和客户完全分离。接口对于我们来说是不透明的：客户不能通过接口看到方法的实现。优点：将编程时对数据的概念转换从任何特定的数据表示和算法实现中分离出来。使用抽象机制可以让我们关心程序如何实现的细节上...
ADT抽象数据类型
weixin_51404363的博客
06-04 781
一.ADT:抽象数据类型1.除了编程语言所提供的基本数据类型和对象数据类型，程序员可定义自己的数据类型2.抽象数据类型被其操作定义,操作和规约刻画其特征3.抽象数据类型与表示独立性：能够分离数据结构和对其使用的方式4.ADT特性：不变量、表示泄露、、抽象函数AF、表示不变量RI二.可变和不可变数据类型1.可变类型的对象：提供了可改变其内部数据的值的操作2.不可变数据类型：其操作不可改变内部值3.抽象类型的操作:构造器(从无到有),构造器可能需要一个对象参数，但这个参数类型不是要构造的类型生产器(从有到新),
抽象数据类型（三元组ADT、复数四则运算）
05-12
抽象数据类型（三元组ADT、复数四则运算） 数据结构 湖南大学
ADT（抽象数据类型）
ybbgrain的历程
09-23 2744
目录 概述 抽象数据类型的出现 抽象数据类型 总结 概述 什么是ADT？ ADT全称（Abstract Data Type）是指数学模型以及定义在数学模型上的一组操作，抽象数据类型需要通过，固有的数据类型（高级编程中实现的数据类型）。对一个抽象数据类型进行定义时，必须给出他的名字及各运算的运算符名，即函数名。并且规定这些函数的参数性质。 我不知道你们看懂了吗？反正我是没看懂，下面我们来了解一下，通俗的理解方式。 抽象数据类型的出现 最初，计算机当中数据对象都是用二进制来表示，为了提高
抽象数据类型 ADT
FOR 的博客
08-25 4807
5. 抽象数据类型（ADT） 抽象数据类型 (ADT，Abstract Data Type)是指一个 数学模型 以及定义在此数学模型上的一组操作。 它通常是对数据的某种抽象，定义了数据的 取值范围 及其结构形式，以及对 数据操作 的集合 。抽象数据类型是描述数据结构的一种理论工具，其目的是使人们能够独立于程序的实现细节来理解数据结构的特性。 抽象数据类型 （ abstract data type ） 是从数据使用者的角度去看数据类型。抽象数据类型是对数据的一种抽象描述，是一种数学上的约束。数据结构是ADT的
软件构造课程总结（六）——抽象数据类型 (ADT)
最新发布
StarryForest的博客
05-25 525
除了编程语言所提供的基本数据类型和对象数据类型，程序员可定义自己的数据类型。数据抽象：由一组操作所刻画的数据类型。传统的类型定义：关注数据的具体表示抽象类型：强调“作用于数据上的操作”，程序员和客户端无需关心数据如何具体存储的，只需设计/使用操作即可。操作本身（及其规范）完全定义了数据类型，并从数据结构、内存存储或实现的细节中抽象出来。ADT是由操作定义的，与其内部如何实现无关！
抽象数据类型ADT 简述
lan_666的博客
01-28 953
XXX1.h为接口头文件：意义在于总起所有类型（struct等及其内部定义）、函数原型（类似于函数声名的大集合） XXX1.c(XXX1同名)为使用接口的文件，意义在于将头文件里声明的函数实现（比如之前声明了一个Max（int a,int b）函数，在这里用具体程序将此方法实现）比如： Max(int a , int b){ int max; if(a>b) max = a; else max = b; return max; } YYYn.c为实现接口的文件，将通过#include"XXX1.h"将
抽象数据类型（ADT）的学习总结及思考
MDNLNDZ的博客
07-04 2429
一.抽象数据类型（ADT）的概念 一个ADT是一个仅由保存的数据类型和可能在这个数据类型上进行的操作定义的。开发者们只能通过ADT的操作方法来访问ADT的属性，而且他们不会知道这个数据类型内部各种操作是如何实现的。 在Java中，我们常常使用一个接口来给出一个操作集合而不需要透露这些操作实现的细节。ADT提供了一个将对象公共接口中的操作和其具体的实现分开的强有力的工具。这使得一个ADT的实现可以不断变化和演化同时保持其公共接口不变。 可以说，数据得抽象是用抽象数据类型来实...
数据结构和抽象数据类型(ADT)简介
聪明的编译器
05-10 9994
1.    数据（Data）数据是信息的载体。它能够被计算机识别、存储和加工处理，是计算机程序加工的"原料"。随着计算机应用领域的扩大，数据的范畴包括：整数、实数、字符串、图像和声音等。2.   数据元素（Data Element）数据元素是数据的基本单位。数据元素也称元素、结点、顶点、记录。一个数据元素可以由若干个数据项（也可称为字段、域、属性）组成。数据项是具有独立含义的最小标识单位。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值