¿Cómo crear una Lista (o Array) dentro de otra Lista (o Array)?

Una lista es una colección de elementos de datos similares o diferentes.

El lenguaje dinámico como python puede almacenar diferentes tipos de datos en la misma lista, pero para lenguajes tipificados estáticamente como C++, una lista significa una colección de tipos de datos similares. Se puede acceder a cada elemento de la lista por sus índices, y para la mayoría de los lenguajes (python, java, C++, etc.) los índices comienzan desde 0.

Una array es lo mismo que la lista para el lenguaje dinámico, pero para un lenguaje como C++, donde el compilador realiza la asignación de memoria dinámica de una lista, el usuario de la array debe hacerlo manualmente.

Implementación de List dentro de List usando C++:

// C++ code to create a list inside another list
 
#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    // Inside this list the another list
    // will be created/inserted.
    // Also ListofList only can store
    // vector<int> datatype, unlike
    // python which can store anything.
    list<list<int> > ListofList;
 
    // The list to be inserted,
    // normal integer type list.
    list<int> insertedList;
    for (int i = 1; i < 5; i++) {
        insertedList.push_back(i);
    }
 
    // Pushing insertedList inside ListofList
    ListofList.push_back(insertedList);
    ListofList.push_back(insertedList);
 
    for (auto it = ListofList.begin();
         it != ListofList.end(); it++) {
        for (int j : *it)
            cout << j << " ";
        cout << endl;
    }
    return 0;
}

// Java code to create a list inside another list
import java.util.*;
 
class GFG{
 
  public static void main(String[] args)
  {
 
    // Inside this list the another list
    // will be created/inserted.
    // Also ListofList only can store
    // Vector<Integer> datatype, unlike
    // Java which can store anything.
    ArrayList<ArrayList<Integer> > ListofList = new ArrayList<ArrayList<Integer> >();
 
    // The list to be inserted,
    // normal integer type list.
    ArrayList<Integer> insertedList = new ArrayList<Integer>();
    for (int i = 1; i < 5; i++) {
      insertedList.add(i);
    }
 
    // Pushing insertedList inside ListofList
    ListofList.add(insertedList);
    ListofList.add(insertedList);
 
    for (ArrayList<Integer> it : ListofList){
      for (int j : it)
        System.out.print(j+ " ");
      System.out.println();
    }
  }
}
 
// This code is contributed by shikhasingrajput

1 2 3 4 
1 2 3 4 

Implementación de List dentro de List usando Python:

Para lenguaje dinámico como python, cree 2 o más listas y agréguelas dentro de una de las listas, y creará una lista dentro de una lista,

list_1 = [1, 2, 3, 4]
list_2 = [4, 7, 8, 9]
list_3 = [3, 1, 4, 7]
list_4 = [3, 5, 7, 11]
 
# list_2, list_3 and list_4
# have been appended inside list_1
list_1.append(list_2)
list_1.append(list_3)
list_1.append(list_4)
 
# As List in python can store different data types,
# that's why here it able to store
# integer type and List in a same list.
print(list_1)

[1, 2, 3, 4, [4, 7, 8, 9], [3, 1, 4, 7], [3, 5, 7, 11]]

Creando una array dentro de la array en C:

Pero para un lenguaje tipado estáticamente como C, uno tiene que predefinir todo, como el tipo de datos de la array que almacena otra array. 

Por ejemplo, para crear una array de enteros 1D dentro de otra array, en primer lugar, la array principal debe almacenar el tipo de datos (int*) y luego solo se puede almacenar/crear otra array 1D dentro de esa array.

Nota: De la misma manera, también se puede crear una array dentro de otra array en C++.

// C++ code to create array inside array
 
#include <bits/stdc++.h>
using namespace std;
#define size 5
 
int main()
{
    // Here is an array(dynamically allocated)
    // that can store array(1-D),
    // or (int*) type data
    int** out_array = (int**)malloc(size * sizeof(int*));
 
    // Here is an normal integer array
    // (dynamically allocated), which stores
    // (int) datatype
    int* temp1 = (int*)malloc(size * sizeof(int));
    int* temp2 = (int*)malloc(size * sizeof(int));
 
    for (int i = 0; i < size; i++) {
        temp1[i] = i; // 0, 1, 2, 3, 4
        temp2[i] = i;
    }
 
    // Now Creating array inside array
    // by storing int* datatype
    // inside the out_array
    out_array[0] = temp1;
    out_array[1] = temp2;
 
    cout << "After Creating array inside array " << endl;
 
    // Since there are only two
    // array inside the out_array
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < size; j++) {
            cout << out_array[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#define size 5
 
int main()
{
    // Here is an array(dynamically allocated)
    // that can store array(1-D), or
    // (int*) type datat
    int** out_array = (int**)malloc(size * sizeof(int*));
 
    // Here is an normal integer array
    // (dynamically allocated), which
    // stores (int) datatype
    int* temp1 = (int*)malloc(size * sizeof(int));
    int* temp2 = (int*)malloc(size * sizeof(int));
 
    for (int i = 0; i < size; i++) {
        temp1[i] = i;
        temp2[i] = i;
    }
 
    // Now Creating array inside array
    // by storing int* datatype
    // inside the out_array
    out_array[0] = temp1;
    out_array[1] = temp2;
 
    printf("After Creating array inside array\n");
 
    // Since there are only two arrays
    // inside the out_array
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < size; j++) {
            printf("%d ", out_array[i][j]);
        }
        printf("\n");
    }
    return 0;
}

After Creating array inside array 
0 1 2 3 4 
0 1 2 3 4