Ik studeer momenteel over abstracte gegevenstypen (ADT’s), maar ik begrijp het concept helemaal niet. Kan iemand mij uitleggen wat dit eigenlijk is? Ook wat is collectie, tas en lijst ADT? in simpele termen?

Antwoord 1, autoriteit 100%

Abstract gegevenstype (ADT) is een gegevenstype, waarbij alleen gedrag wordt gedefinieerd, maar niet de implementatie.

Tegenovergestelde van ADT staat Concrete Data Type (CDT), waar het een implementatie van ADT bevat.

Voorbeelden:
Array, List, Map, Queue, Set, Stack, Table, Tree, and Vector zijn ADT’s. Elk van deze ADT’s heeft veel implementaties, d.w.z. CDT. De container is een ADT op hoog niveau van vooral ADT’s.

Voorbeeld uit de praktijk:
boek is Abstract (Telefoonboek is een implementatie)

Antwoord 2, autoriteit 19%

Het Abstracte gegevenstype Wikipedia-artikel heeft veel te zeggen.

In de informatica is een abstract datatype (ADT) een wiskundig model voor een bepaalde klasse van datastructuren die vergelijkbaar gedrag vertonen; of voor bepaalde gegevenstypen van een of meer programmeertalen die vergelijkbare semantiek hebben. Een abstract gegevenstype wordt indirect gedefinieerd, alleen door de bewerkingen die erop kunnen worden uitgevoerd en door wiskundige beperkingen op de effecten (en mogelijk kosten) van die bewerkingen.

In iets meer concrete termen kun je Java’s gebruiken List interface als voorbeeld. De interface definieert helemaal geen gedrag expliciet omdat er geen concrete List-klasse is. De interface definieert alleen een set methoden die andere klassen (bijv. ArrayList en LinkedList) moet worden geïmplementeerd om als een List te worden beschouwd.

Een verzameling is een ander abstract gegevenstype. In het geval van Java’s Collection -interface, het is zelfs abstracter dan List, aangezien

De List-interface plaatst aanvullende bepalingen, naast die gespecificeerd in de Collection-interface, in de contracten van de iterator, add, remove, equals en hashCode methoden.

Een tas staat ook bekend als een multiset.

In de wiskunde is het begrip multiset (of zak) een veralgemening van het begrip verzameling waarin leden meer dan één keer mogen voorkomen. Er is bijvoorbeeld een unieke set die de elementen a en b bevat en geen andere, maar er zijn veel multisets met deze eigenschap, zoals de multiset die twee exemplaren van a en één van b bevat of de multiset die drie exemplaren van bevat zowel a als b.

In Java zou een tas een verzameling zijn die een zeer eenvoudige interface implementeert. U hoeft alleen items aan een tas toe te voegen, de grootte te controleren en de items die erin zitten te herhalen. Zie Bag.java voor een voorbeeldimplementatie (van Sedgewick & Wayne’s Algoritmen 4e editie).

Antwoord 3, autoriteit 3%

Een echt abstract gegevenstype beschrijft de eigenschappen van zijn instanties zonder verplichting tot hun weergave of specifieke bewerkingen. Het abstracte (wiskundige) type Integer is bijvoorbeeld een discrete, onbeperkte, lineair geordende reeks instanties. Een concreet type geeft een specifieke weergave voor instanties en implementeert een specifieke reeks bewerkingen.

Antwoord 4, autoriteit 3%

Eigenlijk abstracte gegevenstypen zijn:

• Concepten of theoretisch model dat een gegevenstype logisch definieert
• Specificeert een reeks gegevens en een reeks bewerkingen die op die gegevens kunnen worden uitgevoerd
• Vermeldt niets over hoe operaties zullen worden geïmplementeerd
• “Bestaat als een idee, maar heeft geen fysiek idee”

Laten we bijvoorbeeld de specificaties van enkele abstracte gegevenstypen bekijken,

1. Lijst met abstract gegevenstype: initialize(), get(), insert(), remove(), etc.
2. Abstract gegevenstype stapelen: push(), pop(), peek(), isEmpty(), isNull(), etc.
3. Queue Abstract Data Type: enqueue(), dequeue(), size(), peek(), etc.

Antwoord 5, autoriteit 2%

Een van de eenvoudigste uitleg op de wiki van Brilliant:

Abstracte gegevenstypen, gewoonlijk afgekort ADT’s, zijn een manier om
classificeren van datastructuren op basis van hoe ze worden gebruikt en de
gedrag dat ze bieden. Ze specificeren niet hoe de gegevensstructuur
moet worden geïmplementeerd of in het geheugen worden vastgelegd, maar geef gewoon een
minimaal verwachte interface en reeks gedragingen. Bijvoorbeeld een stapel
is een abstract datatype dat een lineaire datastructuur specificeert met
LIFO-gedrag (last in, first out). Stacks worden vaak geïmplementeerd
met behulp van arrays of gekoppelde lijsten, maar een onnodig ingewikkelde
implementatie met behulp van een binaire zoekboom is nog steeds geldig
implementatie. Voor alle duidelijkheid, het is onjuist om te zeggen dat stapels zijn
arrays of omgekeerd. Een array kan als stapel worden gebruikt. Evenzo, een
stack kan worden geïmplementeerd met behulp van een array.

Aangezien abstracte gegevenstypen geen implementatie specificeren, betekent dit:
het is ook onjuist om te praten over de tijdscomplexiteit van een gegeven
abstract gegevenstype. Een associatieve array kan al dan niet O (1) hebben
gemiddelde zoektijden. Een associatieve array die wordt geïmplementeerd door a
hash-tabel heeft O(1) gemiddelde zoektijden.

Voorbeeld voor ADT: Lijst – kan worden geïmplementeerd met behulp van Array en LinkedList, Queue, Deque, Stack, Associative array, Set.

https://brilliant.org/wiki/abstract-data-types/?subtopic=types-and-data-structures&chapter=abstract-data-types

Antwoord 6

ADT zijn een reeks gegevenswaarden en bijbehorende bewerkingen die precies onafhankelijk zijn van een bepaalde implementatie. De kracht van een ADT is dat de implementatie verborgen is voor de gebruiker. Alleen de interface wordt gedeclareerd. Dit betekent dat de ADT op verschillende manieren kan.

Antwoord 7

Abstract gegevenstype is een wiskundige module die gegevens met verschillende bewerkingen bevat. Uitvoeringsdetails zijn verborgen en daarom wordt het abstract genoemd. Met abstractie kon je de complexiteit van de taak organiseren door je te concentreren op logische eigenschappen van gegevens en acties.

Antwoord 8

In programmeertalen is een type een aantal gegevens en de bijbehorende bewerkingen. Een ADT is een door de gebruiker gedefinieerde gegevensaggregaat en de bewerkingen over deze gegevens en wordt gekenmerkt door inkapseling, de gegevens en bewerkingen worden weergegeven, of in een lijst gedeclareerd, in een enkele syntactische eenheid, en informatie verbergen, alleen de relevante bewerkingen zijn zichtbaar voor de gebruiker van de ADT, de ADT interface, op dezelfde manier als een normaal gegevenstype in de programmeertaal. Het is een abstractie omdat de interne representatie van de gegevens en de uitvoering van de bewerkingen niet van belang zijn voor de ADT-gebruiker.

Antwoord 9

Notatie van Abstract Data Type (ADT)

Een abstract gegevenstype kan worden gedefinieerd als een wiskundig model met a
verzameling bewerkingen die erop zijn gedefinieerd. Een eenvoudig voorbeeld is de set van
gehele getallen samen met de operaties van unie, intersectie gedefinieerd
op de set.

De ADT’s zijn generalisaties van het primitieve gegevenstype (integer, char
enz.) en ze kapselen een gegevenstype in in de zin dat de definitie
van het type en alle bewerkingen op dat type gelokaliseerd in één sectie
van het programma. Ze worden behandeld als een primitief gegevenstype buiten de
sectie waarin de ADT en zijn bewerkingen worden gedefinieerd.

Een implementatie van een ADT is de vertaling in statements van
een programmeertaal van de declaratie die een variabele definieert om
van die ADT zijn, plus een procedure in die taal voor elk
werking van die ADT. De implementatie van de ADT kiest voor een
gegevensstructuur om de ADT weer te geven.

Een handig hulpmiddel voor het specificeren van de logische eigenschappen van het gegevenstype is
het abstracte gegevenstype. Fundamenteel is een gegevenstype een verzameling van:
waarden en een reeks bewerkingen op die waarden. Die collectie en
die bewerkingen vormen een wiskundige constructie die kan worden geïmplementeerd
met behulp van een bepaalde hardware- en softwaregegevensstructuur. De voorwaarde
“abstract gegevenstype” verwijst naar het wiskundige basisconcept dat het gegevenstype definieert.

Bij het definiëren van een abstract gegevenstype als wiskundig concept, doen we dat niet
bezig met ruimte- of tijdefficiëntie. Dat zijn implementatie
probleem. In feite houdt de definitie van ADT zich niet bezig met:
uitvoeringsdetails helemaal niet. Het is misschien niet eens mogelijk om te implementeren
een bepaalde ADT op een bepaald stuk hardware of met behulp van een
bepaald softwaresysteem. We hebben bijvoorbeeld al gezien dat een
ADT geheel getal is niet universeel implementeerbaar.

Om het concept van een ADT en mijn specificatiemethode te illustreren,
overweeg de ADT RATIONAL die overeenkomt met de wiskundige
concept van een rationaal getal. Een rationaal getal is een getal dat kan
uitgedrukt worden als het quotiënt van twee gehele getallen. De operaties op
rationale getallen die, we definiëren, het creëren van een rationaal getal zijn
van twee gehele getallen, optellen, vermenigvuldigen en testen op gelijkheid.
Het volgende is een eerste specificatie van deze ADT.

                  /* Value defination */
abstract typedef <integer, integer> RATIONAL;
condition RATIONAL [1]!=0;
                 /*Operator defination*/
abstract RATIONAL makerational (a,b)
int a,b;
preconditon b!=0;
postcondition makerational [0] =a;
              makerational [1] =b;
abstract RATIONAL add [a,b]
RATIONAL a,b;
postcondition add[1] = = a[1] * b[1]
              add[0] = a[0]*b[1]+b[0]*a[1]
abstract RATIONAL mult [a, b]
RATIONAL a,b;
postcondition mult[0] = = a[0]*b[a]
              mult[1] = = a[1]*b[1]
abstract equal (a,b)
RATIONAL a,b;
postcondition equal = = |a[0] * b[1] = = b[0] * a[1];

Een ADT bestaat uit twee delen:-

1) Waardedefinitie

2) Bewerkingsdefinitie

1) Waardedefinitie:-

De waardedefinitie definieert de verzameling waarden voor de ADT en
bestaat uit twee delen:

1) Definitieclausule

2) Voorwaardeclausule

Bijvoorbeeld, de waardedefinitie voor de ADT RATIONAL stelt dat:
een RATIONELE waarde bestaat uit twee gehele getallen, waarvan de tweede niet
niet gelijk aan 0.

Het trefwoord abstract typedef introduceert een waardedefinitie en de
sleutelwoordvoorwaarde wordt gebruikt om eventuele voorwaarden op de nieuw
gedefinieerd gegevenstype. In deze definitie specificeert de voorwaarde dat de
noemer mag niet 0 zijn. De definitieclausule is vereist, maar de
voorwaarde is mogelijk niet nodig voor elke ADT.

2) Operatordefinitie:-

Elke operator wordt gedefinieerd als een abstract kruispunt met drie delen.

1)Koptekst

2)Optionele voorwaarden

3)Optionele postvoorwaarden

De operatordefinitie van de ADT RATIONAL omvat bijvoorbeeld de
bewerkingen van creatie (makerationeel), toevoeging (toevoegen) en
vermenigvuldiging (mult) en een test voor gelijkheid (gelijk). Laat ons
overweeg eerst de specificatie voor vermenigvuldiging, want het is de
eenvoudigste. Het bevat een header en post-voorwaarden, maar nee
voorwaarden.

abstract RATIONAL mult [a,b]
RATIONAL a,b;
postcondition mult[0] = a[0]*b[0]
              mult[1] = a[1]*b[1]

De kop van deze definitie zijn de eerste twee regels, die gewoon
zoals een C-functieheader. Het trefwoord abstract geeft aan dat het is
geen C-functie maar een ADT-operatordefinitie.

De post-conditie specificeert wat de operatie doet. In een
post-condition, wordt de naam van de functie (in dit geval mult) gebruikt
om het resultaat van een operatie aan te duiden. Dus, multi [0] vertegenwoordigt
teller van resultaat en mult 1 staat voor de noemer van de
resultaat. Dat is het specificeert, welke voorwaarden waar worden na de
operatie wordt uitgevoerd. In dit voorbeeld specificeert de post-conditie
dat de neumerator van het resultaat van een rationale vermenigvuldiging gelijk is aan
geheel getal product van tellers van de twee ingangen en de noemer
is gelijk aan het gehele product van twee noemers.

Lijst

In de informatica is een lijst of volgorde een abstract gegevenstype dat
staat voor een telbaar aantal geordende waarden, waarbij dezelfde waarde
kan meer dan eens voorkomen. Een exemplaar van een lijst is een computer
weergave van het wiskundige concept van een eindige reeks; de
(potentieel) oneindige analoog van een lijst is een & nbsp;stream. & nbsp; Lijsten zijn een basis
voorbeeld van  containers, omdat ze andere waarden bevatten. Als dezelfde waarde
meerdere keren voorkomt, wordt elke gebeurtenis als een afzonderlijk item beschouwd

De namenlijst wordt ook gebruikt voor verschillende concrete datastructuren die:
kan worden gebruikt om abstracte lijsten te implementeren, vooral gekoppelde lijsten.

Afbeelding van een lijst

Tas

Een tas is een verzameling objecten waaraan je objecten kunt blijven toevoegen
de tas, maar je kunt ze niet verwijderen als ze eenmaal aan de tas zijn toegevoegd. Dus met een
tas-gegevensstructuur, u kunt alle objecten verzamelen en vervolgens herhalen
door hen. U zult normaal gesproken zakken als u in Java programmeert.

Afbeelding van een tas

Verzameling

Een verzameling in Java-zin verwijst naar elke klasse die de . implementeert
Collectie-interface. Een verzameling in generieke zin is slechts een groep
van objecten.

Afbeelding van collecties

Antwoord 10

Laten we, voordat we abstracte gegevenstypen definiëren, eens kijken naar de verschillende
weergave van door het systeem gedefinieerde gegevenstypen. Dat weten we allemaal standaard allemaal
primitieve gegevenstypen (int, float, etc.) ondersteunen basisbewerkingen zoals:
als optellen en aftrekken. Het systeem zorgt voor de implementaties
voor de primitieve datatypes. Voor door de gebruiker gedefinieerde gegevenstypen hebben we ook:
operaties moeten definiëren. De implementatie voor deze operaties kan:
worden gedaan wanneer we ze daadwerkelijk willen gebruiken. Dat betekent in het algemeen,
door de gebruiker gedefinieerde gegevenstypen worden gedefinieerd samen met hun bewerkingen.

Om het proces van het oplossen van problemen te vereenvoudigen, combineren we de gegevens
structuren met hun operaties en we noemen dit “Abstracte gegevens
Typ”. (ADT’s).

Veelgebruikte ADT’S zijn: gekoppelde lijst, stapels, wachtrijen, binaire structuur,
Woordenboeken, Disjoint Sets (Union en find), Hash Tables en veel
anderen.

ADT’s bestaan ​​uit twee soorten:

1. Verklaring van gegevens.

2. Verklaring van werking.

Antwoord 11

Gewoon abstract gegevenstype is niets anders dan een reeks bewerkingen en een reeks gegevens wordt gebruikt om andere gegevens efficiënt in de machine op te slaan.
Er is geen perticulaire typeverklaring nodig.
Het vereist alleen een implementatie van ADT.

Antwoord 12

Om problemen op te lossen combineren we de datastructuur met hun operaties. Een ADT bestaat uit twee delen:

1. Verklaring van gegevens.
2. Verklaring van operatie.

Veelgebruikte ADT’s zijn gekoppelde lijsten, stapels, wachtrijen, prioriteitswachtrijen, bomen enz. Bij het definiëren van ADT’s hoeven we ons geen zorgen te maken over implementatiedetails. Ze komen alleen in beeld als we ze willen gebruiken.

Antwoord 13

Abstract gegevenstype zijn als door de gebruiker gedefinieerd gegevenstype waarop we functies kunnen uitvoeren zonder te weten wat er in het gegevenstype zit en hoe de bewerkingen erop worden uitgevoerd. Omdat de informatie niet wordt blootgesteld, wordt deze geabstraheerd. bijv. Lijst, matrix, stapel, wachtrij. Op Stack kunnen we functies uitvoeren zoals Push, Pop, maar we weten niet zeker hoe het achter de gordijnen wordt geïmplementeerd.

Antwoord 14

ADT is een verzameling objecten en bewerkingen, nergens in de definities van een ADT wordt vermeld hoe de verzameling bewerkingen wordt geïmplementeerd. Programmeurs die verzamelingen gebruiken, hoeven alleen te weten hoe ze gegevens moeten instantiëren en openen op een vooraf bepaalde manier, zonder zich zorgen te maken over de details van de implementaties van de verzamelingen. Met andere woorden, vanuit het perspectief van de gebruiker is een verzameling een abstractie, en om deze reden worden in de informatica sommige verzamelingen abstracte datatypes (ADT’s) genoemd. De gebruiker houdt zich alleen bezig met het leren van de interface of de reeks bewerkingen die het uitvoert…meer

Antwoord 15

in een eenvoudig woord: een abstract gegevenstype is een verzameling gegevens en bewerkingen die op die gegevens werken. De bewerkingen beschrijven beide de gegevens voor de rest van het programma en stellen de rest van het programma in staat de gegevens te wijzigen. Het woord data in abstract gegevenstype wordt losjes gebruikt. Een ADT kan een grafisch venster zijn met alle bewerkingen die erop van invloed zijn, een bestand en bestandsbewerkingen, een tabel met verzekeringstarieven en de bewerkingen erop, of iets anders.

van code 2 boek voltooien

Antwoord 16

Abstract gegevenstype is de verzameling van waarden en elke soort bewerking op deze waarden. Omdat String bijvoorbeeld geen primitief gegevenstype is, kunnen we het opnemen in abstracte gegevenstypen.

Antwoord 17

ADT is een gegevenstype waarbij het verzamelen van gegevens en bewerkingen op die gegevens werken. Het richt zich meer op het concept dan op de uitvoering.
Het is aan jou welke taal je gebruikt om het zichtbaar te maken op aarde
Voorbeeld:
Stack is een ADT, terwijl de array dat niet is
Stack is ADT omdat we het in veel talen kunnen implementeren,
Python c c++ java en nog veel meer, terwijl Array is ingebouwd in het gegevenstype

Antwoord 18

Een abstract gegevenstype, soms afgekort als ADT, is een logische beschrijving van hoe we de gegevens en de toegestane bewerkingen bekijken, ongeacht hoe ze worden geïmplementeerd. Dit betekent dat we ons alleen bezighouden met wat de gegevens vertegenwoordigen en niet met hoe ze uiteindelijk zullen worden geconstrueerd.

https://runestone.academy/runestone/books/published /pythonds/Introduction/WhyStudyDataStructuresandAbstractDataTypes.html

Antwoord 19

Abstracties geven u alleen informatie (service-informatie), maar geen implementatie.
Bijvoorbeeld: wanneer u geld gaat opnemen bij een geldautomaat, weet u maar één ding, namelijk: plaats uw geldautomaatkaart in de automaat, klik op de opnameoptie, voer het bedrag in en uw geld is op als er geld is.
Dit is alleen wat u weet over geldautomaten. Maar weet u hoe u geld ontvangt?? Welke bedrijfslogica gaat erachter schuil? Welke database wordt aangeroepen? Welke server op welke locatie wordt aangeroepen?? Nee, u weet alleen service-informatie, dat wil zeggen dat u geld kunt opnemen. Dit is een abstractie.

Evenzo geeft ADT u een overzicht van datatypes: wat ze zijn/kunnen worden opgeslagen en welke bewerkingen u op die datatypes kunt uitvoeren. Maar het geeft niet hoe je dat moet implementeren. Dit is ADT. Het definieert alleen de logische vorm van uw gegevenstypen.

Een andere analogie is:
In een auto of fiets weet je pas wanneer je de rem indrukt dat je voertuig stopt. Maar weet je hoe de fiets stopt als je op de rem drukt??? Nee, betekent dat implementatiedetails worden verborgen. Je weet alleen wat de rem doet als je indrukt, maar je weet niet hoe het werkt.

Antwoord 20

De term gegevenstype is het type gegevens dat een bepaalde variabele kan bevatten – het kan een geheel getal, een teken, een float of een willekeurig bereik van eenvoudige gegevensopslagrepresentatie zijn. Wanneer we echter een objectgeoriënteerd systeem bouwen, gebruiken we andere gegevenstypen, ook wel abstract gegevenstype genoemd, die meer realistische entiteiten vertegenwoordigen.

Bijvoorbeeld: we zijn mogelijk geïnteresseerd in het weergeven van een gegevenstype ‘bankrekening’, dat beschrijft hoe alle bankrekeningen in een programma worden verwerkt. Abstractie gaat over het verminderen van complexiteit, het negeren van onnodige details.