精华内容
下载资源
问答
  • 抽象数据类型的定义

    千次阅读 2016-03-14 19:59:21
    抽象数据类型:(所谓抽象数据类型就是把数据类型和相关操作捆绑在一起) 数据类型:是一组性质相同集合及定义在此集合上一些操作。 按照取值不同,数据类型可以分为两类: 1.原子类型:不可以再分解...
    /**
    抽象数据类型:(所谓抽象数据类型就是把数据类型和相关操作捆绑在一起)
    数据类型:是一组性质相同的值的集合及定义在此集合上的一些操作。
    
    按照取值的不同,数据类型可以分为两类:
      1.原子类型:不可以再分解的基本类型,例如整形,浮点型,字符型等。
      2.结构类型:由若干个类型组合而成,是可以再分解的,例如整形数组
        是由若干整形数组组成的。
    
    抽象:抽象是指抽取事物具有的普遍的本质。它要求抽出问题的特征而
    忽略非本质的细节,是对具体事物的一个概括。抽象是一种思考问题的
    方式,它隐藏了细节。
    */
    #include<stdio.h>
    
    int main()
    {
        printf("Hello 数据库!!!");
        return 0;
    }

    展开全文
  • 请问抽象数据类型的定义到底有什么作用? 如线性表的定义,如果我要建立一个线性表,需要在编译过程中对它进行抽象数据类型的定义吗?
  • v1.0可编辑可修改 v1.0可编辑可修改 4 4第 PAGE #页 v1.0可编辑可修改 v1.0可编辑可修改 1 1第1页 数据结构实验报告 实验名称实验二根据二叉树的抽象数据类型的定义使用二叉链表实现 一个二叉树 学生姓名郭江枫 班 ...
  • 北京邮电大学信息与通信工程学院 第 PAGE 3页 北京邮电大学电信工程学院 第 PAGE 1页 数据结构实验报告 实验名称 实验二根据二叉树的抽象数据类型的定义使用二叉链表实现一个二叉树 学生姓名 郭江枫 班 级 ...
  • Java实现单链表本文将数据结构知识中重要知识点:数据元素,结点,数据类型,抽象数据类型,抽象数据类型的实现、以及对新定义的数据结构的应用等知识通过下述java代码的形式串联起来,以从宏观上对数据结构有一个...

    Java实现单链表

    本文将数据结构知识中重要知识点:数据元素,结点,数据类型,抽象数据类型,抽象数据类型的实现、以及对新定义的数据结构的应用等知识通过下述java代码的形式串联起来,以从宏观上对数据结构有一个透彻的理解和认识。

    我们要使用单链表这个数据结构来解决问题的前提是首先得创建一个单链表数据结构。创建单链表数据结构,就得自定义个单链表的抽象数据类型,抽象数据类型只是对数据结构定义一组逻辑操作,没有具体的实现。在实际应用中,必须实现这个抽象数据类型,才能使用它们,而实现抽象数据类型依赖于数据存储结构。

    1. 为单链表的数据元素自定义结点类 Node.java

    /**

    *为单链表自定义的结点类

    *单链表结点类,泛型参数T指定结点的元素类型

    */

    public class Node

    {

    public T data; //数据域,保存数据元素

    public Node next; //地址域,引用后继结点

    public Node(T data, Node next)//构造结点,data指定数据元素,next指定后继结点

    {

    this.data = data;

    this.next = next;

    }

    public Node()//无参构造函数

    {

    this(null, null);

    }

    //4、Node类可声明以下方法:

    public String toString() //返回结点元素值对应的字符串

    {

    return this.data.toString();

    }

    public boolean equals(Object obj) //比较两个结点值是否相等,覆盖Object类的equals(obj)方法

    {

    return obj==this || obj instanceof Node && this.data.equals(((Node)obj).data);

    }

    }

    2.使用Java接口为线性表自定义的抽象数据类型   :LList.java

    /**

    * 为数据结构线性表自定义的抽象数据类型

    * 在Java中,抽象数据类可以使用接口来描述

    * 线性表接口LList,描泛型参数T表示数据元素的数据类型

    */

    public interface LList //线性表接口,泛型参数T表示线性表中的数据元素的数据类型

    {

    boolean isEmpty(); //判断线性表是否空

    int length(); //返回线性表长度

    T get(int i); //返回第i(i≥0)个元素

    void set(int i, T x); //设置第i个元素值为x

    void insert(int i, T x); //插入x作为第i个元素

    void append(T x); //在线性表最后插入x元素

    T remove(int i); //删除第i个元素并返回被删除对象

    void removeAll(); //删除线性表所有元素

    T search(T key); //查找,返回首次出现的关键字为key元素

    String toString(); //返回显示线性表所有元素值对应的字符串

    }

    3.实现线性表接口---抽象数据类型的实现类-LinkedList.java(链表类,提供Llist接口中抽象方法的具体实现)

    /**

    *线性表的链式表示和实现

    *带头结点的单链表类

    *实现线性表接口

    */

    public class LinkedListimplements LList//带头结点的单链表类,实现线性表接口

    {

    protected Node head;//头指针,指向单链表的头结点

    //默认构造方法,构造空单链表。创建头结点,data和next值均为null

    public LinkedList()

    {

    this.head=new Node();

    }

    由指定数组中的多个对象构造单链表,采用尾插入构造单链表

    public LinkedList(T[] element){

    this(); //创建空单链表,只有头结点

    Node rear = this.head;//rear指向单链表的最后一个结点

    /*

    *若element==null,抛出空对象异常

    *element.length==0时,构造空链表

    */

    for(int i=0;i

    rear.next=new Node(element[i],null);//尾插入,创建结点链入rear结点之后

    rear=rear.next;//rear指向新的链尾结点

    }

    }

    //判断单链表是否为空,O(1)

    public boolean isEmpty(){

    return this.head.next==null;

    }

    //求链表的长度

    public int length(){

    int i=0;

    Node p = this.head.next;//p从单链表第一个结点开始

    while(p!=null){ //若单链表未结束

    i++;

    p=p.next;//p到达后继结点

    }

    return i;

    }

    //返回单链表所有元素的描述字符串,形式为“(,)”,覆盖Object类的toString()方法,O(n)

    public String toString(){

    String str="(";

    Node p =this.head.next;

    while(p!=null){

    str+=p.data.toString();

    if(p.next!=null){

    str +=",";//不是最后一个结点时后加分隔符

    }

    p=p.next;

    }

    return str+=")";

    }

    //返回第i(i>=0)个元素,若i无效,则返回null

    public T get(int i){

    if(i>=0){

    Node p=this.head.next;

    for(int j=0; p!=null&&j

    p=p.next;

    if(p!=null)

    return p.data;//p指向第i个结点

    }

    return null;

    }

    //设置第i(i>=0)个元素值为x,若i指定序号无效则抛出序号越界异常

    public void set(int i,T x){

    if(x==null)

    return;//不能设置空对象

    if(i>=0){

    Node p =this.head.next;

    for(int j =0;p!=null&&j

    p=p.next;

    }

    if(p!=null)

    p.data=x;

    }else throw new IndexOutOfBoundsException(i+"");//抛出序号越界异常

    }

    //将x对象出插入在序号为i结点前,O(n)

    public void insert(int i,T x){

    if(x==null)

    return;

    Node p =this.head;

    for(int j =0;p.next!=null&&j

    p=p.next;

    }

    p.next=new Node(x,p.next);

    }

    //在单链表的最后添加对象,O(n)

    public void append(T x){

    insert(Integer.MAX_VALUE,x);

    }

    //删除序号为i的结点

    public T remove(int i){

    if(i>0){

    Node p=this.head;

    for(int j =0;p.next!=null&&j

    p=p.next;

    if(p.next!=null){

    T old=p.next.data;

    p.next=p.next.next;

    return old;

    }

    }

    return null;

    }

    //删除链表所有元素,Java自动收回各结点所占用的内存空间

    public void removeAll(){

    this.head.next=null;

    }

    /*

    public T search(T key){

    if(key==null)

    return null;

    Node p=this.head.next;

    while(p!=null&&p.data.compareTo(key)<=0){

    if(p.data.compareTo(key)==0)

    return p.data;

    p=p.next;

    }

    return null;

    }

    */

    //查找,返回首次出现的关键字为key的元素

    public T search(T key)

    {

    if (key==null)

    return null;

    for (Node p=this.head.next; p!=null; p=p.next)

    if (p.data.equals(key))

    return p.data;

    return null;

    }

    }

    4.利用前面新创建的单链表数据类型,实现单链表逆转 SinglyLinkedList_reverse.java

    注:LinkedList声明为泛型类,类型形式参数T表示链表元素的数据类型。当声明LinkedList类的对象并创建实例时,再指定泛型参数T的实际类型参数为一个确定的类,例如:LinkedList list = new LinkedList();  LinkedList list = new LinkedList();   这样可保证一个链表中的所有数据元素是相同类及其子类的对象。如果向链表添加指定泛型以外的对象,则会出现编译错误。T 的实际类型参数必须是类,不能使int 、char等基本数据类型。如果需要表示基本数据类型,则必须使用对应数据类型的包装类,如Integer 、Character等。

    /**

    *利用前面新创建的单链表数据类型,实现单链表逆转

    */

    public class SinglyLinkedList_reverse

    {

    //将单链表逆转,泛型方法,返回值类型前声明类型参数T

    //public static void reverse(SinglyLinkedList list)

    public static void reverse(LinkedList list)

    {

    Node p=list.head.next, succ=null, front=null; //head必须声明为public

    while (p!=null)

    {

    succ = p.next; //设置succ是p结点的后继结点

    p.next = front; //使p.next指向p结点的前驱结点

    front = p;

    p = succ; //p向后走一步

    }

    list.head.next = front;

    }

    public static void main(String args[])

    {

    String value[]={"A","B","C","D","E","F"};

    //SinglyLinkedList list = new SinglyLinkedList(value);

    LinkedList list = new LinkedList(value);

    System.out.println("list: "+list.toString());

    reverse(list);

    System.out.println("逆转后 "+list.toString());

    }

    }

    /*

    程序运行结果如下:

    list: (A, B, C, D, E, F)

    逆转后 (F, E, D, C, B, A)

    */

    展开全文
  • Java实现单链表 本文将数据结构知识中重要知识点:数据元素,结点,数据类型,抽象数据类型,抽象数据类型的实现、以及对新定义的数据结构的应用等知识通过下述java代码的形式串联起来,以从宏观上对数据结构有一个...

      Java实现单链表  

           本文将数据结构知识中重要知识点数据元素,结点,数据类型,抽象数据类型,抽象数据类型的实现、以及对新定义的数据结构的应用等知识通过下述java代码的形式串联起来以从宏观上对数据结构有一个透彻的理解和认识。

           我们要使用单链表这个数据结构来解决问题的前提是首先得创建一个单链表数据结构。创建单链表数据结构,就得自定义个单链表的抽象数据类型,抽象数据类型只是对数据结构定义一组逻辑操作,没有具体的实现。在实际应用中,必须实现这个抽象数据类型,才能使用它们,而实现抽象数据类型依赖于数据存储结构。

    1. 为单链表的数据元素自定义结点类 Node.java

    [java] view plain copy
    1. /** 
    2.  *为单链表自定义的结点类 
    3.  *单链表结点类,泛型参数T指定结点的元素类型 
    4.  */  
    5. public class Node<T>   
    6. {  
    7.     public T data;   //数据域,保存数据元素  
    8.     public Node<T> next; //地址域,引用后继结点  
    9.   
    10.     public Node(T data, Node<T> next)//构造结点,data指定数据元素,next指定后继结点  
    11.     {  
    12.         this.data = data;  
    13.         this.next = next;  
    14.     }  
    15.     public Node()//无参构造函数  
    16.     {  
    17.         this(nullnull);  
    18.     }  
    19.   
    20.     //4、Node类可声明以下方法:  
    21.     public String toString()                     //返回结点元素值对应的字符串  
    22.     {  
    23.         return this.data.toString();  
    24.     }      
    25.     public boolean equals(Object obj)            //比较两个结点值是否相等,覆盖Object类的equals(obj)方法  
    26.     {  
    27.         return obj==this || obj instanceof Node && this.data.equals(((Node<T>)obj).data);  
    28.     }      
    29. }  
    2.使用Java接口为线性表自定义的抽象数据类型   :LList.java

    [java] view plain copy
    1. /** 
    2.  * 为数据结构线性表自定义的抽象数据类型 
    3.  * 在Java中,抽象数据类可以使用接口来描述 
    4.  * 线性表接口LList,描泛型参数T表示数据元素的数据类型 
    5.  */  
    6. public interface LList<T>     //线性表接口,泛型参数T表示线性表中的数据元素的数据类型  
    7. {  
    8.     boolean isEmpty();        //判断线性表是否空  
    9.     int length();             //返回线性表长度  
    10.     T get(int i);             //返回第i(i≥0)个元素  
    11.     void set(int i, T x);     //设置第i个元素值为x  
    12.     void insert(int i, T x);  //插入x作为第i个元素  
    13.     void append(T x);         //在线性表最后插入x元素  
    14.     T remove(int i);          //删除第i个元素并返回被删除对象  
    15.     void removeAll();         //删除线性表所有元素  
    16.     T search(T key);          //查找,返回首次出现的关键字为key元素  
    17.     String toString();        //返回显示线性表所有元素值对应的字符串  
    18. }  

    3.实现线性表接口---抽象数据类型的实现类-LinkedList.java(链表类,提供Llist接口中抽象方法的具体实现)

    [java] view plain copy
    1. /** 
    2.  *线性表的链式表示和实现 
    3.  *带头结点的单链表类 
    4.  *实现线性表接口 
    5.  */  
    6. public class LinkedList<T>implements LList<T>//带头结点的单链表类,实现线性表接口  
    7. {  
    8.     protected Node<T> head;//头指针,指向单链表的头结点  
    9.     //默认构造方法,构造空单链表。创建头结点,data和next值均为null  
    10.     public LinkedList()  
    11.     {  
    12.         this.head=new Node<T>();  
    13.     }  
    14.     由指定数组中的多个对象构造单链表,采用尾插入构造单链表  
    15.     public LinkedList(T[] element){  
    16.           
    17.         this(); //创建空单链表,只有头结点  
    18.         Node<T> rear = this.head;//rear指向单链表的最后一个结点  
    19.         /* 
    20.          *若element==null,抛出空对象异常 
    21.          *element.length==0时,构造空链表  
    22.          */  
    23.         for(int i=0;i<element.length;i++){  
    24.             rear.next=new Node<T>(element[i],null);//尾插入,创建结点链入rear结点之后  
    25.             rear=rear.next;//rear指向新的链尾结点  
    26.         }  
    27.     }  
    28.     //判断单链表是否为空,O(1)  
    29.     public boolean isEmpty(){  
    30.         return this.head.next==null;  
    31.     }  
    32.     //求链表的长度  
    33.     public int length(){  
    34.         int i=0;  
    35.         Node<T> p = this.head.next;//p从单链表第一个结点开始  
    36.         while(p!=null){ //若单链表未结束  
    37.             i++;  
    38.             p=p.next;//p到达后继结点  
    39.         }  
    40.         return i;  
    41.     }  
    42.     //返回单链表所有元素的描述字符串,形式为“(,)”,覆盖Object类的toString()方法,O(n)  
    43.     public String toString(){  
    44.         String str="(";  
    45.         Node<T> p =this.head.next;  
    46.         while(p!=null){  
    47.             str+=p.data.toString();  
    48.             if(p.next!=null){  
    49.                 str +=",";  //不是最后一个结点时后加分隔符          
    50.             }  
    51.             p=p.next;  
    52.         }  
    53.         return str+=")";  
    54.     }  
    55.     //返回第i(i>=0)个元素,若i无效,则返回null  
    56.     public T get(int i){  
    57.         if(i>=0){  
    58.             Node<T> p=this.head.next;  
    59.             for(int j=0; p!=null&&j<i;j++)  
    60.                 p=p.next;  
    61.             if(p!=null)  
    62.                 return p.data;//p指向第i个结点  
    63.         }  
    64.         return null;  
    65.     }  
    66.     //设置第i(i>=0)个元素值为x,若i指定序号无效则抛出序号越界异常  
    67.     public void set(int i,T x){  
    68.         if(x==null)  
    69.             return;//不能设置空对象  
    70.         if(i>=0){  
    71.             Node<T> p =this.head.next;  
    72.             for(int j =0;p!=null&&j<i;j++){  
    73.                 p=p.next;  
    74.             }  
    75.             if(p!=null)  
    76.                 p.data=x;  
    77.         }else throw new IndexOutOfBoundsException(i+"");//抛出序号越界异常  
    78.     }  
    79.     //将x对象出插入在序号为i结点前,O(n)  
    80.     public void insert(int i,T x){  
    81.         if(x==null)  
    82.             return;  
    83.         Node<T> p =this.head;  
    84.         for(int j =0;p.next!=null&&j<i;j++){  
    85.             p=p.next;  
    86.         }  
    87.         p.next=new Node<T>(x,p.next);       
    88.     }  
    89.     //在单链表的最后添加对象,O(n)  
    90.     public void append(T x){  
    91.         insert(Integer.MAX_VALUE,x);  
    92.     }  
    93.     //删除序号为i的结点  
    94.     public T remove(int i){  
    95.         if(i>0){  
    96.             Node<T> p=this.head;  
    97.             for(int j =0;p.next!=null&&j<i;j++)  
    98.                 p=p.next;  
    99.             if(p.next!=null){  
    100.                 T old=p.next.data;  
    101.                 p.next=p.next.next;  
    102.                 return old;  
    103.             }  
    104.         }  
    105.         return null;  
    106.     }     
    107.     //删除链表所有元素,Java自动收回各结点所占用的内存空间  
    108.     public void removeAll(){  
    109.         this.head.next=null;  
    110.     }  
    111. /* 
    112.     public T search(T key){ 
    113.         if(key==null) 
    114.             return null; 
    115.         Node<T> p=this.head.next; 
    116.         while(p!=null&&p.data.compareTo(key)<=0){ 
    117.             if(p.data.compareTo(key)==0) 
    118.                 return p.data; 
    119.             p=p.next; 
    120.             } 
    121.         return null;         
    122.     } 
    123. */  
    124.     //查找,返回首次出现的关键字为key的元素  
    125.     public T search(T key)   
    126.     {  
    127.         if (key==null)  
    128.             return null;  
    129.         for (Node<T> p=this.head.next;  p!=null;  p=p.next)  
    130.             if (p.data.equals(key))  
    131.                 return p.data;  
    132.         return null;  
    133.     }  
    134. }  

    4.利用前面新创建的单链表数据类型,实现单链表逆转 SinglyLinkedList_reverse.java

    注:LinkedList<T>声明为泛型类,类型形式参数T表示链表元素的数据类型。当声明LinkedList类的对象并创建实例时,再指定泛型参数T的实际类型参数为一个确定,例如:LinkedList<String> list = new LinkedList<String>();  LinkedList<Integer> list = new LinkedList<Integer>();   这样可保证一个链表中的所有数据元素是相同类及其子类的对象。如果向链表添加指定泛型以外的对象,则会出现编译错误。T 的实际类型参数必须是类,不能使int 、char等基本数据类型。如果需要表示基本数据类型,则必须使用对应数据类型的包装类,如Integer 、Character等。

    [java] view plain copy
    1. /** 
    2.  *利用前面新创建的单链表数据类型,实现单链表逆转 
    3.  */  
    4. public class SinglyLinkedList_reverse   
    5. {  
    6.     //将单链表逆转,泛型方法,返回值类型前声明类型参数T  
    7.     //public static <T> void reverse(SinglyLinkedList<T> list)  
    8.     public static <T> void reverse(LinkedList<T> list)  
    9.     {  
    10.         Node<T> p=list.head.next, succ=null, front=null;   //head必须声明为public   
    11.         while (p!=null)  
    12.         {  
    13.             succ = p.next;  //设置succ是p结点的后继结点  
    14.             p.next = front; //使p.next指向p结点的前驱结点  
    15.             front = p;  
    16.             p = succ;       //p向后走一步  
    17.         }  
    18.         list.head.next = front;  
    19.     }  
    20.     
    21.     public static void main(String args[])  
    22.     {  
    23.         String value[]={"A","B","C","D","E","F"};  
    24.         //SinglyLinkedList<String> list = new SinglyLinkedList<String>(value);  
    25.         LinkedList<String> list = new LinkedList<String>(value);  
    26.         System.out.println("list: "+list.toString());  
    27.         reverse(list);  
    28.         System.out.println("逆转后 "+list.toString());  
    29.     }  
    30. }  
    31. /* 
    32. 程序运行结果如下:     
    33. list: (A, B, C, D, E, F) 
    34. 逆转后 (F, E, D, C, B, A) 
    35. */  

    原文链接:

    点击打开链接

    展开全文
  • 二叉树基本功能: 1、二叉树建立 2、前序遍历二叉树 3、中序遍历二叉树 4、后序遍历二叉树 5、按层序遍历二叉树 6、求二叉树深度 7、求指定结点到根路径 8、二叉树销毁 9、其他:自定义操作
  • 改正:void Create( Complex &C, float x, float y),以“&”打头参数即为引用参数,使用方式为 :变量类型 &具体变量 c++中[Error] cin was not declared in this scope问题解决 原因:缺少 #include using ...
    # include<stdio.h>
    #include<iostream>
    #include <iomanip>
    using namespace std;
    # include<stdlib.h>
    typedef struct{
    	float Realpart;//实部
    	float Imagepart;//虚部
    }Complex;
    void Create (Complex &C,float x,float y);//创建复数
    float GetReal(Complex C);//求实部
    float GetImag(Complex C);//求虚部
    Complex Add(Complex C1,Complex C2);//求复数之和
    Complex Sub(Complex C1,Complex C2);//求复数之差
    int main()
    {
    	Complex a,b,sum,sub;
    	float x,y,x1,y1;
    	cin>>x>>y>>x1>>y1;//输入
    	Create(a,x,y);
    	Create(b,x1,y1);
    //	GetReal(a);
    //	GetReal(b);
    //	GetImag(a);
    //	GetImag(b);
    	cout<<a.Realpart <<endl;
    	cout<<a.Imagepart <<endl;
    	cout<<a.Realpart <<'+'<<a.Imagepart <<"*i"<<endl;
    	cout<<b.Realpart <<endl;
    	cout<<b.Imagepart <<endl;
    	cout<<b.Realpart <<'+'<<b.Imagepart <<"*i"<<endl;
    	sum=Add(a,b);
    	cout<<"两复数智和为:"<<sum.Realpart <<'+'<<sum.Imagepart<<"*i"<<endl;
    	sub=Sub(a,b); 
    	cout<<"两复数之差为:"<<sub.Realpart <<'+'<<sub.Imagepart <<"*i"<<endl; 
    	return 0;
     } 
     void Create (Complex &C,float x,float y)
     {
     	C.Realpart=x;
     	C.Imagepart=y;
     }
     float GetReal(Complex C)
     {
     	return C.Realpart;
     }
     float GetImag(Complex C)
     {
     	return C.Imagepart;
     }
     Complex Add(Complex C1,Complex C2)
     {
     	Complex sum;
     	sum.Realpart =C1.Realpart +C2.Realpart ;
     	sum.Imagepart =C1.Imagepart +C2.Imagepart ;
     	return sum;
     }
     Complex Sub(Complex C1,Complex C2)
     {
     	Complex difference;
     	difference.Realpart =C1.Realpart -C2.Realpart ;
     	difference.Imagepart =C1.Imagepart -C2.Imagepart ;
     	return difference;
     } 
    

    [Error] variable or field ‘Create’ declared void问题解决
    在编写代码过程中出现bug: [Error] variable or field ‘Create’ declared void(变量或字段声明无效)

    void Create( &Complex C, float x, float y) 改正:void Create( Complex &C, float x, float y),以“&”打头的参数即为引用参数,使用方式为 :变量类型 &具体变量
    c++中[Error] cin was not declared in this scope问题解决

    原因:缺少
    #include<iostream>
    using namespace std;
    

    上面程序的运行结果
    上面

    展开全文
  • InitTriplet(&T,v1,v2,...书上说它能够提供输入值和返回操作结果,我在网上查了,引用参数是作为形参传递实参地址的,引用参数在这个三元组的定义中怎么理解(哪个是提供输入值哪个是返回操作结果的),求各位大神指点
  • 2.1.2抽象数据类型线性表的定义 ADJ List {数据对象:D-{aiai Elem Set,i-1,2,n,n>=0 数据关系:Rl-{,ai>ai-1,aiD,i-1,2.n} 基本操作 1. IiniList&L) //构造空表L 2. LengthList(L) //求表L的长度 3. GetElem(L, i, &e...
  • 数据类型是程序设计语言中的一个概念,它是一个值的集合和操作的集合。如C语言中的整型、实型、字符型等。整型值的范围(对具体机器都应有整数...抽象数据类型的定义仅取决于它的逻辑特性,而与其在计算机内部如何表
  • 抽象:描述数据类型的方法不依赖于具体实现 与存放数据的机器无关 与数据存储的物理结构无关 与实现操作的算法和编程语言均无关 只描述数据对象及和相关操作集“是什么”,并不涉及“如何做到”的问题 ElementType ...
  • 数据类型 例如C语言中:提供 int,char,float,double 等数据类型;数组,结构,共用体,枚举等构造数据类型;还有指针,空(viod)类型。...抽象数据类型的定义格式如下: ADT 抽象数据类型名{ 数据对象:<数
  • 抽象数据类型的实例

    2020-03-20 15:21:38
    重新学习数据结构,主要了解了一些关于数据结构的一些相关的概念; 数据结构是一种带结构的数据集合;它包括逻辑结构还有存储结构,然后学习了一下数据类型的表示以及实现...抽象数据类型的定义仅仅取决于它的一组逻...
  • 如何理解数据结构中的抽象数据类型

    万次阅读 多人点赞 2018-09-04 18:49:23
    抽象数据类型的标准格式 ADT 抽象数据类型名 { Data: 数据元素之间逻辑关系的定义;...抽象数据类型的定义仅仅取决于它的一组逻辑特性,而与它在计算机中的表示和实现无关。 例如,int类型的数据表示的...
  • 定义抽象数据类型

    2017-11-07 21:23:00
    对于抽象数据类型来说,我们通过它接口来使用它对象而不知道这个类有哪些数据成员。与之相反,若一个类允许他用户直接访问他数据成员,并且要求由用户来编写操作,则这个类不是一个抽象数据类型。 设计...
  • 二叉树的抽象数据类型定义

    千次阅读 2019-08-29 16:22:23
    数据对象集:一个有穷结点集合。 若不为空,则由根结点和其左、右二叉子树组成。 操作集: BT ∈ BinTree, Item ∈ElementType,重要操作有: 1、Boolean IsEmpty( BinTree BT ): 判别BT是否为空; 2、void ...
  • 就数据结构中的struct来说,其是定义抽象数据结构类型的重要手段,但是在看书的... 首先紧跟struct之后的肯定是该抽象数据类型的名称,类比于"int',若无typedef,则在结尾处分号之前的activity就类比于a,b[100],属于
  • 下面 一个基本的二叉树抽象数据类型的定义: ADT BinTree: # 一个二叉树抽象数据类型 BinTree(self, data, left, right) # 构造操作,创建一个新二叉树 is_empty(self) # 判断self是否为一个空二叉树
  • 基本要求: 设计实现抽象数据类型“三元组”,要求动态分配内存。每个三元组由任意三个实数的序列构成,基本操作包括:创建一个三元组,取三元组...//(1)写出抽象数据类型的定义,即数据对象、数据关系、基本操作 //
  • 数据对象:D={ai|ai=ElemSet,i=1,2,..,n,n≥0} 数据关系:R1={<ai-1,ai>|ai-1,ai∈D,i=2,...,n} 基本操作: IniList(&L) 操作结果:构造一个新线性表L。 DestroyList(&L) 操作结果:销毁...
  • 抽象数据类型三元组的定义

    千次阅读 2019-07-20 22:28:47
    抽象数据类型三元组的定义 #include <stdio.h> #include <stdlib.h> //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<&...
  • 数据元素具有相同类型,相邻元素具有先驱和后继关系 operation InitList 输入:无 功能:线性表初始化 输出:空线性表 CreatList 输入:n个数据元素 功能:建立一个线性表 输出:具有n个元素线性表 ...
  • 抽象数据类型ADT

    2018-11-26 15:32:36
    抽象数据类型的定义 ADT 抽象数据类型名{ 数据对象: 数据关系: 基本操作: 构造操作(&amp;amp;amp;L) 销毁操作(&amp;amp;amp;L) 加工型操作(&amp;amp;amp;L) 引用型操作(L) }ADT ...
  • 一、线性表的定义 由n(n>=0)个数据特性相同的元素构成的有限序列称为线性表。 线性表中元素的个数n(n>=0)定义为线性表的长度,n=0时线性表称为空表。 二、非空线性表及线性结构的特点 1、存在唯一的一个被称为...
  • 线性表的抽象数据类型定义

    千次阅读 2018-03-22 11:18:17
     //返回第i个数据元素值(返回类型可能不同) public int indexOf(Object obj); //第一个与obj满足关系equals()数据元素位序。若这样的数据元素不存在,则返回值为-1(obj的类型根据实际不同)  public ...
  • 数据结构-抽象数据类型

    千次阅读 2017-12-19 14:19:27
    抽象数据类型的定义可以由一种数据结构和定义在其上的一组操作组成,数据结构又包括数据元素以及元素之间的关系。因此抽象数据元素类型一般由元素、关系及操作三种元素来定义。(D,R,P) D 是数据对象、R是D上的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,274
精华内容 3,709
关键字:

抽象数据类型的定义