layout – vertical and horizontal scroll patterns

I saw websites with horizontally scrolling content as the main content. For example, Trello and Jira have many pillars that extend horizontally. You can then scroll on the page. I've always heard that websites should be infinite in a vertical direction, and that was the pattern to follow. I would assume that it would be easier to follow a vertical pattern and use regular scrolling than to have to adapt to horizontal scrolling.

I wonder if there is a vertical pattern that could be used in these cases or if it is now just a standard that supports horizontal scrolling.

The horizontal position of two cells returns the same result for cells in different columns in Word VSTO

I compared the results of reading (x, y) coordinates of different cells for two different tables. On the one hand, it works perfectly – both x and y are read correctly, on the other hand, x should be different, but is the same for two cells. I am sure that I have selected the right cells because their text is correct (including their height and width). Both tables have no empty cells and the indexes are correct. I also tried the cell selection approach above Cell.Select () and then reading the vertical / horizontal position from the selected area. The result is the same.

Read code vertical and horizontal position of the cell (for different values ​​of the index):

var y = table.Range.Cells(index).Range.
                Information(WdInformation.wdVerticalPositionRelativeToPage);
var x = table.Range.Cells(index).Range.
                Information(WdInformation.wdHorizontalPositionRelativeToPage);

Website Design – Room Reservation & Availability Horizontal Scroll

I am designing a web application for room booking / availability.

Some of the application specifications are:

  • There are 30 rooms (over three floors, in the same building)
  • Rooms are occupied differently (1 – 20)
  • Users can only book within a 24 hour period (i.e. if I am in the app today at 3:00 p.m., I can view / book rooms until 3:00 p.m. tomorrow).
  • Users can book in 30 minute or 1 hour increments
  • Users should be able to filter results

I created a quick model of a design that I think might work (I edited a design from another question here). Room names left vertically, times and availability horizontally.

The room column contains the date, floor, room number, occupancy number and info symbol (if you click on it, details about the room and possibly picture etc. will be displayed).

The time series contains time and status.

Enter image description here

The idea is that users can scroll horizontally and vertical, but the space column on the left remains in a Firmly Position when scrolling horizontally.

If the floor and occupancy filters are selected, the data in the table change dynamically and only show this information.

On smaller screens, I imagine that instead of 8 columns, 3 or 4 etc. are displayed dynamically and the line on the far left remains fixed.

I have a few questions;

  • can anyone see any problems with the proposed design
  • Should I allow individual lines to be scrolled or should all lines be scrolled?
  • Suggestions on how this design could be improved
  • For some reason it wouldn't work on a smaller screen

I have to put the red in somewhere because it's the brand color, open to suggestions on the other things.

sharepoint enterprise – Implementation of global horizontal navigation in SP Masterpage css issue

Hard to say what you mean, since the example provided seems to be okay and you say that works the same way in SharePoint? But reading between the lines, I think, maybe I know.

In your CSS you have .dropdown-content{position:absolute;} but the question is always absolutely in terms of what? This explains how absolute positioning works.

An element with position: absolute; is positioned relative to that
nearest ancestor (instead of relative to
Viewport as fixed).

However; if an absolutely positioned element has not positioned
Ancestors it uses the document text and moves with the page
Scroll.

Basically, I translate it like this: "It searches the parent / parent until it finds an item that has a different position value than it does static and if it does not find one, the body tag is used. "

I think you absolutely want to position them in terms of .dropdown Elements over which you hover. In the case of your codepen example, there is no position attribute for .dropdown (so it has the default value of static), so it uses the body as a reference. This works perfectly in your sample because your Navi is 0 in the body. However, in SharePoint this is not the case – you have the suite bar and probably other things as well …

So I suspect that the dropdown content items will appear floating, but they are positioned where you can not see them.

I think you have to add Position: relative to the parent containers. But I'm not sure if that's the only solution. I'm not sure why there are so many things that also have an overflow.

CSS – How do "remove" WordPress categories UL and make the list loop in a horizontal line?

When you list categories in WordPress, they are looped over an array as follows:

             
  • catgory1

In fact, the class in question

    Can anyone imagine a way to remove them and display them horizontally so they look like this:

    Apples, pears, bananas, peaches etc?

    One solution is to mess around with the core files, but that's never a good idea, right?

google sheets – Change javascript for interpolation from vertical to horizontal

I want to let this script work horizontally.

This code comes from a different answer here, but I could not let it work horizontally. I have to use it in a row across columns and calculate gaps in records.

I have no idea what I am doing and make a mess every time I try to edit it.

function onOpen() {
  SpreadsheetApp.getActiveSpreadsheet().addMenu("Custom", ({name: "Interpolate",  functionName: "interpolate"}));
}

function interpolate() {
  var ss = SpreadsheetApp.getActiveSpreadsheet();
  var sheet = ss.getActiveSheet();
  var height = sheet.getDataRange().getHeight();
  var cell = sheet.getActiveCell();
  if (cell.getValue() !== '') {
    return;
  }
  var row = cell.getRow();
  var column = cell.getColumn()
  var values = sheet.getRange(1, column, height, 1).getValues();
  for (var i=row-1; i>1; i--) {
    if (values(i-1)(0) !== '') {
      break;
    }
  }
  for (var j=row+1; j

css – React – Is it possible to provide React-Bootstrap Row with N (more than 12) columns with horizontal overflow?

I'm trying to create a form in React that follows exactly the picture in this link. I try to do this through React Bootstrap.

In the gray areas I want to allow horizontal scrolling. Right now I'm just concentrating on the top gray area where there are only one row but N columns. I expect more than 12 columns and want each column to be in the same row.

I'm trying to use bootstrap to accomplish this by doing a Row that contains a Col that contains a Col and styling the Row to have {overflowX: "auto"} but the columns move to a new line. I know Bootstrap includes columns in a new line, but I just want it to overflow so I can scroll.

I've written code to highlight what I want to achieve on the first line (in my chart): https://codesandbox.io/s/bitter-shadow-wzv7r?fontsize=14

Is there a way to do this through React Bootstrap, or is there another way to do that?

Matrices – How to make a tree in C horizontal?

ORIGINAL IDEA: The idea was to get an array of each number to be displayed on the INORDEN tour. Generate a matrix by row width (number of nodes) and by rows (height). To display them in the matrix, use the index that traverses the array and the level of that node to place them in the matrix and then display them on the screen.

//               (8)
//             /      
//           6         10
//          /         / 
//         4    7     9   11
//        /   /    /  /  
//       1   5               13
//      /  /              /  
//                         12

The idea is to show it this way, I've tried different alternatives with matrices and recursive solutions. Thanks in advance, any help can help me

I leave the code

/*
    Codigo de Arbol AVL
    Implementado por: Ulises Rodriguez y Josue Rojas
*/

#include
#include

//utilidades
#define TRUE 1
#define FALSE 0

//definicion de TAD
typedef struct ArbolAVL {
    int valor; // valor principal
    struct ArbolAVL *izq; // lado izquierdo
    struct ArbolAVL *der; // lado derecho
    int altura; // altura del nodo
}ArbolAVL;

// declaracion de funciones
ArbolAVL *crearArbol(int);
ArbolAVL *insertarArbolAVL(ArbolAVL *,int);
ArbolAVL *eliminarArbolAVL(ArbolAVL *,int);
void mostrarArbolAVL(ArbolAVL *,int);
void mostrarPreOrden(ArbolAVL *);
void mostrarInOrden(ArbolAVL *);
void mostrarPostOrden(ArbolAVL *);
int profundidad( ArbolAVL *);
ArbolAVL *rotarDerecha(ArbolAVL *);
ArbolAVL *rotarIzquierda(ArbolAVL *);
ArbolAVL *rotarSimpleIzquierda(ArbolAVL *);
ArbolAVL *rotarSimpleDerecha(ArbolAVL *);
ArbolAVL *rotarDobleDerecha(ArbolAVL *);
ArbolAVL *rotarDobleIzquierda(ArbolAVL *);
int calcularFactorBalance(ArbolAVL *);
int contieneElemento(ArbolAVL *, int);
ArbolAVL *buscarNodo(ArbolAVL *, int);
int cantidadNodos(ArbolAVL *);
int buscarNivel(ArbolAVL *, int, int);
ArbolAVL *copiarArbol(ArbolAVL*);

ArbolAVL *ARBOL = NULL;


/*COPIAR ARBOL DADO*///////////////////////////////////////////////////////////////
ArbolAVL *copiarArbol(ArbolAVL *ARBOL) {
    if(ARBOL) { // si el arbol existe
        ArbolAVL *copia = (ArbolAVL *) malloc(sizeof(ArbolAVL)); // reservamos espacio en memoria
        copia->der = ARBOL->der; // igualamos el lado derecho
        copia->izq = ARBOL->izq; // igualamos el lado izquierdo
        copia->valor = ARBOL->valor; // igualamos su dato

        // igualamos cada dato del arbol

        return copia; // retornamos la copia de ese valor
    } return NULL;   // en caso no haber arbol por copiar 
}

ArbolAVL *crearArbol(int valor) {
    ArbolAVL *nuevo = (ArbolAVL *) malloc(sizeof(ArbolAVL));
    nuevo->valor = valor;
    nuevo->der = nuevo->izq = NULL;
    return nuevo;
}

/**BUSCAR NODO Y RETORNARLO*//////////////////////////////////////////////////////
int buscarNivel(ArbolAVL *ARBOL, int valor, int nivel) {
    if (ARBOL) { // si hay arbol para buscar el valor
        if (ARBOL->valor == valor) // si corresponde el valor, se retorna el nivel
            return nivel;   
        else {
            if (valor > ARBOL->valor) // si es mayor se busca por lado derecho
                return buscarNivel(ARBOL->der, valor, nivel+1);
            else // si es menos o igual por el lado izquierdo
                return buscarNivel(ARBOL->izq, valor, nivel+1);
        }
    } else
        return -1; // sino existe en el arbol
}

void imprimirMenu() {
    // menu principal
    printf("nn--------------------------------------n");
    printf("(ArbolAVL):                           n");
    printf(" (1).Insertar Raiz                        n");
    printf(" (2).Insertar Elemento                    n");
    printf(" (3).Borrar Nodo                          n");
    printf(" (4).Buscar Elemento                      n");
    printf(" (5).Mostrar ArbolAVL                     n");
    printf(" (6).Mostrar preorden                     n");
    printf(" (7).Mostrar inorden                      n");
    printf(" (8).Mostrar postorden                    n");
    printf(" (9).Salir                               n");
    printf("--------------------------------------nn");
}

void ingresoNumero(int *n) {
    int bandera; // representa la entrada correcta del dato
    printf("Ingrese un numero enteron");
    do { // mientras la entrada no sea valida
        bandera = scanf("%i", &(*n));
        if (bandera == 0) { // caso donde la entrada sea invalida
            getchar();
            printf("Ingrese un numero entero valido:n");
            continue; // vuelve a preguntar
        }
    } while (bandera == 0);
}

void mostrar(ArbolAVL *ARBOL) {
    // muestra un encabezado para la visualizacion del arbol
    printf("n**************************************nn");
    printf("Mostrando ARBOL:                  n");
    if (ARBOL != NULL) mostrarArbolAVL(ARBOL, 0); // si existe el arbol lo muestra
    else printf("El ARBOL esta vacio"); // sino da el mensaje
    printf("nn**************************************n");
}

/**BUSCAR NODO Y RETORNAR SI ESTA O NO*////////////////////////////////////////////
int contieneElemento(ArbolAVL *ARBOL, int valor) {
    if (ARBOL) { // si hay donde buscar
        if (ARBOL->valor == valor) // si es el valor correcto
            return TRUE; // caso existe en el arbol
        else {
            if (!contieneElemento(ARBOL->der, valor)) // busca al lado derecho
                if (!contieneElemento(ARBOL->izq, valor)) // busca al lado izquierdo
                    return FALSE; // caso no existe en el arbol
        }
    } else 
        return FALSE; // no hay donde buscar
}

/**BUSCAR NODO Y RETORNARLO*//////////////////////////////////////////////////////
ArbolAVL *buscarNodo(ArbolAVL *ARBOL, int valor) {
    if (ARBOL) { // si hay arbol en donde buscar
        if (ARBOL->valor == valor) // si se encuentra se retorna una copia de ese arbol
            return copiarArbol(ARBOL);
        else { // si no es el arbol que corresponde
            if (!buscarNodo(ARBOL->der, valor)) // se busca al lado derecho
                if (!buscarNodo(ARBOL->izq, valor)) // se busca al lado izquierdo
                    return NULL; // caso donde no se encuentre en el arbol
        }
    } return NULL; // sino hay arbol a buscar, no existe el valor
}

void mostrarBusqueda(ArbolAVL *arbol, int n, int valorBuscado) {
    if (!arbol) // si no hay arbol a mostrar
        return;
    else { // si hay arbol a mostrar
        mostrarBusqueda(arbol->der, n+1, valorBuscado); // muestra por el lado derecho
        for (int i=0; ivalor != valorBuscado) printf("%dn", arbol->valor); // si no es el buscado, solo se muestra
        else printf("(%d)n", arbol->valor); // si es el valor buscado, lo encierra
        mostrarBusqueda(arbol->izq, n+1, valorBuscado); // muestra por el lado izquierdo
    }
}

/*CANTIDAD DE NODOS*///////////////////////////////////////////////////////////////
int cantidadNodos(ArbolAVL *ARBOL) {
    if (ARBOL) // si existe arbol por contar, se retorna 1 (se cuenta a si mismo) y la suma de su lados
        return 1 + cantidadNodos(ARBOL->izq) + cantidadNodos(ARBOL->der);
    else
        return 0;  // si no hay arbol no se cuenta
}


void mostrarDatosNodo(ArbolAVL *raiz, ArbolAVL *ARBOL) {
    if (ARBOL) { // si hay arbol a mostrar
        // datos a mostrar del nodo
        printf("n(Nodo (%d): nivel(%d), altura(%d), cantidadNodosHijos(%d))", 
            ARBOL->valor, buscarNivel(raiz, ARBOL->valor, 0), profundidad(ARBOL)-1, cantidadNodos(ARBOL)-1 );
    }
}

int main() {
    extern ArbolAVL *ARBOL;
    char opcion(100); // buffer de entrada del usuario
    int opcionMenu; // entrada del usuario, uso del menu

    do { 
        imprimirMenu();
        fgets(opcion,100,stdin); // recibe los caracteres de entrada del usuario
        opcionMenu = atoi(opcion); // toma el numero encontrado en la cadena
        switch(opcionMenu) { // segun la opcion dada
            case 1:  /*insertarRaiz*/
                if (!ARBOL) { // si no existe el arbol
                    int numero; 
                    ingresoNumero(&numero); // entrada de usuario
                    ARBOL = crearArbol(numero); // inicializa el arbol con el valor dado
                    mostrar(ARBOL); // muestra el arbol
                    getchar();
                } else // caso donde ya existe una raiz 
                    printf("Ya se ha ingresado una raizn"); 
            break;

            case 2: /*insertar*/
                if (ARBOL) { // si existe el arbol
                    int numero;
                    ingresoNumero(&numero); // entrada de usuario
                    if (contieneElemento(ARBOL, numero)){
                        printf("Ya existe este elemento en el arbol");        
                    }
                    else{
                        ARBOL = insertarArbolAVL(ARBOL, numero); // insertar el valor en el arbol
                        mostrar(ARBOL); // muestra el arbol
                    }
                } else // caso donde el arbol no exista aun
                    printf("Debe ingresar la raiz primeron");
                getchar();
            break;

            case 3: // eliminar
                if (!ARBOL)// sino existe el arbol
                    printf("Debe ingresar la raiz primeron");
                else { // si el arbol ya existe
                    int eliminar;
                    ingresoNumero(&eliminar); // entrada del usuario
                    eliminarArbolAVL(ARBOL, eliminar); // elimina el valor dado
                    mostrar(ARBOL); // muestra el arbol
                    getchar();
                }
            break;

            case 4: // buscar
                if (!ARBOL) { // si no hay arbol donde buscar
                    printf("Debe ingresar la raiz primeron");
                } else { // si hay arbol donde buscar
                    int busqueda;
                    ingresoNumero(&busqueda); // entrada del usuario
                    ArbolAVL *nodoBuscado = buscarNodo(ARBOL, busqueda); //guarda el nodo buscado
                    if (nodoBuscado) { // si lo encontro
                        printf("n");
                        mostrarBusqueda(ARBOL, 0, nodoBuscado->valor); // muestra entre (x), donde x es el valor buscado
                        mostrarDatosNodo(ARBOL, nodoBuscado); // muestra los datos referentes al arbol
                    } else // sino lo encuentra
                        printf("No se ha encontrado el nodo solicitadon");
                }
                getchar();
            break;

            case 5: // mostrar ARBOL
                if (!ARBOL)// si no hay arbol a mostrar
                    printf("Arbol vacio: Debe ingresar la raiz primeron");
                else // si hay arbol a mostrar
                    mostrar(ARBOL);
                getchar();
            break;

            case 6: // mostrar preorden
                if (!ARBOL) // si no hay arbol a mostrar
                    printf("Debe ingresar la raiz primeron");
                else { // si hay arbol a mostrar
                    printf("Preorden: ");
                    mostrarPreOrden(ARBOL);
                    printf("n");
                }
            break;

            case 7: // mostrar inorden
                if (!ARBOL) // si no hay arbol a mostrar
                    printf("Debe ingresar la raiz primeron");
                else { // si hay arbol a mostrar
                    printf("Inorden: ");
                    mostrarInOrden(ARBOL);
                    printf("n");
                }
            break;

            case 8: // mostrar postorden
                if (!ARBOL)// si no hay arbol a mostrar
                    printf("Debe ingresar la raiz primeron");
                else { // si hay arbol a mostrar
                    printf("Postorden: ");
                    mostrarPostOrden(ARBOL);
                    printf("n");
                }
            break;

            case 9: // salir del programa
                printf("nHa salido del programan"); 
            break;

            default: { // caso de una opcion que no corresponda a las mostradas
                printf("Opcion inválida");
            }
        }
        getchar(); // espera una tecla por parte del usuario
        system("clear"); // limpia la pantallar
    } while (opcionMenu != 9); // se ejecuta mientras la opcion no corresponda a salir

}

ArbolAVL * insertarArbolAVL(ArbolAVL *arbol, int valor) {
    if(arbol == NULL) { // si no hay arbol
        arbol = crearArbol(valor); // crea uno nuevo
    } else if(valor > arbol->valor) {   // insertar al lado derecho del arbol
        arbol->der = insertarArbolAVL(arbol->der,valor); // se agrega el valor y se procede a revisar
        if(calcularFactorBalance(arbol) == -2) // si su factor de balance no esta entre (-1, 1)
            if(valor > arbol->der->valor) // se coloca a la derecha
                arbol = rotarSimpleIzquierda(arbol); // rotacion simple izquierda
            else
                arbol = rotarDobleIzquierda(arbol); // rotacion doble izquierda
    } else if(valor < arbol->valor) {  // se coloca a la izquierda
        arbol->izq = insertarArbolAVL(arbol->izq,valor); // se agrega el valor y se procede a revisar
        if(calcularFactorBalance(arbol) == 2) // si su factor de balance no esta entre (-1, 1)
            if(valor < arbol->izq->valor)
                arbol = rotarSimpleDerecha(arbol); // rotar simple derecha
            else
                arbol = rotarDobleDerecha(arbol); // rotar doble derecha
    }
    arbol->altura = profundidad(arbol); // se calcula la profundidad
    return(arbol);
}

ArbolAVL * eliminarArbolAVL(ArbolAVL *arbol,int valor) {
    ArbolAVL *aux; // auxiliar para iterar
    if(!arbol) // si no hay arbol 
        return NULL;
    else
        if(valor > arbol->valor) {  // si el valor a borrar es mayor se mueve a la derecha
            arbol->der = eliminarArbolAVL(arbol->der,valor); 
            if(calcularFactorBalance(arbol) == 2) // si su factor de balance no esta entre (-1, 1s)
                if(calcularFactorBalance(arbol->izq) >= 0) // segun el factor de balance del izquierdo
                    arbol = rotarSimpleDerecha(arbol); // rotacion simple a la derecha
                else
                    arbol=rotarDobleDerecha(arbol); // rotacion doble a la derecha
        } else if(valor < arbol->valor) { // si el valor a borrar es menor
                arbol->izq = eliminarArbolAVL(arbol->izq,valor); // nos movemos a la izquierda
                if(calcularFactorBalance(arbol) == -2)  // si su factor de balance es -2, rotacion izquierda
                    if(calcularFactorBalance(arbol->der) <= 0) // si su factor de balance esta entre (-2, 0)
                        arbol = rotarSimpleIzquierda(arbol); // rotamos simple derecha
                    else
                        arbol = rotarDobleIzquierda(arbol); // rotamos doble derecha
        } else { // si encontramos el valor
            if(arbol->der != NULL) { // si su rama derecha existe
                aux = arbol->der; // para iterar
                while(aux->izq) // mientras exista rama izquierda
                    aux = aux->izq; // se mueve a la izquierda
                arbol->valor = aux->valor;
                arbol->der = eliminarArbolAVL(arbol->der,aux->valor); //eliminarArbolAVL en mostrarInOrden
                if(calcularFactorBalance(arbol) == 2) // si su factor de balance es 2, rotacion derecha
                    if(calcularFactorBalance(arbol->izq) >= 0) // si el factor de balance de su rama izquierda es mayor a 0
                        arbol = rotarSimpleDerecha(arbol); // rotacion simple derecha
                    else
                        arbol = rotarDobleDerecha(arbol); // rotacion doble derecha
            } else // si no existe el lado derecho
                return(arbol->izq);
        }
    arbol->altura = profundidad(arbol); // calculamos su profundidad
    return(arbol);
}

int profundidad(ArbolAVL *arbol) {
    int alturaIzquierda,alturaDerecha; // variables locales para ambos lados
    if(!arbol) // si no hay arbol 
        return 0;
    if(!arbol->izq) // si no hay arbol izquierdo
        alturaIzquierda = 0; // 
    else // si existe el lado izquierdo
        alturaIzquierda = 1 + arbol->izq->altura; 

    if(!arbol->der) // si no hay arbol derecho
        alturaDerecha = 0; 
    else // si hay arbol derecho
        alturaDerecha= 1 + arbol->der->altura;

    if(alturaIzquierda > alturaDerecha) // def: 1 + max(alturaDer, alturaIzq)
        return alturaIzquierda; // caso izquierda de mayor altura
    return(alturaDerecha); // caso derecha o altura 0
}

ArbolAVL * rotarDerecha(ArbolAVL *valor) {
    ArbolAVL *aux; // auxiliar
    aux = valor->izq;      //              (x)              (y)
    valor->izq = aux->der; //           (y)       ==>   (z)     (x)
    aux->der = valor;      //        (z)
    valor->altura = profundidad(valor); // calcular profundidad del nodo derecho
    aux->altura = profundidad(aux); // calcular profuncidad del nodo arbol 
    return(aux);
}

ArbolAVL * rotarIzquierda(ArbolAVL *valor) {
    ArbolAVL *aux; // auxiliar
    aux = valor->der;        //         (x)                     (y)
    valor->der = aux->izq; //              (y)      ==>      (x)   (z)
    aux->izq = valor;      //                 (z)
    valor->altura = profundidad(valor); // calcular produndidad del nodo izquierdo
    aux->altura = profundidad(aux); // calcular profundidad del nodo arbol 
    return(aux);
}

ArbolAVL * rotarSimpleIzquierda(ArbolAVL *arbol) {
    arbol=rotarIzquierda(arbol); // rotamos a la izquierda el arbol dado
    return(arbol); 
}

ArbolAVL * rotarSimpleDerecha(ArbolAVL *arbol) {
    arbol = rotarDerecha(arbol); // rotamos a la derecha el arbol dado
    return(arbol);
}

ArbolAVL * rotarDobleDerecha(ArbolAVL *arbol) {
    arbol->izq=rotarIzquierda(arbol->izq); //           (x)                 (x)             (z)
    arbol=rotarDerecha(arbol);             //       (y)         ==>      (z)      ==>   (y)     (x)
    return(arbol);                         //          (z)             (y)
}

ArbolAVL * rotarDobleIzquierda(ArbolAVL *arbol) {
    arbol->der=rotarDerecha(arbol->der);   //       (x)                  (x)                 (z)
    arbol = rotarIzquierda(arbol);         //           (y)     ==>         (z)      ==>  (x)   (y)
    return(arbol);                         //        (z)                       (y)
}

int calcularFactorBalance(ArbolAVL *arbol) {
    int alturaIzquierda,alturaDerecha; // factorbalance = alturaIzq - alturaDerecha
    if(!arbol) // si no hay arbol
        return 0;
    if(!arbol->izq) // si no hay lado izquierdo
        alturaIzquierda = 0;
    else
        alturaIzquierda = 1 + arbol->izq->altura;

    if(!arbol->der) // si no hay lado derecho
        alturaDerecha = 0;
    else
        alturaDerecha = 1 + arbol->der->altura;
    // al calcular sus altura se devuelve la resta de la derecha a la izquierda
    return(alturaIzquierda-alturaDerecha);
}

void mostrarPreOrden(ArbolAVL *arbol) {
    if(arbol) {  // si existe un arbol por mostrar, mostrar cada uno de sus lados
        printf("%d,",arbol->valor);
        mostrarPreOrden(arbol->izq); // RID (Raiz, Izquierda, Derecha)
        mostrarPreOrden(arbol->der);
    }
}

void mostrarInOrden(ArbolAVL *arbol) {
    if(arbol) { // si existe un arbol por mostrar, mostrar cada uno de sus lados
        mostrarInOrden(arbol->izq);
        printf("%d,",arbol->valor); // IRD (Izquierda, Raiz, Derecha)
        mostrarInOrden(arbol->der);
    }
}

void mostrarPostOrden(ArbolAVL *arbol) {
    if(arbol) { // si existe un arbol por mostrar, mostrar cada uno de sus lados
        mostrarPostOrden(arbol->izq);
        printf("%d,",arbol->valor); // IDR (Izquierda, Derecha, Raiz)
        mostrarPostOrden(arbol->der);
    }
}

void mostrarArbolAVL(ArbolAVL *arbol, int n) {
    if (!arbol) // si no hay arbol a mostrar
        return;
    else { // si hay arbol por mostrar
        mostrarArbolAVL(arbol->der, n+1); // mostrar su lado derecho
        for (int i=0; ivalor); // mostrar valor de la arbol 
         mostrarArbolAVL(arbol->izq, n+1); // mostrar su lado izquierdo
    }
}

Functions – Horizontal divider Between each post … Please edit my code

As below picture …..
Enter image description here

Here is my code

& # 39; # 39 ;, & block1_widget
& # 39; description & # 39; => esc_html __ ("Block Posts Widget, Best for Home Content Top & Home Content Bottom Sidebar.", & # 39; glob & # 39;)
);
parent :: __ construct (& # 39; glob_block_1_widget & # 39 ;, esc_html __ (& # 39; FT Block 1 & # 39 ;, glob & # 39; $ widget_ops);
$ this-> alt_option_name = & # 39; widget_block1 & # 39 ;;
}
/ **
* @param array $ args
* @param array $ instance
* /
public function widget ($ args, $ instance) {
// Get values ​​from widget settings.
$ title = apply_filters (& # 39; widget_title & # 39 ;, empty ($ instance (& 39; title & # 39;))? & # 39 ;: $ instance (& # 39; title & # 39; ), $ instance, $ this-> id_base);
$ block_category = (! empty ($ instance (& # 39; block_category & # 39;)))? $ instance (& # 39; block_category & # 39;): & # 39; & # 39 ;;
$ ignore_sticky = isset ($ instance (& ignore_sticky & # 39;))? $ instance (# ignore_sticky): 1;
$ orderby = (! empty ($ instance (& # 39; orderby & # 39;)))? $ instance ("orderby"): & # 39; date & # 39 ;;
$ order = (! empty ($ instance (& 39; order & # 39;)))? $ instance (& 39;): & # 39; DESC & # 39 ;;
$ number_posts = (! empty ($ instance (& # 39; number_posts & # 39;)))? Absint ($ instance (#number_posts)): 7;
if (! $ number_posts) {
$ number_posts = 7;
}
$ custom_query_args = array (
& # 39; # 39 & post_type; => & # 39; post & # 39 ;,
& # 39; # 39 & posts_per_page; => $ number_posts,
& # 39; # 39 & post_status; => & # 39; publish & # 39 ;,
& # 39; # 39 & ignore_sticky_posts; => $ ignore_sticky,
& # 39; # 39 & category__in; => $ block_category,
& # 39; order & # 39; => $ order,
& # 39; # 39 & orderby; => $ orderby,
);
$ custom_query = new WP_Query (apply_filters (& # 39; widget_block_1_posts_args & # 39 ;, $ custom_query_args));
if ($ custom_query-> have_posts ()) {
$ n = count ($ custom_query-> posts);
$ count = 0;
echo $ args (& # 39; before_widget & # 39;);
$ widget_title = glob_setup_widget_cat_title ($ block_category, $ title);
if ($ widget_title) {
?>

& # 39 ;. $ widget_title (& # 39; title & # 39;). & # 39; & # 39 ;;
} else {
?>
">

have_posts ()) {
$ custom_query-> the_post ();
$ count ++;
if ($ count == 1) {
?>

>

"title =" ">

& # 39;, & # 39; & # 39); ?>

>

"title =" ">

& # 39;, & # 39; & # 39); ?>

& # 39; & # 39 ;,
& # 39; # 39 & block_category; => & # 39 ;,
& # 39; # 39 & ignore_sticky; => 1,
& # 39; # 39 & number_posts; => 7,
& # 39; order & # 39; => & # 39; DESC & # 39 ;,
& # 39; # 39 & orderby; => & # 39; date & # 39;
));
$ instance (title title)) = sanitize_text_field ($ new_instance (& title #));
$ instance (# ignore_sticky) = isset ($ new_instance (# ignore_sticky #)) && $ new_instance (# ignore_sticky #)? 1: 0;
$ instance (& # 39; block_category & # 39;) = isset ($ new_instance (& # 39; block_category & # 39;))? absint ($ new_instance (& # 39; block_category & # 39;)): & # 39; & # 39 ;;
$ instance (& # 39; number_posts & # 39;) = absint ($ new_instance (& # 39; number_posts & # 39;));
$ instance (orderorder #) = sanitize_text_field ($ new_instance (orderorder #));
$ instance (order orderby #) = sanitize_text_field ($ new_instance (orderorderby #));
return $ instance;
}
/ **
* @param array $ instance
* /
Form of public function ($ instance) {
// set the default value.
$ defaults = array (
& # 39; title & # 39; => & # 39 ;,
& # 39; # 39 & block_category; => & # 39 ;,
& # 39; # 39 & ignore_sticky; => 1,
& # 39; # 39 & number_posts; => 7,
& # 39; order & # 39; => & # 39; DESC & # 39 ;,
& # 39; # 39 & orderby; => & # 39; date & # 39;
);
$ instance = wp_parse_args ((array) $ instance, $ defaults);
$ block_category = $ instance (& # 39; block_category & # 39;);
$ list_categories = get_categories ();
$ order = array (& # 39; ASC & # 39 ;, & # 39; DESC & # 39;);
$ orderby = array (& # 39; date & # 39 ;, & # 39; comment_count & # 39 ;, & 39; rand & # 39;);
?>

get_field_id (& # 39; title & # 39;); ?> ">
get_field_id (& # 39; title & # 39;); ?> "name =" get_field_name (& # 39; title & # 39;); ?> "value =" “/>

get_field_id (& # 39; block_category & # 39;); ?> ">
get_field_name ('block_category');?> 'id =' get_field_id ('block_category');?> ">
>

term_id); ?> "term_id); >> name." (". $ category-> count.") ";?>

get_field_id (#number_posts); ?> ">
get_field_id (#number_posts); ?> "name =" get_field_name (# number_posts); ?> "value =" “/>

get_field_id (# ignore_sticky #); ?> "name =" get_field_name (# ignore_sticky #); ?> "type =" checkbox "value =" 1 “/>
get_field_id (# ignore_sticky #); ?> ">

get_field_id (& # 39; order & # 39;); ?> ">
get_field_name (? order?);?> id = "get_field_id (? order?);?>">

">

get_field_id (order orderby #); ?> ">
get_field_name (order orderby #);?> "id =" get_field_id (order orderby #);?> ">

">