Courses Skillsoft

Data Structures & Algorithms in Python: Fundamental Data Structures

Explore Python data structures and learn core concepts and performance metrics while working with linked lists, stacks, and queues, including insertion, deletion, searching, counting elements, and comparing time complexities of common operations.

Beginner Level 1h 19m 4.30 (343) 🌐 EN

What you'll learn

  • Explore fundamental Python data structures including linked lists, stacks, and queues
  • Understand metrics and Big O notation for evaluating algorithms and operations
  • Add, search, delete, and count nodes in linked lists
  • Implement and analyze common stack operations such as ISEMPTY and ISFULL
  • Describe and compare stack and queue data structures and their time complexities

Skills you'll gain

  • Discover the key concepts covered in this course
  • Identify what makes a data structure and some of the purposes they serve
  • Recall the metrics on which algorithms and operations on data are evaluated
  • Recognize how the performance of operations and algorithms is expressed in terms of the size of the input
  • Describe a linked list, and its contents and structure
  • Summarize the different ways in which nodes can be added to a linked list and how search operations work on this data structure
  • Recall different methods to remove nodes from a linked list and describe the process of reversing the order of nodes in this data structure
  • Describe techniques used to keep track of the number of elements in a linked list
  • Summarize the workings of a stack data structure, including the addition and removal of elements
  • Identify some of the operations on stacks, such as ISEMPTY and ISFULL, and recall the complexities of the different stack operations
  • Describe the queue data structure and compare it to stacks
  • Summarize the time complexities of the common operations on linked lists and compare the stack and queue data structures

Prerequisites

  • Basic familiarity with Python syntax
  • Ability to run simple Python programs

Who this course is for

  • Python beginners wanting to learn core data structures
  • Developers preparing for data structures and algorithms interviews
  • Learners following the Python Novice to Pythonista journeys on Skillsoft

Our Review

Learn A Course Online Editorial

Bottom Line

A tight, honest introduction to Python data structures that earns its keep as a first step—but don't mistake it for a complete interview-prep toolkit on its own.

⭐ 4.3/5 👤 Beginners & Interview Preppers ⏱️ 1h 19m 💳 Skillsoft Subscription

📊 Course Snapshot

Student Rating4.3 / 5
Content Depth (for level)Solid Intro
Concept Coverage (Linked Lists, Stacks, Queues, Big O)4 Core Topics
Time Efficiency (content per hour)Very High
Standalone CompletenessPartial (Series Module)

📝 Editorial Analysis

Let me be honest about what this course is: a focused, no-fluff module inside Skillsoft's broader Python learning path. At 1 hour and 19 minutes, it's not trying to be everything—and that restraint is actually one of its strengths. I've seen beginner courses balloon into 50-module junk drawers that overwhelm students before they've written a single node. This isn't that.

The coverage hits the foundational trio—linked lists, stacks, and queues—plus an introduction to Big O notation and performance metrics. That's a clean and simple scope for a beginner. The fact that it walks through insertion, deletion, searching, and node-counting operations on linked lists specifically tells me someone actually thought about the skill sequence here. You're not just reading definitions; you're tracing operations. That matters.

The Big O piece is where I'd pay closest attention. Understanding how to express performance in terms of input size is the mental model that makes everything else click later—and it's often the piece that beginner courses skip or bury. The fact that it's explicitly listed as a learning outcome here is a good sign. Whether the execution is deep enough to make it genuinely stick is harder to assess from the outside, but the intent is right.

Now, the honest friction: this course requires a Skillsoft subscription, not a one-time purchase. If you're already on the platform—through an employer or an existing plan—that's a non-issue. If you're not, the value calculation gets murkier. Under 80 minutes of content is a tough sell as a subscription entry point. I'd only sign up for Skillsoft because of this course if you're committed to the full "Python Novice to Pythonista" journey it's part of. As a standalone? Probably not.

The 4.3 rating across 343 reviews is solid—not spectacular, but real. That distribution suggests students find it useful without finding it transformative. Which is fine. A good first module should build a foundation, not promise the whole house. And this one, by all structural indicators, does that job cleanly.

One thing I'd flag for interview preppers specifically: this is a starting point. Not a finish line. You'll need to pair it with hands-on practice—LeetCode, HackerRank, actual Python implementations—before you're walking into a technical screen with confidence. Think of this as the Monday-morning plan, not the whole week.

⏱️ Real Time Investment

1h 19m

Listed Duration

~3–4h

Realistic Estimate

Where the extra time goes:

+45mRe-watching Big O and linked list segments (this stuff takes repetition)
+60mCoding along in your own Python environment (highly recommended)
+30mNotes, review, and practice problems to make it stick

The listed runtime is passive watch time. If you're actually learning—pausing, implementing, testing—plan for a solid half-day. That's not a complaint. That's how data structures actually land in your brain.

🎯 Skills You'll Build

Linked List Operations Stack Implementation Queue Fundamentals Big O Notation Time Complexity Analysis Node Insertion & Deletion Search Operations ISEMPTY / ISFULL Logic List Reversal Techniques Performance Comparison

🟦 Core data structure skills   🟩 Algorithmic thinking   🟨 Implementation techniques   🟪 Stack-specific ops   🟥 Analysis skills

I'm compressing a lot of nuance into a few lines here—but the short version is this: if you're on Skillsoft already and you want a clean, finishable first look at Python data structures before going deeper, this module does its job. If you're not on Skillsoft, it probably shouldn't be the reason you subscribe. Either way, don't stop here. The real learning happens when you close the video and open your code editor.

Strengths

  • Tight, focused scope (linked lists, stacks, queues, Big O) with no filler—rare for a beginner module
  • Explicitly covers Big O notation and time complexity comparison, which many intro courses bury or skip entirely
  • Under 80 minutes makes it genuinely finishable in a single sitting, reducing the 'I'll come back to it' dropout risk
  • Structured skill sequence—insertion, deletion, search, counting—suggests real instructional design rather than a topic dump
  • 4.3/5 across 343 reviews is a credible, real-world signal that students find it useful

Limitations

  • Requires a Skillsoft subscription—not a one-time purchase—which makes the value math harder if you're not already on the platform
  • Designed as a series module, not a standalone course; interview preppers will need significant additional practice to be job-ready
  • No hands-on coding projects or exercises mentioned in the curriculum, which means retention depends heavily on what you do after watching
  • Covers only three data structures—no trees, graphs, or hash maps—so the 'fundamental' label should be taken literally, not broadly

🎯 Bottom line: A clean, honest first module for Python beginners who want to understand linked lists, stacks, and queues without drowning in bloat—just know it's a starting point, not a finish line, and pair it with real coding practice to make it stick.

Course information sourced from Skillsoft Last verified 3 weeks ago
Pricing varies
Go to Course

You'll be redirected to Skillsoft

Provider

Skillsoft

Related Courses

Learn Data Structures and Algorithms with Python

Learn what data structures and algorithms are, why they are useful, and how you can use them effectively in Python. Understand how to structure data so algorithms can maintain, utilize, and iterate through data quickly.

Codecademy ⭐ 4.40

Crash Course: Beginner Data Structures And Algorithms Concepts

Beginner-friendly crash course that gradually builds your data structures and algorithms knowledge, focusing on core patterns and concepts needed to solve common interview problems and ace technical interviews without the typical LeetCode grind.

Taro ⭐ 4.88

Learn Data Structures and Algorithms in Python

Build data structures from scratch and learn how to think through complex algorithms in Python. Practice hard problem-solving skills and write faster code to feel confident in interviews.

Boot.dev ⭐ 4.60

Data Structures and Algorithms in Python

Explore core data structures—linked lists, stacks, queues, hash tables, trees, and graphs—and implement key search and sort algorithms in Python while analyzing their efficiency using Big O notation.

DataCamp ⭐ 4.70

Python Data Structures

Introduces core Python 3 data structures. Moves beyond basic procedural programming to use built-in structures such as lists, dictionaries, and tuples for increasingly complex data analysis. Covers Chapters 6–10 of the textbook “Python for Everybody.”

Michigan Online ⭐ 4.90

Python Bootcamp

Python Bootcamp covers fundamentals of Python programming, including control structures, advanced data types, functions, modules, packages, multithreading, exception handling, file handling, GUI design, and database connectivity, preparing learners for future work in data science and machine learning.

SYBGEN Inc.