En Abstrakt datatyp (ADT) är en konceptuell modell som definierar en uppsättning operationer och beteenden för en datastruktur utan att specificera hur dessa operationer genomförs eller hur data är organiserad i minnet. Definitionen av ADT nämner bara vad operationer ska utföras men inte hur dessa operationer kommer att genomföras. Den specificerar inte hur data kommer att organiseras i minnet och vilka algoritmer som kommer att användas för att implementera operationerna. Det kallas "abstrakt" eftersom det ger en implementeringsoberoende vy.

Processen att tillhandahålla endast det väsentliga och dölja detaljerna kallas abstraktion.

Funktioner i ADT

Abstrakta datatyper (ADT) är ett sätt att kapsla in data och operationer på dessa data i en enda enhet. Några av nyckelfunktionerna i ADT inkluderar:

• Abstraktion: Användaren behöver inte känna till implementeringen av datastrukturen, bara väsentligheter tillhandahålls.
• Bättre konceptualisering: ADT ger oss en bättre konceptualisering av den verkliga världen.
• Robust: Programmet är robust och har förmågan att fånga upp fel.
• Inkapsling : ADT:er döljer datas interna detaljer och tillhandahåller ett offentligt gränssnitt för användare att interagera med data. Detta möjliggör enklare underhåll och modifiering av datastrukturen.
• Dataabstraktion : ADT ger en abstraktionsnivå från implementeringsdetaljerna för data. Användare behöver bara veta vilka operationer som kan utföras på data, inte hur dessa operationer implementeras.
• Datastrukturoberoende : ADT:er kan implementeras med hjälp av olika datastrukturer såsom arrayer eller länkade listor utan att påverka ADT:s funktionalitet.
• Döljer information: ADT:er kan skydda dataintegriteten genom att endast tillåta åtkomst till auktoriserade användare och operationer. Detta hjälper till att förhindra fel och missbruk av data.
• Modularitet : ADT kan kombineras med andra ADT för att bilda större och mer komplexa datastrukturer. Detta möjliggör större flexibilitet och modularitet vid programmering.

Övergripande ADT ger ett kraftfullt verktyg för att organisera och manipulera data på ett strukturerat och effektivt sätt.

Den här bilden visar hur en abstrakt datatyp (ADT) döljer interna datastrukturer (som arrayer länkade listor) med hjälp av offentliga och privata funktioner som endast exponerar ett definierat gränssnitt för applikationsprogrammet.

Varför använda ADT?

De viktigaste skälen till att använda ADT i Java listas nedan:

• Inkapsling: Döljer komplexa implementeringsdetaljer bakom ett rent gränssnitt.
• Återanvändbarhet : Tillåter olika interna implementeringar (t.ex. array eller länkad lista) utan att ändra extern användning.
• Modularitet: Förenklar underhåll och uppdateringar genom att separera logik.
• Säkerhet: Skyddar data genom att förhindra direktåtkomst och minimerar buggar och oavsiktliga ändringar.

Exempel på abstraktion

Till exempel använder vi primitiva värden som int float och char med insikten att dessa datatyper kan arbeta och utföras på utan någon kunskap om deras implementeringsdetaljer. ADT fungerar på liknande sätt genom att definiera vilka operationer som är möjliga utan att detaljera deras genomförande.

Skillnaden mellan ADT och UDT

Tabellen nedan visar skillnaden mellan ADT och UDT.

javascript onload script

Exempel på ADT

Låt oss nu förstå tre vanliga ADT:er: List ADT Stack ADT och Queue ADT.

1. Lista ADT

List ADT (Abstract Data Type) är en sekventiell samling av element som stöder en uppsättning operationer utan att specificera det interna genomförandet . Det ger ett ordnat sätt att lagra åtkomst och ändra data.

Operationer:

List ADT behöver lagra de nödvändiga data i sekvensen och bör ha följande operationer :

• få(): Returnera ett element från listan vid en given position.
• infoga(): Infoga ett element på valfri plats i listan.
• ta bort(): Ta bort den första förekomsten av ett element från en icke-tom lista.
• removeAt(): Ta bort elementet på en angiven plats från en icke-tom lista.
• ersätta(): Byt ut ett element på valfri plats med ett annat element.
• storlek(): Returnera antalet element i listan.
• isEmpty(): Returnera sant om listan är tom; annars returnerar false.
• ärFull(): Returnera sant om listan är full annars returneras falskt. Endast tillämpligt i implementeringar med fast storlek (t.ex. arraybaserade listor).

2. Stapla ADT

Stack ADT är en linjär datastruktur som följer LIFO-principen (Last In First Out). Det gör att element kan läggas till och tas bort endast från ena änden som kallas toppen av stapeln.

Operationer:

I Stack ADT bör ordningen för infogning och radering vara enligt FILO- eller LIFO-principen. Element sätts in och tas bort från samma ände som kallas toppen av stapeln. Det bör också stödja följande operationer:

• tryck(): Infoga ett element i ena änden av stapeln som kallas toppen.
• pop(): Ta bort och returnera elementet överst i högen om det inte är tomt.
• titt(): Lägg tillbaka elementet överst i högen utan att ta bort det om högen inte är tom.
• storlek(): Returnera antalet element i stacken.
• isEmpty(): Returnera sant om stacken är tom; annars returnerar false.
• ärFull(): Returnera sant om stacken är full; annars returnerar false. Endast relevant för stackar med fast kapacitet (t.ex. array-baserade).

3. Kö ADT

Queue ADT är en linjär datastruktur som följer FIFO-principen (First In First Out). Det gör att element kan sättas in i ena änden (bak) och tas bort från den andra änden (framtill).

Operationer:

Queue ADT följer en design som liknar Stack ADT men ordningen för infogning och radering ändras till FIFO. Elementen sätts in i ena änden (kallas baksidan) och tas bort från den andra änden (kallas framsidan). Det bör stödja följande operationer:

java tecken till sträng

• kö(): Infoga ett element i slutet av kön.
• följaktligen(): Ta bort och returnera det första elementet i kön om kön inte är tom.
• titt(): Returnera elementet i kön utan att ta bort det om kön inte är tom.
• storlek(): Returnera antalet element i kön.
• isEmpty(): Returnera sant om kön är tom; annars returnerar false.

Fördelar och nackdelar med ADT

Abstrakta datatyper (ADT) har flera fördelar och nackdelar som bör beaktas när man bestämmer sig för att använda dem i mjukvaruutveckling. Här är några av de viktigaste fördelarna och nackdelarna med att använda ADT:

Fördel:

Fördelarna är listade nedan:

• Inkapsling : ADT ger ett sätt att kapsla in data och operationer i en enda enhet vilket gör det lättare att hantera och modifiera datastrukturen.
• Abstraktion : ADT:er tillåter användare att arbeta med datastrukturer utan att behöva känna till implementeringsdetaljerna, vilket kan förenkla programmering och minska fel.
• Datastrukturoberoende : ADT kan implementeras med hjälp av olika datastrukturer som kan göra det lättare att anpassa sig till förändrade behov och krav.
• Döljer information : ADT:er kan skydda dataintegriteten genom att kontrollera åtkomst och förhindra obehöriga ändringar.
• Modularitet : ADT:er kan kombineras med andra ADT:er för att bilda mer komplexa datastrukturer som kan öka flexibiliteten och modulariteten i programmering.

Nackdelar:

Nackdelarna är listade nedan:

• Över huvudet : Implementering av ADT kan lägga till overhead i termer av minne och bearbetning, vilket kan påverka prestandan.
• Komplexitet : ADT:er kan vara komplexa att implementera speciellt för stora och komplexa datastrukturer.
• Inlärning Kurva: Att använda ADT kräver kunskap om deras implementering och användning, vilket kan ta tid och ansträngning att lära sig.
• Begränsad flexibilitet: Vissa ADT:er kan vara begränsade i sin funktionalitet eller kanske inte är lämpliga för alla typer av datastrukturer.
• Kosta : Implementering av ADT kan kräva ytterligare resurser och investeringar som kan öka kostnaderna för utveckling.