Tömb az adatstruktúrában: Mi az, tömbök Operaciók [Példák]

Mi az a tömb az adatszerkezetben?

An sor egy adatstruktúra több, hasonló adattípusú adatelem tárolására. Egy tömb elemei a szomszédos memóriahelyeken vannak lefoglalva. Ezeket a memóriahelyeket ún elemek abból a tömbből. Egy tömb elemeinek teljes számát hívjuk meg hossz.

A tömb részleteit a pozíciójáról érheti el. Ezt a hivatkozást ún index or alsó index.

A tömb fogalma

A fenti diagram azt szemlélteti, hogy:

A tömb elemek tárolója.
Az elemek meghatározott értékkel és adattípussal rendelkeznek, például „ABC”, TRUE vagy FALSE stb.
Minden elemnek saját indexe is van, amely az elem elérésére szolgál.

Jegyzet:

Az elemek összefüggő memóriahelyeken tárolódnak.
Egy index mindig kisebb, mint a tömbelemek teljes száma.
Szintaxis szempontjából minden tömbként deklarált változó több értéket is tárolhat.
Szinte minden nyelv azonos módon érti a tömböket, de eltérő módon deklarálják és inicializálják őket.
A három rész azonban mindig közös marad az összes inicializálásnál, azaz a tömbnév, az elemek és az elemek adattípusa.

A következő diagram az an deklarálás szintaxisát mutatja be tömb be Python és a C++ bemutatni, hogy a megértés ugyanaz marad, bár a szintaxis kissé eltérhet a különböző nyelveken.

Tömb neve: szükséges az elemek gyűjteményének egyszerű hivatkozásához
Adattípus: szükséges a típusellenőrzéshez és az adatok integritásához
elemek: ezek a tömbben lévő adatértékek

Miért van szükségünk tömbökre?

Íme néhány ok, amiért tömböket használunk az adatstruktúrában:

A tömbök a legjobbak több érték tárolására egyetlen változóban
A tömbök könnyebben és gyorsan dolgoznak fel sok értéket
A tömbökben egyszerűbb az értékek rendezése és keresése

Tömb létrehozása a ben Python

In Python, a tömbök különböznek a listáktól; a listák adattípusú tömbelemeket tartalmazhatnak, míg a tömbök csak azonos adattípusú elemeket tartalmazhatnak.

Python rendelkezik egy külön modullal a tömbök kezelésére, az úgynevezett array-t, amelyet importálni kell, mielőtt elkezdené dolgozni rajtuk.

Jegyzet: A tömbnek valós számokat kell tartalmaznia, például egész számokat és lebegőpontokat, karakterláncok nem megengedettek.

A következő kód bemutatja, hogyan hozhat létre egész számokat tartalmazó tömböt a pythonban a számlaegyenleg tárolására:

 import array
 balance = array.array('i', [300,200,100])
 print(balance)

A tömb deklarálásának módjai Python

Ebben deklarálhat egy tömböt Python miközben inicializálja a következő szintaxis használatával.

arrayName = array.array(type code for data type, [array,items])

A következő kép a szintaxist magyarázza.

Azonosító: adjon meg egy nevet, mint általában a változókhoz
Modulok: Python rendelkezik egy speciális modullal a tömbök létrehozására, az úgynevezett „tömböt” – ezt importálni kell használat előtt
Módszer: a tömbmodulnak van egy metódusa a tömb inicializálására. Két argumentumra van szükség, a típuskódra és az elemekre.
Típus kód: adja meg az adattípust a rendelkezésre álló típuskódokkal (lásd az alábbi listát)
Elemek: adja meg a tömb elemeit szögletes zárójelben, például [130,450,103]

Az alábbi táblázat a támogatott adattípusokhoz elérhető típuskódokat mutatja be:

Írja be a kódot	C Típus	Python típus	Minimális méret bájtban
'c'	faszén	karakter	1
„B”	aláíratlan char	int	1
„b”	aláírt char	int	1
'u'	Py_UNICODE	Unicode karakter	2
„h”	röviden aláírva	int	2
„H”	aláíratlanul rövid	int	2
'én'	aláírt int	int	2
'ÉN'	aláíratlan int	hosszú	2
'én'	hosszan aláírva	int	4
„L”	aláíratlanul hosszú	hosszú	4
'F'	úszik	úszik	4
'd'	kétszeresére	úszik	8

Hogyan lehet elérni egy adott tömbértéket?

A tömb bármely elemét elérheti az index használatával.

Szintaxis

arrayName[indexNum]

Példa:

balance[1]

A következő kép szemlélteti a tömbelemek indexük alapján történő elérésének alapelvét.

Itt a tömb második értékéhez fértünk hozzá az indexével, ami 1. Ennek kimenete 200 lesz, ami lényegében a kiegyensúlyozott tömb második értéke.

import array
balance = array.array('i', [300,200,100])
print(balance[1])

KIMENET

Sor OperaTIONS

A tömb modulja Python külön funkciói vannak a tömbműveletek végrehajtásához. Ez egy destruktív módszer a tömbökkel való működésre, ami azt jelenti, hogy a módosítás a tömbváltozóba kerül mentésre.

betétlap

Ezzel a művelettel egy vagy több elemet beszúrhat egy tömbbe a tömb elejére, végére vagy a tömb bármely adott indexére. Ez a módszer két argumentumot vár: index és érték.

Szintaxis

arrayName.insert(index, value)

Példa:

Adjunk hozzá egy új értéket közvetlenül a tömb második eleme után. Jelenleg az egyenlegtömbünk három elemből áll: 300, 200 és 100. Tehát mi az indexe a második 200-as értékű tömbelemnek, ha 1-et mondott.

Ahhoz, hogy az új értéket közvetlenül az 1. index „után” illessze be, hivatkoznia kell a 2. indexre a beszúrási metódusban, így:

import array
balance = array.array('i', [300,200,100])
balance.insert(2, 150)

Most annak ellenőrzéséhez, hogy az új érték beszúrásra került-e, írja be a tömb nevét, és nyomja meg az Enter billentyűt a billentyűzeten:

import array
balance = array.array('i', [300,200,100])
balance.insert(2, 150)
print(balance)

KIMENET

array('i', [300,200,150,100])

töröl

Ezzel a művelettel érték szerint törölhet egy elemet egy tömbből. Ez a módszer csak egy argumentumot, értéket fogad el. A módszer futtatása után a tömbelemek átrendeződnek, és az indexek hozzárendelődnek.

Szintaxis

arrayName.remove(value)

Példa:

Távolítsuk el a 150-es értéket a tömbből. Jelenleg a mérlegtömbünk négy elemből áll: 300, 200, 150 és 100. Tehát ahhoz, hogy eltávolítsuk a 150-et a tömbből, csak 150-et kell beírnunk a method argumentumba. Egyszerű, igaz?

import array
balance = array.array('i', [300,200,100])
balance.insert(2, 150)
print(balance)
balance.remove(150)

Most annak ellenőrzéséhez, hogy az érték törölve lett-e, írja be a tömb nevét, és nyomja meg az Enter billentyűt a billentyűzeten:

import array
balance = array.array('i', [300,200,100])
balance.insert(2, 150)
print(balance)
balance.remove(150)
print(balance)

KIMENET

 array('i', [300,200,100])

KERESÉS

Ezzel a művelettel az értéke alapján kereshet egy elemet egy tömbben. Ez a módszer csak egyetlen érvet, értéket fogad el. Ez egy roncsolásmentes módszer, ami azt jelenti, hogy nincs hatással a tömbértékekre.

Szintaxis

arrayName.index(value)

Példa:

Keressük a tömbben a 150-es értéket. Jelenleg az egyensúlyi tömbünk négy elemből áll: 300, 200, 150 és 100. Tehát ahhoz, hogy a 150-et keressük a tömbben, csak a 150-et kell beírnunk a method argumentumba. Ez elég könnyű. Ez a metódus a keresett érték indexét adja vissza.

import array
balance = array.array('i', [300,200,150,100])
print(balance.index(150))

KIMENET

UPDATE

Ez a művelet nagyon hasonlít a beszúrási módszerhez, azzal a különbséggel, hogy lecseréli az adott indexnél meglévő értéket. Ez azt jelenti, hogy egyszerűen hozzárendel egy új értéket az adott indexhez. Ez a módszer két argumentumot vár: index és érték.

Szintaxis

arrayName.udpate(index, value)

Példa:

Tételezzük fel, hogy a tömbünk négy elemből áll: 300, 200, 150 és 100, és a 150-et 145-tel akarjuk helyettesíteni. Tehát mi az index 150?

Gratulálok, ha azt mondtad, hogy 2.

A 150-es indexű 2 lecseréléséhez a 2-es indexre kell hivatkoznia egyszerű hozzárendelési operátor használatával, például a következővel:

import array
balance = array.array('i', [300,200,150,100])
balance[2] = 145

Most, hogy ellenőrizze, hogy az érték frissült-e, írja be a tömb nevét, és nyomja meg az Enter billentyűt a billentyűzeten:

import array
balance = array.array('i', [300,200,150,100])
balance[2] = 145
print(balance)

KIMENET

array('i', [300,200,145,100])

Traverse

A Python tömbön áthaladhat hurkok használatával, például ez:

import array
balance = array.array('i', [300,200,100])
for x in balance:
	print(x)

KIMENET

300
200
100

Tömb létrehozása a ben C++

C++ nyelv rugalmasabb, mint Python ha tömbök létrehozásáról van szó. Létrehozhatsz C++ tömbök az előbb említett három módon.

A következő kód bemutatja, hogyan hozhat létre egész számokat tartalmazó tömböt C++ számlaegyenleg tárolása:

#include <iostream>
using namespace std;

int main()
{
  int balance[3] = { 300, 200, 100 };
  for (int i = 0; i < 3; i++)
    {
      cout << "value of i: " << balance[i] << endl;
    }
  return 0;
}

A tömb deklarálásának módjai C++

Egy tömböt három szintaxisváltozatban deklarálhatunk. Melyik illik a programodhoz; ez a választás a programkövetelményeken alapul.

Nyilatkozat méret szerint

Szintaxis

dataType arrayName[arraySize];

Példa:

int balance[3];

Csak a nyilatkozat inicializálási tömb elemei

Szintaxis

dataType arrayName[] = {array, items};

Példa:

int balance[] = { 300, 200, 100 };

Nyilatkozat méret és inicializálás tömb elemei szerint

Szintaxis

dataType arrayName[arraySize] = {array, items};

Példa:

int balance[3] = { 300, 200, 100 };

Hogyan lehet elérni egy adott tömbértéket?

A tömb bármely elemét elérheti az index használatával.

Szintaxis

arrayName[indexNum]

Példa:

balance[1]

A következő kép szemlélteti a tömbelemek indexük alapján történő elérésének alapelvét.

Itt a tömb második értékéhez fértünk hozzá az indexe segítségével, ami 1. Ennek kimenete 200 lesz, ami lényegében a mérleg tömb második értéke.

#include <iostream>
using namespace std;

int main()
{
  int balance[3] = { 300, 200, 100 };
  cout << balance[1];

  return 0;
}

teljesítmény

Sor Operabe C++

Eltérően Python-ban C++ Önnek kell programoznia a logikát a beszúrási, törlési, keresési frissítési és bejárási műveletek végrehajtásához C++ tömbök.

betétlap

A beillesztési művelet logikája a következő:

végigpörgetni a tömb elemeit
áthelyezni őket egy nagyobb indexre
új tömbelem hozzáadása egy adott indexhez

A következő példában 5 tétel van az egyenlegtömbben, és egy új elemet szeretnénk hozzáadni közvetlenül a 200-as érték után. Ez azt jelenti, hogy a 200 utáni összes tételt át kell helyeznünk egy nagyobb indexbe, majd be kell illesztenünk az új elemet. értéke 150.

#include <iostream>
#include <stdio.h>

main() {
   int pos = 2;
   int size = 4;
   int balance[] = {300,200,100,50,0};
   
   printf("BEFORE INCREMENT: \n");
   for(int i = 0; i<5; i++) {
      printf("%d\n",balance[i]);
   }

   /* FOR SHIFTING ITEMS TO A GREATER INDEX */
   for(int i = size; i >= pos; i--) {
       balance[i+1]=balance[i];
   }

   /* FOR INSERTING VALUE AT OUR DESIRED INDEX */   
   balance[pos] = 150;
   
   printf("AFTER INCREMENT: \n");
   

   /* FOR PRINTING THE NEW ARRAY */   
   for(int i = 0; i<6; i++) {
      printf("%d\n",balance[i]);
   }
}

teljesítmény

BEFORE INCREMENT
300
200
100
50
0
AFTERINCREMENT
300
200
150
100
50
0

Sor Operabe Java

Készítsünk egy programozást Java, ebben tömb program be Java elfogadjuk a felhasználótól a tömbelemek méretét és értékét.

import java.util.Scanner;

public class AddElements {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        System.out.println("Enter the size of the array");
        int n=sc.nextInt();

        int arr[]=new int[n];

        System.out.println("Enter Elements in the array");
        for(int i=0;i<n;i++)
        {
            arr[i]=sc.nextInt();
        }
        System.out.println("Elements in the array");
        for(int j=0;j<n;j++)
        {
            System.out.print(arr[j]+" ");
        }
    }
}

Kimenet:-

Enter the size of the array

5
Enter Elements in the array

1
2
3
4
5
Elements in the array
1 2 3 4 5

Elem módosítása a tömbben:-

Frissítsen egy elemet a megadott indexszel.

Program be Java a tömb elemeinek módosításához

import java.util.Scanner;

public class ModifyElement {
    public static void main(String[] args) {
        int arr[]={1,2,3,4,5};
        int length= arr.length;
        Scanner sc=new Scanner(System.in);

        System.out.println("Array Elements Before modify");
        for(int i=0;i<length;i++)
        {
            System.out.print(arr[i]+" ");
        }


        System.out.println("\nEnter the position where you want to change in an array");
        int pos=sc.nextInt();

        System.out.println("Enter the value");
        int val=sc.nextInt();

        arr[pos]=val;

        System.out.println("Array Elements After modify");
        for(int j=0;j<length;j++)
        {
            System.out.print(arr[j]+" ");
        }
    }
}

Kimenet:-

Array Elements Before modify
1 2 3 4 5 
Enter the position where you want to change in an array

2
Enter the value
8
Array Elements After modify
1 2 8 4 5

Elérési elem a tömbben: -

Nyomtassa ki az összes tömbelemet.

Program be Java hogy hogyan lehet bejárni a tömbben

public class AccessElements {
    public static void main(String[] args) {
        int arr[]={1,2,3,4,5};
        int length= arr.length;

        System.out.println("Array Elements are:-");
        for(int i=0;i<length;i++)
        {
            System.out.print(arr[i]+" ");
        }

    }
}

Kimenet:-

Array Elements are:-
1 2 3 4 5

Összegzésként

A tömb több, hasonló adattípussal rendelkező adatelem tárolására szolgáló adatstruktúra
Az azonosító, az adattípus, a tömb hossza, az elemek és az index a tömb fő részei
A tömbelemek értékeinek feldolgozásához használja az indexet
A tömbök kiválóan támogatják az adattípusok érintetlenségét
A legtöbb nyelven egy tömb létrehozása az azonosító, az adattípus és a belefoglalandó elemek megadásával történik
A tömbök a legjobbak nagyszámú érték feldolgozására, valamint a gyors rendezésre és keresésre
Python modulokkal és beépített módszerekkel rendelkezik az alapvető tömbműveletek végrehajtásához, mint például a beszúrás, törlés, keresés, frissítés és bejárás
C++ definiáló programokra van szüksége az olyan alapvető tömbműveletekhez, mint a beszúrás, törlés, keresés frissítés és bejárás

Talán tetszene:

Mi az a tömb az adatszerkezetben?

A tömb fogalma

Miért van szükségünk tömbökre?

Tömb létrehozása a ben Python

A tömb deklarálásának módjai Python

KAPCSOLÓDÓ CIKKEK

Hogyan lehet elérni egy adott tömbértéket?

Sor OperaTIONS

betétlap

töröl

KERESÉS

UPDATE

Traverse

Tömb létrehozása a ben C++

A tömb deklarálásának módjai C++

Hogyan lehet elérni egy adott tömbértéket?

Sor Operabe C++

betétlap

Sor Operabe Java

Elem módosítása a tömbben:-

Elérési elem a tömbben: -

Összegzésként