An Abstrakt datatype (ADT) er en konceptuel model, der definerer et sæt operationer og adfærd for en datastruktur uden at specificere, hvordan disse operationer implementeres eller hvordan data er organiseret i hukommelsen. Definitionen af ​​ADT nævner kun hvad operationer skal udføres men ikke hvordan disse operationer vil blive gennemført. Det specificerer ikke, hvordan data vil blive organiseret i hukommelsen, og hvilke algoritmer der vil blive brugt til at implementere operationerne. Det kaldes 'abstrakt', fordi det giver et implementeringsuafhængigt syn.

Processen med kun at levere det væsentlige og skjule detaljerne er kendt som abstraktion.

Funktioner af ADT

Abstrakte datatyper (ADT'er) er en måde at indkapsle data og operationer på disse data i en enkelt enhed. Nogle af nøglefunktionerne ved ADT'er inkluderer:

• Abstraktion: Brugeren behøver ikke at kende implementeringen af ​​datastrukturen, kun væsentlige er tilvejebragt.
• Bedre konceptualisering: ADT giver os en bedre konceptualisering af den virkelige verden.
• Robust: Programmet er robust og har evnen til at fange fejl.
• Indkapsling : ADT'er skjuler de interne detaljer i dataene og giver en offentlig grænseflade, så brugerne kan interagere med dataene. Dette giver mulighed for lettere vedligeholdelse og ændring af datastrukturen.
• Dataabstraktion : ADT'er giver et niveau af abstraktion fra implementeringsdetaljerne i dataene. Brugere behøver kun at kende de operationer, der kan udføres på dataene, ikke hvordan disse operationer implementeres.
• Datastrukturuafhængighed : ADT'er kan implementeres ved hjælp af forskellige datastrukturer såsom arrays eller sammenkædede lister uden at påvirke ADT'ens funktionalitet.
• Informationsskjul: ADT'er kan beskytte integriteten af ​​dataene ved kun at tillade adgang til autoriserede brugere og operationer. Dette hjælper med at forhindre fejl og misbrug af dataene.
• Modularitet : ADT'er kan kombineres med andre ADT'er for at danne større mere komplekse datastrukturer. Dette giver mulighed for større fleksibilitet og modularitet i programmeringen.

Overordnede ADT'er giver et kraftfuldt værktøj til at organisere og manipulere data på en struktureret og effektiv måde.

Dette billede demonstrerer, hvordan en abstrakt datatype (ADT) skjuler interne datastrukturer (som array-linkede lister) ved hjælp af offentlige og private funktioner, der kun udsætter en defineret grænseflade til applikationsprogrammet.

Hvorfor bruge ADT'er?

De vigtigste grunde til at bruge ADT'er i Java er anført nedenfor:

• Indkapsling: Skjuler komplekse implementeringsdetaljer bag en ren grænseflade.
• Genanvendelighed : Tillader forskellige interne implementeringer (f.eks. array eller linket liste) uden at ændre ekstern brug.
• Modularitet: Forenkler vedligeholdelse og opdateringer ved at adskille logik.
• Sikkerhed: Beskytter data ved at forhindre direkte adgang og minimerer fejl og utilsigtede ændringer.

Eksempel på abstraktion

For eksempel bruger vi primitive værdier som int float og char med den forståelse, at disse datatyper kan fungere og udføres på uden nogen viden om deres implementeringsdetaljer. ADT'er fungerer på samme måde ved at definere hvilke operationer der er mulige uden at detaljere deres implementering.

Forskellen mellem ADT'er og UDT'er

Tabellen nedenfor viser forskellen mellem ADT'er og UDT'er.

amplitudemodulation

Eksempler på ADT'er

Lad os nu forstå tre almindelige ADT'er: List ADT Stack ADT og Queue ADT.

1. List ADT

List ADT (Abstract Data Type) er en sekventiel samling af elementer, der understøtter et sæt operationer uden at specificere den interne implementering . Det giver en ordnet måde at gemme adgang og ændre data på.

Operationer:

List ADT skal gemme de nødvendige data i rækkefølgen og bør have følgende operationer :

• få(): Returner et element fra listen på en given position.
• indsæt(): Indsæt et element på en hvilken som helst position på listen.
• fjerne(): Fjern den første forekomst af ethvert element fra en ikke-tom liste.
• removeAt(): Fjern elementet på et bestemt sted fra en ikke-tom liste.
• erstatte(): Udskift et element på en hvilken som helst position med et andet element.
• størrelse(): Returner antallet af elementer på listen.
• er tom(): Returner sand, hvis listen er tom; ellers returner falsk.
• er fuld(): Returner sand, hvis listen er fuld, ellers returneres falsk. Kun anvendelig i implementeringer med fast størrelse (f.eks. array-baserede lister).

2. Stable ADT

Stack ADT er en lineær datastruktur, der følger LIFO-princippet (Last In First Out). Det tillader kun at tilføje og fjerne elementer fra den ene ende kaldet toppen af ​​stakken.

Operationer:

I Stack ADT skal rækkefølgen af ​​indsættelse og sletning være i overensstemmelse med FILO- eller LIFO-princippet. Elementer indsættes og fjernes fra den samme ende kaldet toppen af ​​stakken. Det bør også understøtte følgende operationer:

• skubbe(): Indsæt et element i den ene ende af stakken kaldet toppen.
• pop(): Fjern og returner elementet i toppen af ​​stakken, hvis det ikke er tomt.
• kig(): Returner elementet i toppen af ​​stakken uden at fjerne det, hvis stakken ikke er tom.
• størrelse(): Returner antallet af elementer i stakken.
• er tom(): Returner true, hvis stakken er tom; ellers returner falsk.
• er fuld(): Returner sand, hvis stakken er fuld; ellers returner falsk. Kun relevant for stakke med fast kapacitet (f.eks. array-baserede).

3. Kø ADT

Queue ADT er en lineær datastruktur, der følger FIFO-princippet (First In First Out). Det gør det muligt at indsætte elementer i den ene ende (bag) og fjerne fra den anden ende (for).

Operationer:

Kø-ADT følger et design, der ligner Stack ADT, men rækkefølgen for indsættelse og sletning ændres til FIFO. Elementer indsættes i den ene ende (kaldet bagsiden) og fjernes fra den anden ende (kaldes forsiden). Det skal understøtte følgende operationer:

streng af længde

• kø(): Indsæt et element i slutningen af ​​køen.
• derfor(): Fjern og returner det første element i køen, hvis køen ikke er tom.
• kig(): Returner elementet i køen uden at fjerne det, hvis køen ikke er tom.
• størrelse(): Returner antallet af elementer i køen.
• er tom(): Returner true, hvis køen er tom; ellers returner falsk.

Fordele og ulemper ved ADT

Abstrakte datatyper (ADT'er) har flere fordele og ulemper, som bør overvejes, når man beslutter sig for at bruge dem i softwareudvikling. Her er nogle af de vigtigste fordele og ulemper ved at bruge ADT'er:

Fordel:

Fordelene er angivet nedenfor:

• Indkapsling : ADT'er giver en måde at indkapsle data og operationer i en enkelt enhed, hvilket gør det nemmere at administrere og ændre datastrukturen.
• Abstraktion : ADT'er giver brugerne mulighed for at arbejde med datastrukturer uden at skulle kende implementeringsdetaljerne, hvilket kan forenkle programmering og reducere fejl.
• Datastrukturuafhængighed : ADT'er kan implementeres ved hjælp af forskellige datastrukturer, som kan gøre det lettere at tilpasse sig skiftende behov og krav.
• Informationsskjul : ADT'er kan beskytte integriteten af ​​data ved at kontrollere adgangen og forhindre uautoriserede ændringer.
• Modularitet : ADT'er kan kombineres med andre ADT'er for at danne mere komplekse datastrukturer, som kan øge fleksibiliteten og modulariteten i programmering.

Ulemper:

Ulemperne er angivet nedenfor:

• Overhead : Implementering af ADT'er kan tilføje overhead med hensyn til hukommelse og behandling, hvilket kan påvirke ydeevnen.
• Kompleksitet : ADT'er kan være komplekse at implementere især for store og komplekse datastrukturer.
• Læring Kurve: Brug af ADT'er kræver viden om deres implementering og brug, hvilket kan tage tid og kræfter at lære.
• Begrænset fleksibilitet: Nogle ADT'er kan være begrænset i deres funktionalitet eller er muligvis ikke egnede til alle typer datastrukturer.
• Koste : Implementering af ADT'er kan kræve yderligere ressourcer og investeringer, som kan øge udviklingsomkostningerne.