# data[].attributes.body
es un lenguaje de programación orientado a objetos que se puede considerar una evolución de Visual Basic implementada sobre el framework .NET.

# data[].attributes.attachment_link.title
Tutorial Visual Basic .NET - Parte 1 (Curso VB.NET 2010 & 2012)

# data[].attributes.attachment_link.readable_text
VB.NET

Desarrollador(es)

Microsoft
https://docs.microsoft.com/en-us/dotnet/visual-basic/ y https://docs.microsoft.com/ja-jp/dotnet/visual-basic/

Información general

Extensiones comunes

.vb

Paradigma

Multiparadigma: estructurado, imperativo, orientado a objetos, dirigido por eventos, funcional, genérico, reflexivo

Apareció en

2001

Diseñado por

Microsoft

Última versión estable

16.9

Sistema de tipos

Estático, dinámico, fuerte, seguro, nominal

Implementaciones

Microsoft .NET, Microsoft .NET Core, Mono y DotGNU

Dialectos

Microsoft Visual Basic

Influido por

Small Basic, Visual Basic

Sistema operativo

Multiplataforma

Visual Basic .NET ( VB.NET) es un lenguaje de programación orientado a objetos que se puede considerar una evolución de Visual Basic implementada sobre el framework .NET. Su introducción resultó muy controvertida, ya que debido a cambios significativos en el lenguaje VB.NET no es retro compatible con Visual Basic, pero el manejo de las instrucciones es similar a versiones anteriores de Visual Basic, facilitando así el desarrollo de aplicaciones más avanzadas con herramientas modernas. Para mantener eficacia en el desarrollo de las aplicaciones la gran mayoría de programadores de VB.NET utilizan el entorno de desarrollo integrado Microsoft Visual Studio en alguna de sus versiones (desde el primer Visual Studio .NET hasta Visual Studio .NET 2022, que es la última versión de Visual Studio para la plataforma .NET), aunque existen otras alternativas, como SharpDevelop (que además es libre).

Al igual que con todos los lenguajes de programación basados en .NET, los programas escritos en VB .NET requieren el Framework .NET o Mono para ejecutarse.

Visual Basic 2008 (VB 9.0)

Para esta versión se añadieron varias novedades, incluyendo:

Visual Basic 2010 ofrece soporte de entorno de ejecución dinámica.

VB 2010 forma parte de Microsoft Silverlight. Visual Basic es un lenguaje de programación que permite realizar diferentes programas de registro anidados.

Si Visual Basic .NET debe considerarse una mera versión de Visual Basic, o si debe considerarse como un nuevo lenguaje de programación, es un tema que ha traído mucha discusión, y que aún la trae.

La sintaxis básica es prácticamente la misma entre VB y VB.NET, con la excepción de los añadidos para soportar nuevas características como el control estructurado de excepciones, la programación orientada a objetos, o los Genéricos.

Las diferencias entre VB y VB.NET son profundas, sobre todo en cuanto a metodología de programación y bibliotecas, pero ambos lenguajes siguen manteniendo un gran parecido, cosa que facilita notablemente el paso de VB a VB.NET.

Al mismo tiempo que evolucionaba el lenguaje, las herramientas que Microsoft proporciona para programar también evolucionaban para adaptarse a las novedades.

Visual Studio .NET (2002)

Visual Studio .NET se publicó en 2002 y fue la primera versión de Visual Studio.NET

En esta primera versión de Visual Studio .NET se podían programar aplicaciones Windows.

En esta versión se añadió por primera vez la posibilidad de programar para dispositivos móviles usando .NET, ya fuera usando el Compact Framework, o ASP.NET.

Visual Basic Express Edition

A partir de la introducción en el mercado de la versión 2005 de Visual Studio Microsoft publicó lo que se conoce como ediciones Exp de distintos programas. Las versiones Express son versiones limitadas pero gratuitas, pensadas para usos no profesionales (principiantes, aficionados y pequeños negocios), existiendo una edición independiente para cada lenguaje.

Visual Basic Express Edition es una versión de Visual Studio limitada. Esta versión permite sólo programar en VB.NET, y además limita el tipo de proyectos que se pueden desarrollar. Visual Web Developer Express Edition permite programar páginas ASP.NET en VB.

Se lanzó el Service Pack 1 para Visual Studio 2005 el 14 de diciembre de 2006.

El IDE de Visual Studio 2008 permite trabajar contra 3 .NET frameworks diferentes:

.NET Framework 2.0

.NET Framework 3.0

.NET Framework 3.5

También es muy fácil de usar gracias al desarrollo de hardware.

Además, integra el framework ASP.NET AJAX para el desarrollo de AJAX..

El 12 de abril de 2010, Microsoft publica Visual Studio 2010, nombre clave Dev10, y .NET Framework versión 4. Compatible con Visual Basic .NET, con una interfaz rediseñada, más sencilla y con soporte para diseño de aplicaciones en Windows 7.

Para desarrollar en VB.NET existen algunas alternativas a Visual Studio, quizás la más notable sea SharpDevelop.

SharpDevelop es un entorno de programación integrado que permite programar en C# y en VB.NET.

Este es un entorno publicado bajo licencia LGPL, lo que implica que es libre y que el código fuente es abierto.

MonoDevelop es una implementación de SharpDevelop para programar usando Mono, una implementación libre de .NET que funciona en distintos sistemas operativos.

Desarrollo multiplataforma

Gracias al esfuerzo que ha realizado la gente del proyecto Mono para implementar una versión compatible 100% con .NET que incluye la inmensa mayoría de la bibliotecas y una implementación multiplataforma de Windows.Forms, resulta posible programar para distintos sistemas operativos usando VB.NET.

Ejemplo básico de "Hola, Mundo" en la consola:

Enlaces externos

# data[].attributes.attachment_link.title
Visual Basic .NET - Wikipedia, la enciclopedia libre

# data[].attributes.attachment_link.description
VB.NET Desarrollador(es) Microsoft https://docs.microsoft.com/en-us/dotnet/visual-basic/ y https://docs.microsoft.com/ja-jp/dotnet/visual-basic/ Información general Extensiones comunes .vb Paradigma Multiparadigma: estructurado, imperativo, orientado a objetos, dirigido por eventos, funcional, genérico, reflexivo Apareció en 2001 Diseñado por Microsoft Última versión estable 16.9 Sistema de tipos Estático, dinámico, fuerte, seguro, nominal Implementaciones Microsoft .NET, Microsoft .NET Core, Mono y DotGNU Dialectos Microsoft Visual Basic Influido por Small Basic, Visual Basic Sistema operativo Multiplataforma Visual Basic .NET ( VB.NET) es un lenguaje de programación orientado a objetos que se puede considerar una evolución de Visual Basic implementada sobre el framework .NET.

# data[].attributes.body
El lenguaje ensamblador, o assembler, es un lenguaje de programación de bajo nivel. Consiste en un conjunto de mnemónicos que representan instrucciones básicas para los computadores, microprocesadores, ... etc.

# data[].attributes.attachment_link.readable_text
What is Assembly Language?

Each personal computer has a microprocessor that manages the computer's arithmetical, logical, and control activities.

Each family of processors has its own set of instructions for handling various operations such as getting input from keyboard, displaying information on screen and performing various other jobs. These set of instructions are called 'machine language instructions'.

A processor understands only machine language instructions, which are strings of 1's and 0's. However, machine language is too obscure and complex for using in software development. So, the low-level assembly language is designed for a specific family of processors that represents various instructions in symbolic code and a more understandable form.

Advantages of Assembly Language

Having an understanding of assembly language makes one aware of −

How programs interface with OS, processor, and BIOS;

How data is represented in memory and other external devices;

How the processor accesses and executes instruction;

How instructions access and process data;

How a program accesses external devices.

Other advantages of using assembly language are −

It requires less memory and execution time;

It allows hardware-specific complex jobs in an easier way;

It is suitable for time-critical jobs;

It is most suitable for writing interrupt service routines and other memory resident programs.

Basic Features of PC Hardware

The main internal hardware of a PC consists of processor, memory, and registers. Registers are processor components that hold data and address. To execute a program, the system copies it from the external device into the internal memory. The processor executes the program instructions.

The fundamental unit of computer storage is a bit; it could be ON (1) or OFF (0) and a group of 8 related bits makes a byte on most of the modern computers.

So, the parity bit is used to make the number of bits in a byte odd. If the parity is even, the system assumes that there had been a parity error (though rare), which might have been caused due to hardware fault or electrical disturbance.

The processor supports the following data sizes −

Word: a 2-byte data item

Doubleword: a 4-byte (32 bit) data item

Quadword: an 8-byte (64 bit) data item

Paragraph: a 16-byte (128 bit) area

Kilobyte: 1024 bytes

Megabyte: 1,048,576 bytes

Binary Number System

Every number system uses positional notation, i.e., each position in which a digit is written has a different positional value. Each position is power of the base, which is 2 for binary number system, and these powers begin at 0 and increase by 1.

The following table shows the positional values for an 8-bit binary number, where all bits are set ON.

The value of a binary number is based on the presence of 1 bits and their positional value. So, the value of a given binary number is −

1 + 2 + 4 + 8 +16 + 32 + 64 + 128 = 255

which is same as 2 ⁸ - 1.

Hexadecimal Number System

Hexadecimal number system uses base 16. The digits in this system range from 0 to 15. By convention, the letters A through F is used to represent the hexadecimal digits corresponding to decimal values 10 through 15.

Hexadecimal numbers in computing is used for abbreviating lengthy binary representations. Basically, hexadecimal number system represents a binary data by dividing each byte in half and expressing the value of each half-byte. The following table provides the decimal, binary, and hexadecimal equivalents −

Decimal number

Binary representation

Hexadecimal representation

To convert a binary number to its hexadecimal equivalent, break it into groups of 4 consecutive groups each, starting from the right, and write those groups over the corresponding digits of the hexadecimal number.

Example − Binary number 1000 1100 1101 0001 is equivalent to hexadecimal - 8CD1

To convert a hexadecimal number to binary, just write each hexadecimal digit into its 4-digit binary equivalent.

Example − Hexadecimal number FAD8 is equivalent to binary - 1111 1010 1101 1000

Binary Arithmetic

The following table illustrates four simple rules for binary addition −

Rules (iii) and (iv) show a carry of a 1-bit into the next left position.
Example
A negative binary value is expressed in two's complement notation. According to this rule, to convert a binary number to its negative value is to reverse its bit values and add 1.
Example
To subtract one value from another, convert the number being subtracted to two's complement format and add the numbers.
Example
Subtract 42 from 53

Overflow of the last 1 bit is lost.

Addressing Data in Memory

The process through which the processor controls the execution of instructions is referred as the fetch-decode-execute cycle or the execution cycle. It consists of three continuous steps −

Fetching the instruction from memory

Decoding or identifying the instruction

Executing the instruction

The processor may access one or more bytes of memory at a time. Let us consider a hexadecimal number 0725H. This number will require two bytes of memory. The high-order byte or most significant byte is 07 and the low-order byte is 25.

The processor stores data in reverse-byte sequence, i.e., a low-order byte is stored in a low memory address and a high-order byte in high memory address. So, if the processor brings the value 0725H from register to memory, it will transfer 25 first to the lower memory address and 07 to the next memory address.

x: memory address

When the processor gets the numeric data from memory to register, it again reverses the bytes. There are two kinds of memory addresses −

# data[].attributes.attachment_link.description
Each personal computer has a microprocessor that manages the computer's arithmetical, logical, and control activities. Each family of processors has its own set of instructions for handling various operations such as getting input from keyboard, displaying information on screen and performing various other jobs. These set of instructions are called 'machine language instructions'.

# data[].attributes.body
es un lenguaje de programación diseñado por Larry Wall en 1987. Perl toma características del lenguaje C, del lenguaje interpretado bourne shell, AWK, sed, Lisp y, en un grado inferior, de muchos otros lenguajes de programación.

# data[].attributes.attachment_link.readable_text
Raku

Raku (formerly known as Perl 6) is a sister language, part of the Perl family, not intended as a replacement for Perl, but as its own thing - libraries exist to allow you to call Perl code from Raku programs and vice versa.
View details "
The Perl Foundation

The Perl Foundation is dedicated to the advancement of the Perl programming language through open discussion, collaboration, design, and code.
View details "

# data[].attributes.attachment_link.title
The Perl Programming Language - www.perl.org

# data[].attributes.attachment_link.description
The Perl Programming Language at Perl.org. Links and other helpful resources for new and experienced Perl programmers.

# data[].attributes.body
JavaScript es un lenguaje de programación interpretado, dialecto del estándar ECMAScript. Se define como orientado a objetos, ​ basado en prototipos, imperativo, débilmente tipado y dinámico.

# data[].attributes.attachment_link.title
Curso Básico de Javascript 9.- Funciones

# data[].attributes.attachment_link.description
JavaScript.com is a resource for the JavaScript community. You will find resources and examples for JavaScript beginners as well as support for JavaScript experts. Learn JavaScript or free with our easy to use input output machine.

# data[].attributes.body
es un lenguaje de programación de propósito general de código del lado del servidor originalmente diseñado para el desarrollo web de contenido dinámico.

# data[].attributes.attachment_link.title
Curso Practico de PHP Desde Cero - 1.- Introducción

# data[].attributes.attachment_link.description
Well organized and easy to understand Web building tutorials with lots of examples of how to use HTML, CSS, JavaScript, SQL, PHP, and XML.

# data[].attributes.body
es un lenguaje de programación orientado a objetos desarrollado y estandarizado por Microsoft como parte de su plataforma .NET, que después fue aprobado como un estándar por la ECMA e ISO.

# data[].attributes.attachment_link.description
The sections below list the C# operators starting with the highest precedence to the lowest. The operators within each section share the same precedence level.

# data[].attributes.body
es el lenguaje de programación más popular para crear software de sistemas, aunque también se utiliza para crear aplicaciones.

# data[].attributes.attachment_link.readable_text
El futuro pertenece a las nuevas tecnologías. Desarrollar competencias tecnológicas es fundamental para encontrar un hueco en el mercado laboral de los próximos años ya que cada vez se demandan más perfiles digitales en todos los sectores y en empleos de nueva creación.

Entre todo este magma de nuevas posibilidades tecnológicas hay una habilidad que va a pasar a ser esencial, si es que no lo es ya: la programación. Desde una calculadora hasta un smartphone de última generación, la gran mayoría de dispositivos electrónicos que te rodean han necesitado de la programación en mayor o menor medida.

Aunque programar puede parecer complicado, hoy en día tienes a tu disposición muchos recursos para ir aprendiendo poco a poco, por tu cuenta o mediante cursos. Sin embargo, hay una decisión que tienes que tomar antes de lanzarte a aprender los secretos que permiten que tus aplicaciones favoritas funcionen, elegir un lenguaje de programación.

Hay diferentes lenguajes de programación y cada profesional tiene su favorito. La elección dependerá mucho de para qué lo quieras y de lo fácil que te resulte su uso. La compañía especialista en software, TIOBE, publica un índice con los lenguajes de programación más populares, así que lee esta lista, decídete y empieza a programar.

Java, el favorito para Android

Java se mantiene líder en la lista de este año, ya lo fue en la de 2017. Conocer Java facilita tu acceso al mundo laboral puesto que es usado por un gran número de grandes empresas y es el lenguaje más común para diseñar las aplicaciones de Android.

Según la propia web de Java, este sistema de programación cuenta con 9 millones de desarrolladores en todo el mundo.

Las principales razones detrás de la popularidad de Jave son su portabilidad, escalabilidad, sus herramientas de aplicación empresarial, su compatibilidad con distintos dispositivos y la gran comunidad de usuarios.

C, en el origen de Apple

Es uno de los lenguajes de programación más antiguos que debe su popularidad a l a adopción temprana por gigantes tecnológicos como Microsoft, Oracle y Apple. Puede funcionar con casi todos los sistemas y es muy adecuado para sistemas operativos y sistemas integrados.

C es un lenguaje muy simple de aprender ya que solo hay que dominar 32 keywords, lo que lo convierte en un lenguaje fundamental para principiantes.

Fuente: Computer Science, Fossbytes

Leer más: Educar en programación: así se enseña tecnología digital en los colegios españoles

C++, el descendiente de C

Es un spinoff de C, mucho más sencillo a la hora de programar tanto objetos como plantillas, de ahí que esté muy extendido en los entornos de escritorio.

Su flexibilidad y su buen rendimiento lo colocan en el podio, y suele ser uno de los primeros lenguajes en ser aprendido en la universidad.

Python, fácil y flexible

Muchos programadores creen que es lenguaje más fácil de usar por su código altamente legible. Está orientado a objetos pero que también se puede utilizar en el desarrollo web. Lo utilizan grandes empresas como YouTube, Reddit, Instagram, Spotify o Dropbox.

Python es de código abierto y se aprende de manera muy intuititiva. Su simplicidad no limita sus posibilidades de uso puesto que también es muy flexible y permite crear productos innovadores.

C#, el favorito de los desarrolladores de videojuegos

Este lenguaje de programación fue desarrollado por Microsoft para competir con Java. Si estás familiarizado con con C, C++ o Java, el lenguaje C# se aprende con facilidad, de hecho, su sintaxis simplifica muchas complicaciones de C++.

Se utiliza para desarrollar aplicaciones en la plataforma Microsoft y aunque puede servir para casi cualquier producto, sobre todo crea aplicaciones de escritorio para Windows y videojuegos.

Leer más: Los 14 lenguajes de programación más populares, según un estudio entre 100.000 desarrolladores

Visual Basic, simplicidad para Windows

Visual Basic mantiene la sexta posición en el ranking de este año. Destaca por su seguridad y la interoperabilidad entre lenguajes.

También es un lenguaje de Microsoft que y facilita las tareas de los programadores y mejoran la productividad. Visual Basic ofrece una manera rápida y fácil de crear aplicaciones de escritorio para la plataforma Windows, así como servicios web y desarrollo web.

PHP, perfecto para principantes

PHP a menudo se utiliza para sitios web de datos pesados ​​y desarrollo de aplicaciones. Es el lenguaje de programación que ha codificado sitios como WordPress y Facebook.

PHP es que es un lenguaje de código abierto y es fácil de aprender, características que lo convierten en candidato ideal para los principiantes.

JavaScript, un básico

JavaScript es un lenguaje de programación que se utiliza fundamentalmente para el desarrollo de páginas webs dinámicas. Aunque no aparece en la lista hasta el puesto número 8, se considera uno de los tres lenguajes que todo programador debería dominar. Se usa en WordPress, Soundcloud, Khan Academy, Linkedin, Groupon y Yahoo, entre otros.

Es uno de los programas más fáciles de aprender y es muy útil para construir sitios responsive, crear cookies o validar formularios.

Fuente: Computer Science, Fossbytes, ComputerHoy

Leer más: Mercadona busca informáticos: mencionan sueldos de hasta 5.500 euros al mes

SQL, la sorpresa del top 10

Este lenguaje de programación no llegó ni a los 20 primeros en el índice de TIOBE del año pasado y ahora ocupa la novena posición.

Esto se debe a su simplicidad y fiabilidad, y a su capacidad para tratar grandes cantidades de datos mediante el acceso y la gestión de bases de datos.

R, el futuro del Big Data

R se ha convertido en una herramienta para el tratamiento de Big Data, lo que lo convierte en uno de los lenguajes de programación con más futuro.

R se presenta como una buena opción para todo lo que implique estadísticas, representación gráfica y análisis de visualización de datos. Se compila y se ejecuta en una amplia variedad de plataformas UNIX y sistemas similares (incluidos FreeBSD y Linux), Windows y MacOS.

Ofrecido por V by Vodafone

# data[].attributes.attachment_link.title
Los 10 lenguajes de programación más utilizados del mundo

# data[].attributes.attachment_link.description
El futuro pertenece a las nuevas tecnologías. Desarrollar competencias tecnológicas es fundamental para encontrar un hueco en el mercado laboral de los próximos años ya que cada vez se demandan más perfiles digitales en todos los sectores y en empleos de nueva creación.

# data[].attributes.body
es un lenguaje de programación diseñado en 1979 por Bjarne Stroustrup. La intención de su creación fue el extender al lenguaje de programación C mecanismos que permiten la manipulación de objetos.

# data[].attributes.attachment_link.readable_text
A binary tr ee is a hierarchical data structure whose behavior is similar to a tree, as it contains root and leaves (a node that has no child). The root of a binary tree is the topmost node. Each node can have at most two children, which are referred to as the left child and the right child. A node that has at least one child becomes a parent of its child. A node that has no child is a leaf. In this tutorial, you will be learning about the Binary tree data structures, its principles, and strategies in applying this data structures to various applications.

This article is an excerpt from the book, C++ Data Structures and Algorithms, authored by Wisnu Anggoro.

Please take a look at the following binary tree:

From the preceding binary tree diagram, we can conclude the following:

The root of the tree is the node of element 1 since it's the topmost node

The children of element 1 are element 2 and element 3

The parent of elements 2 and 3 is 1

There are four leaves in the tree, and they are element 4, element 5, element 6, and element 7 since they have no child

This hierarchical data structure is usually used to store information that forms a hierarchy, such as a file system of a computer.

Building a binary search tree ADT

A binary search tree ( BST) is a sorted binary tree, where we can easily search for any key using the binary search algorithm. To sort the BST, it has to have the following properties:

The node's left subtree contains only a key that's smaller than the node's key

The node's right subtree contains only a key that's greater than the node's key

You cannot duplicate the node's key value

By having the preceding properties, we can easily search for a key value as well as find the maximum or minimum key value. Suppose we have the following BST:

As we can see in the preceding tree diagram, it has been sorted since all of the keys in the root's left subtree are smaller than the root's key, and all of the keys in the root's right subtree are greater than the root's key. The preceding BST is a balanced BST since it has a balanced left and right subtree. We also can define the preceding BST as a balanced BST since both the left and right subtrees have an equal height (we are going to discuss this further in the upcoming section).

However, since we have to put the greater new key in the right subtree and the smaller new key in the left subtree, we might find an unbalanced BST, called a skewed left or a skewed right BST. Please see the following diagram:

The preceding image is a sample of a skewed left BST, since there's no right subtree. Also, we can find a BST that has no left subtree, which is called a skewed right BST, as shown in the following diagram:

As we can see in the two skewed BST diagrams, the height of the BST becomes taller since the height equals to N - 1 (where N is the total keys in the BST), which is five. Comparing this with the balanced BST, the root's height is only three.

To create a BST in C++, we need to modify our TreeNode class in the preceding binary tree discussion, Building a binary tree ADT. We need to add the Parent properties so that we can track the parent of each node. It will make things easier for us when we traverse the tree. The class should be as follows:

class BSTNode
{
public:
    int Key;
    BSTNode * Left;
    BSTNode * Right;
    BSTNode * Parent;
};

There are several basic operations which BST usually has, and they are as follows:

Insert() is used to add a new node to the current BST. If it's the first time we have added a node, the node we inserted will be a root node.

PrintTreeInOrder() is used to print all of the keys in the BST, sorted from the smallest key to the greatest key.

Search() is used to find a given key in the BST. If the key exists it returns TRUE, otherwise it returns FALSE.

FindMin() and FindMax() are used to find the minimum key and the maximum key that exist in the BST.

Successor() and Predecessor() are used to find the successor and predecessor of a given key. We are going to discuss these later in the upcoming section.

Remove() is used to remove a given key from BST.

Now, let's discuss these BST operations further.

Inserting a new key into a BST

Inserting a key into the BST is actually adding a new node based on the behavior of the BST. Each time we want to insert a key, we have to compare it with the root node (if there's no root beforehand, the inserted key becomes a root) and check whether it's smaller or greater than the root's key. If the given key is greater than the currently selected node's key, then go to the right subtree. Otherwise, go to the left subtree if the given key is smaller than the currently selected node's key. Keep checking this until there's a node with no child so that we can add a new node there. The following is the implementation of the Insert() operation in C++:

BSTNode * BST::Insert(BSTNode * node, int key)
{
    // If BST doesn't exist
    // create a new node as root
    // or it's reached when
    // there's no any child node
    // so we can insert a new node here
    if(node == NULL)
    {
        node = new BSTNode;
        node->Key = key;
        node->Left = NULL;
        node->Right = NULL;
        node->Parent = NULL;
    }
    // If the given key is greater than
    // node's key then go to right subtree
    else if(node->Key Right = Insert(node->Right, key);
        node->Right->Parent = node;
    }
    // If the given key is smaller than
    // node's key then go to left subtree
    else
    {
        node->Left = Insert(node->Left, key);
        node->Left->Parent = node;
    }

return node; }

As we can see in the preceding code, we need to pass the selected node and a new key to the function. However, we will always pass the root node as the selected node when performing the Insert() operation, so we can invoke the preceding code with the following Insert() function:

void BST::Insert(int key)
{
    // Invoking Insert() function
    // and passing root node and given key
    root = Insert(root, key);
}

Based on the implementation of the Insert() operation, we can see that the time complexity to insert a new key into the BST is O(h), where h is the height of the BST. However, if we insert a new key into a non-existing BST, the time complexity will be O(1), which is the best case scenario. And, if we insert a new key into a skewed tree, the time complexity will be O(N), where N is the total number of keys in the BST, which is the worst case scenario.

Traversing a BST in order

We have successfully created a new BST and can insert a new key into it. Now, we need to implement the PrintTreeInOrder() operation, which will traverse the BST in order from the smallest key to the greatest key. To achieve this, we will go to the leftmost node and then to the rightmost node. The code should be as follows:

void BST::PrintTreeInOrder(BSTNode * node) { // Stop printing if no node found if(node == NULL) return; // Get the smallest key first // which is in the left subtree PrintTreeInOrder(node->Left); // Print the key std::cout Key Right); }

Since we will always traverse from the root node, we can invoke the preceding code as follows:

void BST::PrintTreeInOrder()
{
    // Traverse the BST
    // from root node
    // then print all keys
    PrintTreeInOrder(root);
    std::cout


The time complexity of the  PrintTreeInOrder() function will be  O(N), where  N is the total number of keys for both the best and the worst cases since it will always traverse to all keys.


Finding out whether a key exists in a BST


Suppose we have a BST and need to find out if a key exists in the BST. It's quite easy to check whether a given key exists in a BST, since we just need to compare the given key with the current node. If the key is smaller than the current node's key, we go to the left subtree, otherwise we go to the right subtree. We will do this until we find the key or when there are no more nodes to find. The implementation of the  Search() operation should be as follows:


BSTNode * BST::Search(BSTNode * node, int key)
{
    // The given key is
    // not found in BST
    if (node == NULL)
        return NULL;
    // The given key is found
    else if(node->Key == key)
        return node;
    // The given is greater than
    // current node's key
    else if(node->Key Right, key);
    // The given is smaller than
    // current node's key
    else
        return Search(node->Left, key);
}


Since we will always search for a key from the  root node, we can create another  Search() function as follows:


bool BST::Search(int key) { // Invoking Search() operation // and passing root node BSTNode * result = Search(root, key); // If key is found, returns TRUE // otherwise returns FALSE return result == NULL ? false : true; }


The time complexity to find out a key in the BST is  O(h), where  h is the height of the BST. If we find a key which lies in the root node, the time complexity will be  O(1), which is the best case. If we search for a key in a skewed tree, the time complexity will be  O(N), where  N is the total number of keys in the BST, which is the worst case.


Retrieving the minimum and maximum key values


Finding out the minimum and maximum key values in a BST is also quite simple. To get a minimum key value, we just need to go to the leftmost node and get the key value. On the contrary, we just need to go to the rightmost node and we will find the maximum key value. The following is the implementation of the  FindMin() operation to retrieve the minimum key value, and the  FindMax() operation to retrieve the maximum key value:


int BST::FindMin(BSTNode * node) { if(node == NULL) return -1; else if(node->Left == NULL) return node->Key; else return FindMin(node->Left); } int BST::FindMax(BSTNode * node) { if(node == NULL) return -1; else if(node->Right == NULL) return node->Key; else return FindMax(node->Right); }




We return -1 if we cannot find the minimum or maximum value in the tree, since we assume that the tree can only have a positive integer. If we intend to store the negative integer as well, we need to modify the function's implementation, for instance, by returning  NULL if no minimum or maximum values are found.




As usual, we will always find the minimum and maximum key values from the  root node, so we can invoke the preceding operations as follows:


int BST::FindMin() { return FindMin(root); } int BST::FindMax() { return FindMax(root); }


Similar to the  Search() operation, the time complexity of the  FindMin() and  FindMax() operations is  O(h), where  h is the height of the BST. However, if we find the maximum key value in a skewed left BST, the time complexity will be  O(1), which is the best case, since it doesn't have any right subtree. This also happens if we find the minimum key value in a skewed right BST. The worst case will appear if we try to find the minimum key value in a skewed left BST or try to find the maximum key value in a skewed right BST, since the time complexity will be  O(N).


Finding out the successor of a key in a BST


Other properties that we can find from a BST are the  successor and the  predecessor. We are going to create two functions named  Successor() and  Predecessor() in C++. But before we create the code, let's discuss how to find out the successor and the predecessor of a key of a BST. In this section, we are going to learn about the successor first, and then we will discuss the predecessor in the upcoming section.


There are three rules to find out the successor of a key of a BST. Suppose we have a key,  k, that we have searched for using the previous  Search() function. We will also use our preceding BST to find out the successor of a specific key. The successor of  k can be found as follows:





If k does not have a right subtree, we have to traverse the ancestors of k until we find the first node, n, which is greater than node k. After we find node n, we will see that node k is the maximum element in the left subtree of n. From our preceding BST, if k = 15, Successor(15) will give us 23 since it's the first greater ancestor compared with 15, which is 23. Please take a look at the following diagram:





If k is the maximum integer in the BST, there's no successor of k. From the preceding BST, if we run Successor(88), we will get -1, which means no successor has been found, since 88 is the maximum key of the BST.


Based on our preceding discussion about how to find out the successor of a given key in a BST, we can create a  Successor() function in C++ with the following implementation:


int BST::Successor(BSTNode * node)
{
    // The successor is the minimum key value
    // of right subtree
    if (node->Right != NULL)
    {
        return FindMin(node->Right);
    }
    // If no any right subtree
    else
    {
        BSTNode * parentNode = node->Parent;
        BSTNode * currentNode = node;


// If currentNode is not root and // currentNode is its right children // continue moving up while ((parentNode != NULL) && (currentNode == parentNode->Right)) { currentNode = parentNode; parentNode = currentNode->Parent; } // If parentNode is not NULL // then the key of parentNode is // the successor of node return parentNode == NULL ? -1 : parentNode->Key; } }


However, since we have to find a given key's node first, we have to run  Search() prior to invoking the preceding  Successor() function. The complete code for searching for the successor of a given key in a BST is as follows:


int BST::Successor(int key) { // Search the key's node first BSTNode * keyNode = Search(root, key); // Return the key. // If the key is not found or // successor is not found, // return -1 return keyNode == NULL ? -1 : Successor(keyNode); }


From our preceding  Successor() operation, we can say that the average time complexity of running the operation is  O(h), where  h is the height of the BST. However, if we try to find out the successor of a maximum key in a skewed right BST, the time complexity of the operation is  O(N), which is the worst case scenario.


Finding out the predecessor of a key in a BST





If k does not have a left subtree, we have to traverse the ancestors of k until we find the first node, n, which is lower than node k. After we find node n, we will see that node n is the minimum element of the traversed elements. From our preceding BST, if k = 29, Predecessor(29) will give us 23 since it's the first lower ancestor compared with 29, which is 23. Please take a look at the following diagram:





If k is the minimum integer in the BST, there's no predecessor of k. From the preceding BST, if we run Predecessor(3), we will get -1, which means no predecessor is found since 3 is the minimum key of the BST.


Now, we can implement the  Predecessor() operation in C++ as follows:


int BST::Predecessor(BSTNode * node)
{
    // The predecessor is the maximum key value
    // of left subtree
    if (node->Left != NULL)
    {
        return FindMax(node->Left);
    }
    // If no any left subtree
    else
    {
        BSTNode * parentNode = node->Parent;
        BSTNode * currentNode = node;


// If currentNode is not root and // currentNode is its left children // continue moving up while ((parentNode != NULL) && (currentNode == parentNode->Left)) { currentNode = parentNode; parentNode = currentNode->Parent; } // If parentNode is not NULL // then the key of parentNode is // the predecessor of node return parentNode == NULL ? -1 : parentNode->Key; } }


And, similar to the  Successor() operation, we have to search for the node of a given key prior to invoking the preceding  Predecessor() function. The complete code for searching for the predecessor of a given key in a BST is as follows:


int BST::Predecessor(int key) { // Search the key's node first BSTNode * keyNode = Search(root, key); // Return the key. // If the key is not found or // predecessor is not found, // return -1 return keyNode == NULL ? -1 : Predecessor(keyNode); }


Similar to our preceding  Successor() operation, the time complexity of running the  Predecessor() operation is  O(h), where  h is the height of the BST. However, if we try to find out the predecessor of a minimum key in a skewed left BST, the time complexity of the operation is  O(N), which is the worst case scenario.


Removing a node based on a given key


The last operation in the BST that we are going to discuss is removing a node based on a given key. We will create a  Remove() operation in C++. There are three possible cases for removing a node from a BST, and they are as follows:


Removing a leaf (a node that doesn't have any child). In this case, we just need to remove the node. From our preceding BST, we can remove keys 7, 15, 29, and 53 since they are leaves with no nodes.


Also, similar to the  Search() operation, if the target node doesn't exist, we just need to return  NULL. The implementation of the  Remove() operation in C++ is as follows:


BSTNode * BST::Remove(
    BSTNode * node,
    int key)
{
    // The given node is
    // not found in BST
    if (node == NULL)
        return NULL;


// Target node is found if (node->Key == key) { // If the node is a leaf node // The node can be safely removed if (node->Left == NULL && node->Right == NULL) node = NULL; // The node have only one child at right else if (node->Left == NULL && node->Right != NULL) { // The only child will be connected to // the parent's of node directly node->Right->Parent = node->Parent;


// Bypass node node = node->Right; } // The node have only one child at left else if (node->Left != NULL && node->Right == NULL) { // The only child will be connected to // the parent's of node directly node->Left->Parent = node->Parent;


// Bypass node node = node->Left; } // The node have two children (left and right) else { // Find successor or predecessor to avoid quarrel int successorKey = Successor(key); // Replace node's key with successor's key node->Key = successorKey;


// Delete the old successor's key node->Right = Remove(node->Right, successorKey); } } // Target node's key is smaller than // the given key then search to right else if (node->Key Right = Remove(node->Right, key); // Target node's key is greater than // the given key then search to left else node->Left = Remove(node->Left, key); // Return the updated BST return node; }


Since we will always remove a node starting from the  root node, we can simplify the preceding  Remove() operation by creating the following one:


void BST::Remove(int key)
{
    root = Remove(root, key);
}


As shown in the preceding  Remove() code, the time complexity of the operation is  O(1) for both case  1 (the node that has no child) and case  2 (the node that has only one child). For case  3 (the node that has two children), the time complexity will be  O(h), where  h is the height of the BST, since we have to find the successor or predecessor of the node's key.


If you found this tutorial useful, do check out the book  C++ Data Structures and Algorithms for more useful material on data structure and algorithms with real-world implementation in C++.


Read next

# data[].attributes.attachment_link.title
Build a C++ Binary search tree [Tutorial] | Packt Hub

# data[].attributes.attachment_link.description
A binary tr ee is a hierarchical data structure whose behavior is similar to a tree, as it contains root and leaves (a node that has no child). The root of a binary tree is the topmost node. Each node can have at most two children, which are referred to as the left child and the right child.

# data[].attributes.body
es un lenguaje de programación interpretado cuya filosofía hace hincapié en una sintaxis que favorezca un código legible.

# data[].attributes.attachment_link.title
Tutorial Python 1: Introducción al Lenguaje de Programación

# data[].attributes.attachment_link.readable_text
Python 3.7 estaba, hasta hace poco, en la versión denominada "candidate release", pero ya pasó a su estado de versión oficial 3.7. Desde luego que esto no ha sido un camino fácil. Pasar de la versión 2 a la 3 ha llevado tiempo y un sinfín de contratiempos. Pero quien siga usando versiones anteriores a la 3 debería de reconsiderarlo porque Python 3.7 ya es una versión madura. Y de alguna manera, el lenguaje está empezando a convertirse en un clásico.
DevTube: una colección de videos para programadores
Lo nuevo en la versión 3.7 empieza con las nuevas "data classes", las cuales son clases que permiten almacenar datos. Por ejemplo, en C se usa "struct" o en Pascal "record". Java ya está en proceso de tener estas "data classes" y Kotlin ya las tiene definitivamente. Las nuevas clases en Python es una manera de crear clases listas para usarse con datos. Simplemente se añade @dataclass frente a una definición de clase y entonces se listan todos los campos que se desean usar. Cada campo es un nombre de una variable seguido por una anotación de su tipo. El sistema (decorator) convierte esto en una definición de clases con su correspondiente init de manera que el programador pueda inicializar correctamente los datos cuando se crea finalmente la instancia. Se puede modificar la manera en que los campos son creados usando la función de ayuda del "helper". Lo que es impresionante es que este tipo de datos se implementó usando solamente Python.

Con respecto a las anotaciones de tipos, la versión 3.7 añade referencias hacia adelante "forward" y mejora la velocidad de la operación. Y aunque tiene algunas dificultades, por ejemplo, cuando se describe la firma de una función, ésta se puede hacer mucho más compleja muy pronto, la idea puede ser funcional. Tendrá que ponerse más en práctica para ver la bondad de esta idea.

Otra característica nueva es la capacidad de trabajar con atributos definidos en módulos. Ahora se puede usar getattr__and__dir en los módulos. Esto, lógicamente, hace que los módulos se vean como clases "más grandes", lo cual es realmente así. Por otra parte, se ha incrementado la precisión del paquete de rutinas que manejan el tiempo. Por ejemplo, se pueden usar las funciones del módulo de tiempo para ganar precisión hasta nanosegundos, que regresan como si fuesen enteros.

Hay otras mejoras, que no son espectaculares, pero que se ven importantes:

El orden del Diccionario se especifica ahora como parte del lenguaje y los iteratores trabajan en el orden en el que los objetos se han añadido.

"async" y "wait" son palabras reservadas que si se usan como variables con esos nombres, le causarán problemas seguramente.

Se ha mejorado el módulo "aysncio".

Nuevas variables de contexto proveen almacenamiento de los threads locales para las tareas asíncronas.

Un nuevo API de C para el almacenamiento de los threads locales.

Finalmente, esta nueva versión mejora la velocidad de llamado a la biblioteca estándar. Las llamadas a los métodos son más rápidas y el startup es más rápido también.

# data[].attributes.attachment_link.description
Python 3.7 estaba, hasta hace poco, en la versión denominada "candidate release" , pero ya pasó a su estado de versión oficial 3.7. Desde luego que esto no ha sido un camino fácil. Pasar de la versión 2 a la 3 ha llevado tiempo y un sinfín de contratiempos.

# data[].attributes.body
es un lenguaje de programación de propósito general, concurrente, orientado a objetos, que fue diseñado específicamente para tener tan pocas dependencias de implementación como fuera posible.

# data[].attributes.attachment_link.title
Curso Java desde cero  #1 | Introducción e instalación de JDK

# data[].attributes.attachment_link.readable_text
Escrito por

Java es una de las plataformas informáticas más populares. Son muchos los programas y servicios basados en este sistema. Sin embargo en los últimos tiempos no cuenta con demasiados amigos. El motivo es por las brechas de seguridad y las vulnerabilidades que tiene. Hay quienes incluso recomiendan deshabilitar o desinstalarlo completamente del equipo. Pero la realidad es que son muchas aplicaciones y sitios web que funcionan gracias a esta plataforma. En este artículo vamos a explicar cómo utilizar Java de forma segura en Windows 10 y así no comprometer nuestro equipo.

Cómo utilizar Java de forma segura

Es muy común encontrarnos con noticias relacionadas con vulnerabilidades y errores de Java. Fallos que pueden poner en riesgo la seguridad de los usuarios. Es por ello que conviene tener en cuenta algunos consejos y buenos hábitos para preservar el buen funcionamiento de nuestros equipos. Además, incluso puede llegar a provocar filtraciones de datos.

Tener la última versión

Lo primero que debemos tener es la última versión de la plataforma instalada. Como sabemos, en ocasiones surgen amenazas y vulnerabilidades que pueden comprometer los sistemas. Normalmente aparecen parches que pueden solucionar estos problemas.

Por tanto es muy importante tener la última versión instalada y no estar utilizando una anticuada que pueda comprometer nuestra seguridad.

Para ello simplemente hay que ir a Inicio y acceder al Panel de control (lo escribimos en la barra de búsqueda). Nuevamente en la barra de búsqueda escribimos Java y accedemos. Una vez dentro vamos a la pestaña Actualizar, donde podemos comprobar actualizaciones de forma automática. De esta manera, al marcarlo así, nos aseguramos de tener siempre la última versión instalada.

Nivel de seguridad

No siempre cuando accedemos a una página es segura. Puede que se inicie Java en un sitio que no sea confiable. Para evitar que se inicie en sitios que puedan causar problemas, es importante marcar el nivel de seguridad. Este nivel puede ser bajo, medio, alto o muy alto.

Si por ejemplo optamos por establecer el nivel de seguridad para la aplicación como Muy alto, solo la aplicación Java certificada por una autoridad de confianza podrá ejecutarse. Si el nivel de seguridad de una aplicación es Alto, la aplicación Java certificada por una autoridad de confianza podrá ejecutarse aunque no se verifique el estado de revocación del certificado.

Dejarlo en medio o bajo significa que nuestro equipo puede ser vulnerable a ataques de seguridad.

Para establecer un nivel hay que ir a la pestaña de seguridad y seleccionar alta o muy alta. De esta manera podremos proteger más nuestro equipo.

Indicaciones de seguridad

Antes de iniciar Java en el navegador aparece un mensaje que nos muestra el riesgo. Nos solicita confirmación antes de abrirlo. Esto significa que, en caso de que aparezca un mensaje de riesgo alto, no ejecutarlo.

También es aconsejable restaurar las solicitudes de seguridad periódicamente. Para ello nuevamente vamos a la pestaña de Seguridad y, debajo, encontraremos Restaurar Peticiones de Datos de Seguridad.

De esta manera podremos utilizar Java de manera más segura en Windows 10.

# data[].attributes.attachment_link.title
Cómo usar Java en Windows 10 sin poner en peligro tu ordenador

# data[].attributes.attachment_link.description
Escrito por Java es una de las plataformas informáticas más populares. Son muchos los programas y servicios basados en este sistema. Sin embargo en los últimos tiempos no cuenta con demasiados amigos. El motivo es por las brechas de seguridad y las vulnerabilidades que tiene. Hay quienes incluso recomiendan deshabilitar o desinstalarlo completamente del equipo.

# data[].attributes.body
es un lenguaje formal que especifica una serie de instrucciones para que una computadora produzca diversas clases de datos.

# data[].attributes.attachment_link.readable_text
A diario interactuamos con distintos tipos de máquinas como celulares, tablets y computadores. Todos ellos tienen un lenguaje de programación que ayuda a traducir las órdenes del usuario para que pueda utilizarlos.

Un lenguaje de programación es básicamente un sistema estructurado de comunicación, similar al humano, el cual nos permite comunicarnos por medio de signos, ya sean palabras, sonidos o gestos. Refiriéndonos a los aparatos, este sistema está organizado para que se entiendan entre sí y a su vez interprete las instrucciones que debe ejecutar.

El término programación se define como un conjunto de instrucciones consecutivas y ordenadas que llevan a ejecutar una tarea específica. Dichas instrucciones se denominan "código fuente", el cual es único para cada lenguaje y está diseñado para cumplir una función o propósito específico. Usan diferentes normas o bases para controlar el comportamiento de un dispositivo y también pueden ser usados para crear programas informáticos. En la actualidad, hay más de cien lenguajes de programación diferentes, estos se clasifican en dos tipos principales:

1. Lenguajes de programación de bajo nivel. Son aquellos utilizados para controlar el hardware (partes tangibles) del aparato y dependen directamente de la máquina, es decir, que no pueden ser usados en aparatos diferentes para los que fueron creados. Estos lenguajes son los que ordenan las operaciones esenciales para el funcionamiento del dispositivo. También es conocido como código máquina. Su funcionamiento es complejo, por lo que lo utilizan principalmente los fabricantes de hardware. Con ellos se pueden programar tareas como reproducción de audio o video, mostrar imágenes, realizar operaciones matemáticas, movimiento del puntero, asignación, liberación de memoria, entre otras.

2. Lenguajes de programación de alto nivel. Estos lenguajes son más parecidos al humano. No dependen de la máquina y sirven principalmente para crear programas informáticos que puedan solucionar distintos tipos de necesidades.

Ahora bien, algunos de los lenguajes de programación más utilizados son SQL, PHP, C y Java.

* SQL: son las siglas de Structured Query Language (Lenguaje Estructurado de Consulta). Su función principal es actuar sobre una base de datos y extraer su contenido para almacenar, introducir, actualizar, eliminar y consultar información. Suele ser usado en la construcción de páginas web y aplicaciones de escritorio.

* PHP: es un acrónimo recursivo que significa PHP Hypertext Pre-processor. Es utilizado para el desarrollo de sitios online, ya que es posible combinarlo con HTML. Es un lenguaje de lado del servidor, es decir, que primero se ejecuta en éste y posteriormente regeresa al navegador del usuario como resultado una página web.

* C: lenguaje orientado principalmente a los sistemas operativos. Se puede crear un software para sistemas operativos como Windows o Linux, también es muy usado en robótica para crear simuladores o para experimentos informáticos, físicos, matemáticos, etc.

* Java: es uno de los lenguajes favoritos ya que permite construir programas que gestionan la memoria del dispositivo donde reside la aplicación, como por ejemplo herramientas, juegos y apps. Es utilizado en dispositivos móviles, aparatos de televisión y computadores personales. Suele ser asociado a Java Script, que es otro tipo de lenguaje para crear pequeños programas encargados de realizar acciones dentro de páginas webs, como por ejemplo crear efectos especiales o para definir la interactividad con los usuarios.

Con esto nos damos una idea del sistema con el que funcionan muchas de las aplicaciones que usamos a diario y, aunque son diferentes, casi todos los lenguajes de programación tienen fundamentos o bases comunes que hacen que aprenderlo sea fácil, una vez se conoce lo básico. Si quiere saber más sobre el tema, es necesario ahondar en este mundo y entender por qué cuando en un juego presiona el botón 'Play' puede empezar a jugar.

Vea más en nuestro especial del mes ¿Por qué es importante aprender a programar?

# data[].attributes.attachment_link.title
Lenguajes de programación: ¿qué son y para qué sirven?

# data[].attributes.attachment_link.description
A diario interactuamos con distintos tipos de máquinas como celulares, tablets y computadores. Todos ellos tienen un lenguaje de programación que ayuda a traducir las órdenes del usuario para que pueda utilizarlos. Un lenguaje de programación es básicamente un sistema estructurado de comunicación, similar al humano, el cual nos permite comunicarnos por medio de signos, ya sean palabras, sonidos o gestos.