La estructura de datos es la forma de almacenar datos en la memoria de la computadora para que pueda usarse de manera fácil y eficiente. Existen diferentes estructuras de datos utilizadas para el almacenamiento de datos. También se puede definir como un modelo matemático o lógico de una organización particular de elementos de datos. La representación de una estructura de datos particular en la memoria principal de una computadora se denomina estructura de almacenamiento. Por ejemplo: array , pila , cola , árbol , gráfico , etc.
Operaciones en diferentes estructuras de datos:
existen diferentes tipos de operaciones que se pueden realizar para la manipulación de datos en cada estructura de datos. Algunas operaciones se explican e ilustran a continuación:
- Atravesar: Atravesar una Estructura de Datos significa visitar el elemento almacenado en ella. Visita los datos de manera sistemática. Esto se puede hacer con cualquier tipo de DS.
A continuación se muestra el programa para ilustrar el recorrido en una array:
Array
// C++ program to traversal in an array
#include <iostream>
using namespace std;
// Driver Code
int main()
{
// Initialise array
int arr[] = { 1, 2, 3, 4 };
// size of array
int N = sizeof(arr) / sizeof(arr[0]);
// Traverse the element of arr[]
for (int i = 0; i < N; i++) {
// Print the element
cout << arr[i] << ' ';
}
return 0;
}
Stack
// C++ program to traversal in an stack
#include <bits/stdc++.h>
using namespace std;
// Function to print the element in stack
void printStack(stack<int>& St)
{
// Traverse the stack
while (!St.empty()) {
// Print top element
cout << St.top() << ' ';
// Pop top element
St.pop();
}
}
// Driver Code
int main()
{
// Initialise stack
stack<int> St;
// Insert Element in stack
St.push(4);
St.push(3);
St.push(2);
St.push(1);
// Print elements in stack
printStack(St);
return 0;
}
Queue
// C++ program to traversal
// in an queue
#include <bits/stdc++.h>
using namespace std;
// Function to print the
// element in queue
void printQueue(queue<int>& Q)
{
// Traverse the stack
while (!Q.empty()) {
// Print top element
cout << Q.front() << ' ';
// Pop top element
Q.pop();
}
}
// Driver Code
int main()
{
// Initialise queue
queue<int> Q;
// Insert element
Q.push(1);
Q.push(2);
Q.push(3);
Q.push(4);
// Print elements
printQueue(Q);
return 0;
}
LinkedList
// C++ program to traverse the
// given linked list
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* next;
};
// Function that allocates a new
// node with given data
Node* newNode(int data)
{
Node* new_node = new Node;
new_node->data = data;
new_node->next = NULL;
return new_node;
}
// Function to insert a new node
// at the end of linked list
Node* insertEnd(Node* head, int data)
{
// If linked list is empty,
// Create a new node
if (head == NULL)
return newNode(data);
// If we have not reached the end
// Keep traversing recursively
else
head->next = insertEnd(head->next, data);
return head;
}
/// Function to traverse given LL
void traverse(Node* head)
{
if (head == NULL)
return;
// If head is not NULL,
// print current node and
// recur for remaining list
cout << head->data << " ";
traverse(head->next);
}
// Driver Code
int main()
{
// Given Linked List
Node* head = NULL;
head = insertEnd(head, 1);
head = insertEnd(head, 2);
head = insertEnd(head, 3);
head = insertEnd(head, 4);
// Function Call to traverse LL
traverse(head);
}
Producción:
1 2 3 4
A continuación se muestra el programa para ilustrar el recorrido en una array en Java:
C++
// C++ program to traversal in an array
#include <bits/stdc++.h>
using namespace std;
// Driver Code
int main()
{
// Initialise array
int arr[] = { 1, 2, 3, 4 };
// size of array
int N = sizeof(arr)/sizeof(arr[0]);
// Traverse the element of arr[]
for (int i = 0; i < N; i++) {
// Print the element
cout << arr[i] << " ";
}
return 0;
}
// This code is contributed by jana_sayantan.
Java
// Java program to traversal in an array
import java.util.*;
class GFG{
// Driver Code
public static void main(String[] args)
{
// Initialise array
int arr[] = { 1, 2, 3, 4 };
// size of array
int N = arr.length;
// Traverse the element of arr[]
for (int i = 0; i < N; i++) {
// Print the element
System.out.print(arr[i] + " ");
}
}
}
// This code contributed by Rajput-Ji
Python3
# Python program to traversal in an array # Driver Code if __name__ == '__main__': # Initialise array arr = [ 1, 2, 3, 4 ]; # size of array N = len(arr); # Traverse the element of arr for i in range(N): # Print element print(arr[i], end=" "); # This code is contributed by Rajput-Ji
C#
// C# program to traversal in an array
using System;
public class GFG {
// Driver Code
public static void Main(String[] args) {
// Initialise array
int []arr = { 1, 2, 3, 4 };
// size of array
int N = arr.Length;
// Traverse the element of []arr
for (int i = 0; i < N; i++) {
// Print the element
Console.Write(arr[i] + " ");
}
}
}
// This code contributed by Rajput-Ji
Javascript
<script>
// javascript program to traversal in an array // Driver Code
// Initialise array
var arr = [ 1, 2, 3, 4 ];
// size of array
var N = arr.length;
// Traverse the element of arr
for (i = 0; i < N; i++) {
// Print the element
document.write(arr[i] + " ");
}
// This code is contributed by Rajput-Ji
</script>
A continuación se muestra el programa para ilustrar el recorrido en una pila en Java:
Java
// Java program to traversal in an stack
import java.util.*;
class GFG{
// Function to print the element in stack
static void printStack(Stack<Integer> St)
{
// Traverse the stack
while (!St.isEmpty()) {
// Print top element
System.out.print(St.peek() +" ");
// Pop top element
St.pop();
}
}
// Driver Code
public static void main(String[] args)
{
// Initialise stack
Stack<Integer> St = new Stack<>() ;
// Insert Element in stack
St.add(4);
St.add(3);
St.add(2);
St.add(1);
// Print elements in stack
printStack(St);
}
}
// This code contributed by Rajput-Ji
C#
// C# program to traversal in an stack
using System;
using System.Collections.Generic;
public class GFG {
// Function to print the element in stack
static void printStack(Stack<int> St) {
// Traverse the stack
while (St.Count != 0) {
// Print top element
Console.Write(St.Peek() + " ");
// Pop top element
St.Pop();
}
}
// Driver Code
public static void Main(String[] args)
{
// Initialise stack
Stack<int> St = new Stack<int>();
// Insert Element in stack
St.Push(4);
St.Push(3);
St.Push(2);
St.Push(1);
// Print elements in stack
printStack(St);
}
}
// This code is contributed by Rajput-Ji
Javascript
<script>
// javascript program to traversal in an stack
// Function to print the element in stack
function printStack(St)
{
// Traverse the stack
while (St.length != 0)
{
// Print top element
document.write(St.pop() + " ");
}
}
// Driver Code
// Initialise stack
var St = [];
// Insert Element in stack
St.push(4);
St.push(3);
St.push(2);
St.push(1);
// Print elements in stack
printStack(St);
// This code is contributed by Rajput-Ji
</script>
- Búsqueda : Buscar significa encontrar un elemento particular en la estructura de datos dada. Se considera exitosa cuando se encuentra el elemento requerido. La búsqueda es la operación que podemos realizar en estructuras de datos como array, lista enlazada, árbol, gráfico, etc.
A continuación se muestra el programa para ilustrar la búsqueda de un elemento en una array:
Array
// C++ program to searching in an array
#include <iostream>
using namespace std;
// Function that finds element K in the
// array
void findElement(int arr[], int N, int K)
{
// Traverse the element of arr[]
// to find element K
for (int i = 0; i < N; i++) {
// If Element is present then
// print the index and return
if (arr[i] == K) {
cout << "Element found!";
return;
}
}
cout << "Element Not found!";
}
// Driver Code
int main()
{
// Initialise array
int arr[] = { 1, 2, 3, 4 };
// Element to be found
int K = 3;
// size of array
int N = sizeof(arr) / sizeof(arr[0]);
// Function Call
findElement(arr, N, K);
return 0;
}
Stack
// C++ program to find element in stack
#include <bits/stdc++.h>
using namespace std;
// Function to find element in stack
void findElement(stack<int>& St, int K)
{
// Traverse the stack
while (!St.empty()) {
// Check if top is K
if (St.top() == K) {
cout << "Element found!";
return;
}
// Pop top element
St.pop();
}
cout << "Element Not found!";
}
// Driver Code
int main()
{
// Initialise stack
stack<int> St;
// Insert Element in stack
St.push(4);
St.push(3);
St.push(2);
St.push(1);
// Element to be found
int K = 3;
// Function Call
findElement(St, K);
return 0;
}
Queue
// C++ program to find given element
// in an queue
#include <bits/stdc++.h>
using namespace std;
// Function to find element in queue
void findElement(queue<int>& Q, int K)
{
// Traverse the stack
while (!Q.empty()) {
// Check if top is K
if (Q.front() == K) {
cout << "Element found!";
return;
}
// Pop top element
Q.pop();
}
cout << "Element Not found!";
}
// Driver Code
int main()
{
// Initialise queue
queue<int> Q;
// Insert element
Q.push(1);
Q.push(2);
Q.push(3);
Q.push(4);
// Element to be found
int K = 3;
// Print elements
findElement(Q, K);
return 0;
}
LinkedList
// C++ program to traverse the
// given linked list
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* next;
};
// Function that allocates a new
// node with given data
Node* newNode(int data)
{
Node* new_node = new Node;
new_node->data = data;
new_node->next = NULL;
return new_node;
}
// Function to insert a new node
// at the end of linked list
Node* insertEnd(Node* head, int data)
{
// If linked list is empty,
// Create a new node
if (head == NULL)
return newNode(data);
// If we have not reached the end
// Keep traversing recursively
else
head->next = insertEnd(head->next, data);
return head;
}
/// Function to traverse given LL
bool traverse(Node* head, int K)
{
if (head == NULL)
return false;
// If node with value K is found
// return true
if (head->data == K)
return true;
return traverse(head->next, K);
}
// Driver Code
int main()
{
// Given Linked List
Node* head = NULL;
head = insertEnd(head, 1);
head = insertEnd(head, 2);
head = insertEnd(head, 3);
head = insertEnd(head, 4);
// Element to be found
int K = 3;
// Function Call to traverse LL
if (traverse(head, K)) {
cout << "Element found!";
}
else {
cout << "Element Not found!";
}
}
Producción:
Element found!
- Inserción: Es la operación que aplicamos sobre todas las estructuras de datos. Inserción significa agregar un elemento en la estructura de datos dada. La operación de inserción tiene éxito cuando el elemento requerido se agrega a la estructura de datos requerida. No tiene éxito en algunos casos cuando el tamaño de la estructura de datos está lleno y cuando no hay espacio en la estructura de datos para agregar ningún elemento adicional. La inserción tiene el mismo nombre que una inserción en la estructura de datos como array, lista enlazada, gráfico, árbol. En la pila, esta operación se llama Push. En la cola, esta operación se llama Poner en cola.
A continuación se muestra el programa para ilustrar la inserción en la pila:
Array
// C++ program for insertion in array
#include <iostream>
using namespace std;
// Function to print the array element
void printArray(int arr[], int N)
{
// Traverse the element of arr[]
for (int i = 0; i < N; i++) {
// Print the element
cout << arr[i] << ' ';
}
}
// Driver Code
int main()
{
// Initialise array
int arr[4];
// size of array
int N = 4;
// Insert elements in array
for (int i = 1; i < 5; i++) {
arr[i - 1] = i;
}
// Print array element
printArray(arr, N);
return 0;
}
Stack
// C++ program for insertion in array
#include <bits/stdc++.h>
using namespace std;
// Function to print the element in stack
void printStack(stack<int>& St)
{
// Traverse the stack
while (!St.empty()) {
// Print top element
cout << St.top() << ' ';
// Pop top element
St.pop();
}
}
// Driver Code
int main()
{
// Initialise stack
stack<int> St;
// Insert Element in stack
St.push(4);
St.push(3);
St.push(2);
St.push(1);
// Print elements in stack
printStack(St);
return 0;
}
Queue
// C++ program for insertion in queue
#include <bits/stdc++.h>
using namespace std;
// Function to print the
// element in queue
void printQueue(queue<int>& Q)
{
// Traverse the stack
while (!Q.empty()) {
// Print top element
cout << Q.front() << ' ';
// Pop top element
Q.pop();
}
}
// Driver Code
int main()
{
// Initialise queue
queue<int> Q;
// Insert element
Q.push(1);
Q.push(2);
Q.push(3);
Q.push(4);
// Print elements
printQueue(Q);
return 0;
}
LinkedList
// C++ program for insertion in LL
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* next;
};
// Function that allocates a new
// node with given data
Node* newNode(int data)
{
Node* new_node = new Node;
new_node->data = data;
new_node->next = NULL;
return new_node;
}
// Function to insert a new node
// at the end of linked list
Node* insertEnd(Node* head, int data)
{
// If linked list is empty,
// Create a new node
if (head == NULL)
return newNode(data);
// If we have not reached the end
// Keep traversing recursively
else
head->next = insertEnd(head->next, data);
return head;
}
/// Function to traverse given LL
void traverse(Node* head)
{
if (head == NULL)
return;
// If head is not NULL,
// print current node and
// recur for remaining list
cout << head->data << " ";
traverse(head->next);
}
// Driver Code
int main()
{
// Given Linked List
Node* head = NULL;
head = insertEnd(head, 1);
head = insertEnd(head, 2);
head = insertEnd(head, 3);
head = insertEnd(head, 4);
// Function Call to traverse LL
traverse(head);
}
Producción:
1 2 3 4
- Borrado: Es la operación que aplicamos sobre todas las estructuras de datos. Eliminación significa eliminar un elemento en la estructura de datos dada. La operación de eliminación es exitosa cuando el elemento requerido se elimina de la estructura de datos. La eliminación tiene el mismo nombre que una eliminación en la estructura de datos como array, lista enlazada, gráfico, árbol, etc. En la pila, esta operación se llama Pop. En Queue, esta operación se llama Dequeue.
A continuación se muestra el programa para ilustrar la eliminación de la cola en la cola:
Stack
// C++ program for insertion in array
#include <bits/stdc++.h>
using namespace std;
// Function to print the element in stack
void printStack(stack<int> St)
{
// Traverse the stack
while (!St.empty()) {
// Print top element
cout << St.top() << ' ';
// Pop top element
St.pop();
}
}
// Driver Code
int main()
{
// Initialise stack
stack<int> St;
// Insert Element in stack
St.push(4);
St.push(3);
St.push(2);
St.push(1);
// Print elements before pop
// operation on stack
printStack(St);
cout << endl;
// Pop the top element
St.pop();
// Print elements after pop
// operation on stack
printStack(St);
return 0;
}
Queue
// C++ program to illustrate dequeue
// in queue
#include <bits/stdc++.h>
using namespace std;
// Function to print the element
// of the queue
void printQueue(queue<int> myqueue)
{
// Traverse the queue and print
// element at the front of queue
while (!myqueue.empty()) {
// Print the first element
cout << myqueue.front() << ' ';
// Dequeue the element from the
// front of the queue
myqueue.pop();
}
}
// Driver Code
int main()
{
// Declare a queue
queue<int> myqueue;
// Insert element in queue from
// 0 to 5
for (int i = 1; i < 5; i++) {
// Insert element at the
// front of the queue
myqueue.push(i);
}
// Print element beforepop
// from queue
printQueue(myqueue);
cout << endl;
// Pop the front element
myqueue.pop();
// Print element after pop
// from queue
printQueue(myqueue);
return 0;
}
LinkedList
// C++ program for insertion in LL
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* next;
};
// Function that allocates a new
// node with given data
Node* newNode(int data)
{
Node* new_node = new Node;
new_node->data = data;
new_node->next = NULL;
return new_node;
}
// Function to insert a new node
// at the end of linked list
Node* insertEnd(Node* head, int data)
{
// If linked list is empty,
// Create a new node
if (head == NULL)
return newNode(data);
// If we have not reached the end
// Keep traversing recursively
else
head->next = insertEnd(head->next, data);
return head;
}
/// Function to traverse given LL
void traverse(Node* head)
{
if (head == NULL)
return;
// If head is not NULL,
// print current node and
// recur for remaining list
cout << head->data << " ";
traverse(head->next);
}
// Driver Code
int main()
{
// Given Linked List
Node* head = NULL;
head = insertEnd(head, 1);
head = insertEnd(head, 2);
head = insertEnd(head, 3);
head = insertEnd(head, 4);
// Print before deleting the first
// element from LL
traverse(head);
// Move head pointer to forward
// to remove the first element
// If LL has more than 1 element
if (head->next != NULL) {
head = head->next;
}
else {
head = NULL;
}
cout << endl;
// Print after deleting the first
// element from LL
traverse(head);
}
Producción:
1 2 3 4 2 3 4
Algún otro método:
Crear: –
Invierte la memoria para los elementos del programa declarándolos. La creación de la estructura de datos se
puede hacer durante
- Tiempo de compilación
- Tiempo de ejecución.
Puede usar la función malloc().
Selección : –
Selecciona datos específicos de los datos actuales. Puede seleccionar datos específicos dando condición en bucle.
Actualizar
Actualiza los datos en la estructura de datos. También puede actualizar cualquier dato específico dando alguna condición en bucle como enfoque de selección.
Ordenar
Ordenar datos en un orden particular. Como ascendiendo o descendiendo.
Podemos tomar la ayuda de muchos algoritmos de clasificación para clasificar los datos en menos tiempo. Ejemplo: clasificación de burbujas que requiere tiempo para clasificar los datos. Hay muchos algoritmos presentes como clasificación por fusión, clasificación por inserción, clasificación por selección, clasificación rápida, etc.
Combinar
La combinación de datos de dos órdenes diferentes en un orden específico puede ascender o descender. Usamos merge sort para fusionar datos de clasificación
Dividir datos
Dividir datos en diferentes subpartes para que el proceso se complete en menos tiempo.
Publicación traducida automáticamente
Artículo escrito por itskawal2000 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA