Tömb az adatszerkezetben (Operaciók)

Mi az a tömb az adatszerkezetben?

An sor egy olyan adatstruktúra, amely több hasonló adattípusú adatelem tárolására szolgál. Egy tömb elemei szomszédos memóriahelyeken vannak lefoglalva, és ezeket a helyeket az úgynevezett elemek a tömb elemeinek teljes száma. Egy tömb elemeinek teljes száma a hossz.

Minden elemhez a pozíciója alapján lehet hozzáférni, és ezt a hivatkozást nevezzük index or alsó index.

A tömb fogalma

A tömbök fogalmi diagramja

A fenti ábra ezt szemlélteti:

1. A tömb elemek tárolója.
2. Az elemeknek meghatározott értékük és adattípusuk van, például „ABC”, IGAZ vagy HAMIS.
3. Minden elemnek saját indexe van, amely az eléréséhez szükséges.

Jegyzet:

• Az elemek összefüggő memóriahelyeken tárolódnak.
• Egy index mindig kisebb, mint a tömbelemek teljes száma.
• Bármely tömbként deklarált változó több értéket is tárolhat.
• Szinte minden nyelv ugyanazt a tömbfogalmat használja, de abban különböznek, hogyan deklarálják és inicializálják őket.
• Három rész marad közös az összes inicializálás során: a tömb neve, az elemek és az elemek adattípusa.

A következő ábra egy deklarálásának szintaxisát mutatja be. tömb be Python és a C++, ami azt mutatja, hogy a koncepció ugyanaz marad, annak ellenére, hogy a szintaxis kissé eltér a nyelvek között.

Ismerje meg a tömbök szintaxisát

• Tömb neve: az elemek gyűjteményének könnyű eléréséhez szükséges.
• Adattípus: típusellenőrzéshez és adatintegritás-ellenőrzéshez szükséges.
• elemek: a tömbben található adatértékek.

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

• A tömbök ideálisak több érték egyetlen változóban történő tárolására.
• Sok értéket könnyen és gyorsan feldolgoznak.
• A tömbök segítségével könnyebb az értékek rendezése és keresése.

Tömb létrehozása a ben Python

In PythonA tömbök különböznek a listáktól: egy lista különböző adattípusú elemeket tartalmazhat, míg egy tömb csak azonos adattípusú elemeket. Python Van egy külön modulja a tömbök kezelésére, az úgynevezett array, amelyet használat előtt importálnia kell.

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

A következő kód egy egész értékű tömböt hoz létre Python számlaegyenlegek 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 a következő szintaxissal inicializálja:

arrayName = array.array(typecode, [array_items])

A tömb szintaxisa be Python

1. Azonosító: adj meg egy nevet, ahogy általában a változóknál szoktál.
2. Modul: Python van egy speciális, „array” nevű modulja, amelyet először importálni kell.
3. Módszer: A tömb modulnak van egy metódusa a tömb inicializálására, amely két argumentumot fogad el – typecode és elements.
4. Típuskód: Adja meg az adattípust a rendelkezésre álló típuskódok segítségével (lásd az alábbi táblázatot).
5. elemek: Adja meg a tömb elemeit szögletes zárójelben, például [130, 450, 103].

Az alábbi táblázat felsorolja a támogatott adattípusokhoz elérhető típuskódokat.

Írja be a kódot	C Típus	Python típus	Minimális méret (bájt)
„b”	aláírt char	int	1
„B”	aláíratlan 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	int	2
'én'	hosszan aláírva	int	4
„L”	aláíratlanul hosszú	int	4
'F'	úszik	úszik	4
'd'	kétszeresére	úszik	8

Hogyan lehet hozzáférni egy adott tömbértékhez?

Bármely tömbelemhez hozzáférhetsz az indexével.

Syntax:

arrayName[indexNum]

Példa:

balance[1]

Hozzáférés egy tömbelemhez

Itt az 1-es index segítségével értük el a tömb második értékét. A kimenet 200, ami a balance tömb második értéke.

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

output:

200

Sor Operabe Python

Az Python Az array modul különálló függvényeket biztosít a tömbműveletekhez. Ezek destruktív metódusok, ami azt jelenti, hogy a módosítás a tömbváltozóban kerül mentésre.

betétlap

Ez a művelet egy vagy több elemet szúr be egy tömb elejére, végére vagy egy adott indexre. Két argumentumot vár: indexet és értéket.

arrayName.insert(index, value)

Példa: Ha egy új értéket szeretne közvetlenül az 1. index (a 200-as érték) után beszúrni, hivatkozzon a 2. indexre az insure metódusban.

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

output:

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

Törölni

Ez a művelet egyetlen elemet töröl egy tömbből érték szerint, egyetlen argumentumot elfogadva. A futása után az elemek átrendeződnek, és az indexek újra lesznek rendelve.

arrayName.remove(value)

Példa:

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

output:

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

Keresés

Ez a művelet egy elemet érték alapján keres, és visszaadja annak indexét. Ez egy roncsolásmentes metódus, tehát nem változtatja meg a tömb értékeit.

arrayName.index(value)

Példa:

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

output:

2

Frissítések

A frissítés egy egyszerű értékadó operátor segítségével lecseréli az adott indexen található meglévő értéket.Python a tömböknek nincs update() módszer.)

arrayName[index] = value

Példa: A 150-es szám (a 2-es indexnél) 145-tel való helyettesítése:

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

output:

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

Traverse

Áthaladhat a Python tömb ciklus használatával:

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

output:

300
200
100

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

C++ rugalmasabb, mint Python tömbök létrehozásakor. Létrehozhat C++ tömbök háromféleképpen. A következő kód egy egész értékű tömböt hoz létre a C++ számlaegyenlegek tárolására:

#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áromféleképpen deklarálhatsz, a programod követelményeitől függően.

Méret szerinti nyilatkozat:

dataType arrayName[arraySize];   // e.g. int balance[3];

Deklaráció csak tömbelemekkel:

dataType arrayName[] = {array_items};   // e.g. int balance[] = { 300, 200, 100 };

Méret és tételek szerinti nyilatkozat:

dataType arrayName[arraySize] = {array_items};   // e.g. int balance[3] = { 300, 200, 100 };

Hogyan férhetünk hozzá egy adott tömbértékhez a C++?

Hozzáférés egy tömbelemhez

#include <iostream>
using namespace std;

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

output:

200

Sor Operabe C++

Eltérően Python-ban C++ A beszúrás, törlés, keresés, frissítés és bejárás műveletek logikáját Önnek kell programoznia.

betétlap

A beszúrási logika a következő: végigmegy a tömb elemein, eltolja őket egy nagyobb indexre, majd hozzáad egy új elemet a megadott indexen. Az alábbi példa öt elemet tartalmaz, és a 200-as érték után közvetlenül beszúrja a 150-et.

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

main() {
   int pos = 2;
   int size = 4;
   int balance[] = {300, 200, 100, 50, 0};

   printf("BEFORE INSERT:\n");
   for(int i = 0; i < 5; i++) {
      printf("%d\n", balance[i]);
   }

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

   /* INSERT VALUE AT THE DESIRED INDEX */
   balance[pos] = 150;

   printf("AFTER INSERT:\n");
   for(int i = 0; i < 6; i++) {
      printf("%d\n", balance[i]);
   }
}

Sor Operabe Java

Készítsünk egy programot a Java amely elfogadja a tömb elemeinek méretét és értékeit a felhasználótól.

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] + " ");
        }
    }
}

Elem módosítása egy Java Sor

Egy elem frissítése az indexe alapján.

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 to change");
        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] + " ");
        }
    }
}

Hozzáférési elemek egy Java Sor

Nyomtassa ki az összes tömbelemet a tömb bejárásával.

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] + " ");
        }
    }
}

GYIK