2888. Reshape Data Concatenate

Problem Description

The given problem requires concatenating two DataFrames df1 and df2 vertically to create a single DataFrame. Each DataFrame consists of a student_id, name, and age. The purpose of the vertical concatenation is to stack the rows of df2 below the rows of df1 while maintaining the order and structure of the columns.

To accomplish the task effectively, the solution must ensure that both DataFrames are combined such that:

  • The student_id, name, and age columns from df2 append directly below the corresponding columns in df1.
  • The resulting DataFrame should not have duplicate indexes; i.e., the index should be reset or ignored during the concatenation process to ensure a unique and ordered sequence from 0 through the last row.


The intuition behind the solution stems from understanding the pandas library's capabilities in handling DataFrames. Concatenation is a common operation in pandas that enables us to combine multiple DataFrames along a particular axis - either row-wise (axis=0) or column-wise (axis=1).

Since we want to concatenate the DataFrames vertically, we will be concatenating along axis=0. The pd.concat function from pandas is used, with two key parameters passed into it:

  1. The first parameter is a list of the DataFrames to concatenate: [df1, df2]. This indicates to the pd.concat function which DataFrames are involved in the operation.
  2. The second parameter is ignore_index=True. This parameter tells pandas to ignore the existing index of both DataFrames and assign a new incremental index starting from 0 to the resulting DataFrame. This results in a clean, non-duplicated index across the combined DataFrame.

With this approach, pd.concat takes care of realigning the DataFrames and managing the indexes, giving us a straightforward way to achieve the desired outcome without having to manipulate the DataFrames manually.

Solution Approach

To implement the solution, the pandas library is a prerequisite as it provides us with the DataFrame structure and the pd.concat function necessary for the operation. Here's how the algorithm works:

  1. Import the pandas library, which is a powerful and flexible open-source data analysis/manipulation tool written in Python. It is used here to work with the DataFrame structure.

  2. Define the concatenateTables function, which takes two DataFrames, df1 and df2, as inputs.

  3. Use the pd.concat function inside this function. The pd.concat function is a well-defined method in pandas that is specifically designed to concatenate any number of DataFrame or Series objects along a particular axis – by default, axis=0 for vertical concatenation, which is exactly what we need.

  4. Enclose df1 and df2 within a list and pass it as the first argument to pd.concat. This tells pandas to concatenate these two DataFrame objects.

  5. Set the ignore_index parameter of pd.concat to True. This instructs pandas to assign a new continuous index to the resulting DataFrame, starting from 0.

  6. The pd.concat function returns the concatenated DataFrame.

  7. The concatenateTables function, therefore, returns the result of the pd.concat operation, thus completing the vertical concatenation of df1 and df2 into one single DataFrame.

By using the pandas pd.concat function with ignore_index=True, our algorithm efficiently performs a vertical stack of two separate DataFrame objects without the need for any complex data structures or additional patterns. This method achieves the goal with minimal code and complexity.

The implementation of this solution does not require the development of new algorithms or the use of complex data structures due to the strength of the pandas library, which abstracts these details away. The high-level abstraction provided by the pd.concat function substantially simplifies the task, demonstrating the power of using the right tools for data manipulation tasks in Python.

Ready to land your dream job?

Unlock your dream job with a 2-minute evaluator for a personalized learning plan!

Start Evaluator

Example Walkthrough

Let's illustrate the solution approach with a specific example. Suppose we have two DataFrames df1 and df2 with the following data:

DataFrame df1 contains:


DataFrame df2 contains:


Our goal is to concatenate df1 and df2 vertically.

  1. First, we import the pandas library as it provides us with the necessary DataFrame structure and concatenation functions.
1import pandas as pd
  1. We then define the DataFrame instances df1 and df2 for our example, which correspond to the tables above.
1df1 = pd.DataFrame({
2    'student_id': [1, 2],
3    'name': ['Alice', 'Bob'],
4    'age': [21, 22]
7df2 = pd.DataFrame({
8    'student_id': [3, 4],
9    'name': ['Charlie', 'David'],
10    'age': [23, 24]
  1. Next, we define the function concatenateTables that will take two DataFrame objects and concatenate them vertically while resetting the index.
1def concatenateTables(df1, df2):
2    return pd.concat([df1, df2], ignore_index=True)
  1. We call the concatenateTables function with df1 and df2 as arguments.
1resulting_df = concatenateTables(df1, df2)
  1. The pd.concat function called inside the concatenateTables function concatenates these two DataFrames and, at the same time, ignores the original indices and assigns a new sequence of index starting from 0 to the combined DataFrame.

The concatenated DataFrame resulting_df now looks like this:


As we can see, the student_id, name, and age columns from df2 have been appended directly below the corresponding columns in df1, and the index has been reset to reflect the new order. The resulting DataFrame is well structured, just as required by the problem statement. This example demonstrates the effectiveness and simplicity of the approach using the pd.concat function from the pandas library.

Solution Implementation

1# Import the pandas library as pd.
2import pandas as pd
4# Define a function to concatenate two dataframes.
5def concatenateTables(dataframe1: pd.DataFrame, dataframe2: pd.DataFrame) -> pd.DataFrame:
6    """
7    Concatenate two pandas DataFrames into a single DataFrame.
9    Parameters:
10    dataframe1 (pd.DataFrame): The first DataFrame to concatenate.
11    dataframe2 (pd.DataFrame): The second DataFrame to concatenate.
13    Returns:
14    pd.DataFrame: The concatenated DataFrame with the index reset.
15    """
16    # Use the pd.concat method to concatenate the two DataFrames.
17    # The ignore_index=True parameter will reassign new index values to the 
18    # resulting dataframe, ranging from 0 to the length of the new dataframe minus one.
19    concatenated_dataframe = pd.concat([dataframe1, dataframe2], ignore_index=True)
21    # Return the concatenated DataFrame.
22    return concatenated_dataframe
1import java.util.ArrayList;
2import java.util.List;
3import java.util.Map;
5public class DataFrameUtils {
7    /**
8     * Concatenates two lists of maps simulating dataframes into a single list.
9     * 
10     * Each map in the list represents a row, and the keys of the map represent the column names.
11     * 
12     * @param dataframe1 The first list of maps to concatenate.
13     * @param dataframe2 The second list of maps to concatenate.
14     * @return A new list containing all the elements from dataframe1 followed by all the elements of dataframe2.
15     */
16    public static List<Map<String, Object>> concatenateTables(
17            List<Map<String, Object>> dataframe1, List<Map<String, Object>> dataframe2) {
19        // Create a new ArrayList to hold the concatenated data.
20        List<Map<String, Object>> concatenatedList = new ArrayList<>();
22        // Add all rows from the first dataframe.
23        concatenatedList.addAll(dataframe1);
25        // Add all rows from the second dataframe.
26        concatenatedList.addAll(dataframe2);
28        // Return the concatenated list of maps which simulates a dataframe.
29        return concatenatedList;
30    }
32    // Example usage from a main method.
33    public static void main(String[] args) {
34        // Example DataFrames as lists of maps.
35        List<Map<String, Object>> dataframe1 = new ArrayList<>();
36        List<Map<String, Object>> dataframe2 = new ArrayList<>();
38        // Populate the dataframes with examples (omitted for brevity).
40        // Concatenate the dataframes.
41        List<Map<String, Object>> combinedDataframe = concatenateTables(dataframe1, dataframe2);
43        // Print out the concatenated dataframe (omitted for brevity).
44    }
1#include <pandas.h> // Assuming a hypothetical C++ equivalent of the Pandas library exists.
3// Define a function to concatenate two dataframes.
4DataFrame ConcatenateTables(const DataFrame& dataframe1, const DataFrame& dataframe2) {
5    /**
6     * Concatenate two DataFrames into a single DataFrame.
7     *
8     * Parameters:
9     * dataframe1: The first DataFrame to concatenate.
10     * dataframe2: The second DataFrame to concatenate.
11     *
12     * Returns:
13     * A concatenated DataFrame with the index reset.
14     */
16    // Use the Concat method to concatenate the two DataFrames.
17    // Pass true for ignoreIndex to reassign new index values to the resulting DataFrame,
18    // ranging from 0 to the length of the new DataFrame minus one.
19    DataFrame concatenatedDataFrame = pandas::concat({dataframe1, dataframe2}, true);
21    // Return the concatenated DataFrame.
22    return concatenatedDataFrame;
1import { DataFrame } from 'pandas-js';
3// Function to concatenate two dataframes.
4function concatenateTables(dataframe1: DataFrame, dataframe2: DataFrame): DataFrame {
5    /**
6     * Concatenate two pandas-js DataFrames into a single DataFrame.
7     * 
8     * @param {DataFrame} dataframe1 - The first DataFrame to concatenate.
9     * @param {DataFrame} dataframe2 - The second DataFrame to concatenate.
10     * 
11     * @return {DataFrame} - The concatenated DataFrame with the index reset.
12     */
14    // Use the concat method from pandas-js to concatenate the two DataFrames.
15    // The reset_index option will assign new index values to the resulting DataFrame,
16    // ranging from 0 to the length of the new DataFrame minus one.
17    let concatenatedDataFrame = dataframe1.concat(dataframe2).reset_index(drop=true);
19    // Return the concatenated DataFrame.
20    return concatenatedDataFrame;
23// Usage example (assuming DataFrame objects are created properly):
24// let resultDataFrame = concatenateTables(dataFrame1, dataFrame2);

Time and Space Complexity

The time complexity of concatenateTables when using pd.concat with ignore_index=True depends on the combined size of the input DataFrames df1 and df2. If df1 has n rows and df2 has m rows, then the time complexity is O(n + m) because each row from both DataFrames needs to be copied into the new DataFrame.

The space complexity of this operation is also O(n + m), as a new DataFrame is created that holds all rows from both df1 and df2. In the worst case, all the data from the input DataFrames must be kept in memory to produce the concatenated DataFrame.

Discover Your Strengths and Weaknesses: Take Our 2-Minute Quiz to Tailor Your Study Plan:
Question 1 out of 10

In a binary min heap, the maximum element can be found in:

Recommended Readings

Got a question? Ask the Monster Assistant anything you don't understand.

Still not clear? Ask in the Forum,  Discord or Submit the part you don't understand to our editors.

Coding Interview Strategies

Dive into our free, detailed pattern charts and company guides to understand what each company focuses on.

See Patterns