쉐도잉 연습: Data Structures Explained for Beginners - How I Wish I was Taught - 영상으로 영어 말하기 배우기

연습 모드 선택

각 모드는 전체 화면 연습실로 열립니다.

214 문장

문장이 너무 짧거나 길면 Edit를 눌러 조정하세요.

Data structures are super important to know for technical coding interviews and computer science in general.

And so in this video, I'm going to be breaking down some of the most popular data structures out there, what they look like and how they operate, real world examples so you can actually picture what I'm talking about,

plus their time complexities, but more on that later.

And if you're new here, hi, my name is Ajad.

I have a bachelor's and master's in computer science from Georgia Tech.

I have software engineering experience working at top tech companies like Amazon.

And every single day, I help hundreds of thousands of people break into tech.

Before we

data structure we do need to understand one big concept called big oh this is our way of measuring speed

and efficiency how well data structures are actually operating in different scenarios for example

if I'm in New York

and I want to go to California I could walk there

it might take me a month I could bike there in

a couple weeks I could drive there in a few days

or I could fly there in just a few hours different

vehicles are optimized for different scenarios just like different data structures are also optimized for by miles per hour,

but for the speed of data structures and how they operate, we use time complexity or big O notation.

If you're not understanding this, let me break down four different types of big O notation.

First one, we got O of one constant time.

This is the fastest an algorithm can operate.

Think like rocket ship, speed of light.

O of one means the operation takes the same amount of time, no matter how much data there is.

Imagine you have a grocery list and The list is five items, 500 items, 5 ,000 items.

The operation is the same exact thing.

You just need to take the first one instantly.

There's no extra effort despite how long the list is.

So it's super fast and super efficient.

A level above that, we have O of N, linear time, where N in this case represents the amount of data that we have.

This is still a pretty fast operation.

So you can imagine not speed of light, but like super car.

And specifically O of N, this is when the amount of data increases.

grows at that same rate.

For example, if you have a list of names and you need to find a specific name, the worst case is you have to check every single name until you find that name.

If you have a list of 10 names, you might have to do 10 checks.

If there are a thousand names, you might have to do 1000 checks.

We don't know the position in the list like we did for the O of 1 scenario, and so as the data increases in size, it takes longer because there's just a longer operation,

just more to deal with, but it's a very predictable increase.

A level above

that, we have quadratic time O of n squared think of

biking from New York to California I mean like very very slow

and this happens

when every single item in a data set needs to interact

with every other item imagine you have a classroom full of students

and each student has to shake hands with every other student

if there are 10 students that means 10 times 10 a hundred handshakes

if there are a hundred students

that is a hundred times a hundred ten thousand handshakes the amount of work this operation has to go through

too fast the more students that are added into the mix.

And if you have an algorithm that takes O of n squared time complexity, just know that's a really slow, really bad algorithm, and chances are there's a better scenario.

Now the fourth scenario I want to talk about is a slight curveball, and that is O of log n, logarithmic time.

And this one is faster than O of n, but slower than O of 1.

So it's not the speed of light, it's like the speed of sound.

It's still really fast.

An example look up a word in the dictionary.

Typically, if you have like a random word, what people generally do is they open up the dictionary to the middle, somewhere in the middle.

And from there, you decide does the word I'm looking for come before or after the current page I'm on.

And so depending on that, you'll jump forward or backward.

And you'll repeat that process until you find your desired word.

Each time we're jumping pages, we're cutting the amount of time that we're looking in our search of n.

But rather we're going half and then half of that, half of that, and the search space of the operation just gets smaller and smaller.

And actually if you look at a logarithm graph, at a certain point as you keep increasing the input, the difference in the output is so small and so marginal.

And so these are the different time complexities that different data structures can have.

And now that we understand how things are getting measured, let's start off with our first data structure and we're going to be talking about the array.

Think of an array like a row of middle just by knowing its number.

Arrays store data in a contiguous manner, meaning all elements are placed side by side by side in memory.

Because each element has a specific index, retrieving a value is extremely fast and you can go directly to its position without like searching.

However, if the array is already full and you want to add a new element, that can be a little tricky because you can't just squeeze another item.

It's a fixed size.

Just like you can't add a new locker,

you and all existing elements must be copied over and then the new element can be added.

But there is a structure that's similar to an array that handles this resizing a little bit better.

If you know which one I'm talking about and why it's better, let me know in the comments down below and I might give you a shout out in my next video.

In terms of time complexities, accessing any element by an index is an O of one operation, so it's super efficient.

Inserting an element at a position is also O of one if you're simply replacing an existing item.

But inserting a value beyond the requires creating a whole other array, which takes O of N time, because you have to copy over a whole array.

Deleting an element is also O of N, because once an element is removed, all subsequent elements must shift down to maintain the array's contiguous structure,

unless you're deleting at the very end of the array.

In that case, it's an O of 1, because you're just removing the last element, and there's no shifting downwards.

The next data structure we're going to be talking about is the linked list.

Think of a linked list like a train, where each car is connected to the next one.

reach a specific car, you can't just teleport to it.

You have to start from the front and move through each car until you find the one that you need.

In linked lists, each element is stored in a separate node, and each node contains both a value and a pointer to the next node in the sequence.

This makes linked lists more flexible than arrays since you can easily add or remove elements without worrying about shifting everything around.

However, accessing specific elements is slower because you have to traverse the list from the beginning to find it.

So in terms of time

accessing an element by an index is an O of N operation because you actually have to go through the list.

There's no index inbuilt into the linked list.

Inserting an element at a position is an O of one operation

if you already have reference to the node that you're trying to insert around.

But if you actually have to search for it, once again, you're traversing the list.

So that's going to be an O of N operation.

Deleting an element similar to inserting is O of one

if you have the right reference because all you have to do is just switch around the pointers.

But if you have to It's an O operation once again.

The nice thing is, unlike an array, deleting from a linked list doesn't require shifting elements around, so sometimes it can be a little more efficient in this type of use case.

Plus there's also no resizing issue because it's just nodes and pointers.

There's no like fixed structures that you have to deal with.

The next data structure we're going to talk about is the stack.

100

This is a simple structure that follows a last in first out principle, meaning the last element added is the first one to be removed.

101

Think of a stack of chips.

102

You have to eat the top one first before you can eat the next one.

103

Each element in a stack is stored in an ordered manner.

104

But unlike arrays, you can only access or modify elements from the top of the stack.

105

because there's no shifting around.

106

For the big O time complexity for a stack there's no accessing really at a particular index

107

because you only take or remove from the top itself but

108

if you have to access or search through a stack

109

that would be an O of N operation

110

because you have to go through each element one by one by one there's no indexing.

111

Inserting an element which is called pushing onto the stack is an O of one operation

112

because you simply add the element to the top of the stack

113

popping from the stack once again is an O of one operation

114

because you only have to remove from the top of the element.

115

There's no dealing with the other elements when you're taking or removing from a stack.

116

So it's highly efficient for adding or removing plus it's very widely used in depth for search but more on that later.

117

The next data structure we're going to talk about is the queue

118

and unlike a stack that was last in first out this is a first in first out

119

which means the first element added is the first element to be removed.

120

Think of it when you're standing in line at the at the front, gets to the checkout first, and then they get dealt with first.

121

Any new people that want to join the line has to join in in the back

122

and must wait their turn till they come to the front.

123

Each element in a queue is stored in an ordered manner, but unlike an array which is also ordered, these elements can be added only in the back and removed in the front.

124

For the big O time complexity of a queue, just like a stack, you can't access the element by their index, but for some reason, if you have to go through the whole queue to find a certain element,

125

that would be an O of N to access or search if you're not just trying to access the first element there.

126

In terms of insertion or deletion those are O of one operations

127

because you add to the back remove from the front

128

and it's just continuous think of a stack but in slight reverse order.

129

Plus queues are highly used in breadth -thrift search and Spotify music.

130

The next data structure we're going to talk about is the heap or priority queue.

131

Think of a heap like a pyramid of stacked boxes where the smallest box

132

middle you always take from the top

133

but specifically for heaps they actually always need a box to be at the top like

134

if any boxes are removed within the pyramid they need to readjust

135

so there's a box still at the top so it can maintain that structure.

136

Also there are two types of heaps that you need to know.

137

First is a min heap where every parent is smaller than its children

138

and the top element is the smallest

139

while in a max heap every parent is larger than its children and the top

140

is not a general operation but

141

if needed it would be O of 1 to access the top element

142

which we call the root and O of n for any arbitrary elements within the heap.

143

Inserting an element is an O of log in procedure

144

because first it's added into the heap and then

145

because of the heap property of the parent -child relationship being bigger or smaller it bubbles up to its right position.

146

Similarly removing is also O of log in because it removes the elements and then bubbles down to

147

actually balanced binary trees which more on that later both insertion

148

and deletion operations are extremely efficient compared to linear data structures like arrays

149

or linked lists

150

which we talked about the next data structure we're going to talk about is the hash map

151

and make sure you know this one think of a hash

152

map like a mail room in an office where every employee

153

has a dedicated mailbox instead of sorting through all the mail one by one by one you just look oh john

154

You know exactly where to put it and John and Sally know exactly where to access it.

155

A HashMap stores data using key value pairs where each key is run through a hash function

156

that determines where the value should be stored.

157

An example of a hash function could be the length of a string.

158

So John's name for example is four characters long so he's in position four.

159

Sally is in position five her name is five characters long.

160

This makes lookups on HashMaps extremely

161

the same mailbox which we call a hash collision for example

162

if a new employee andy joins well his name is also

163

four letters we can't just put him in position number four

164

because that's where john is so we need to have a hash collision resolution

165

which could be a linkless chaining from the hash map position

166

or it could be linear probing where you find the next

167

available position either way this is the only real downside to

168

hash maps otherwise they are super super efficient as a data structure

169

so overall accessing an element by its key in a hash map is an o of one operation

170

be O of N worst case if everything is put onto

171

that linked list and you have to do a lot of searching.

172

Inserting an element is an O of 1 operation, but worst case scenario, that could end up being O of N.

173

Deleting an element is also an O of 1 operation because

174

if you have the right key you can just go to the value, but if there is a long linked list

175

that you have to deal with to find the actual element that you're dealing with, that could end up being an O of N operation.

176

By the way, if you use Python you probably call HashMaps dictionaries, but they're pretty much the search tree.

177

So it's a tree.

178

It looks similar to a family tree, but the key difference is each node follows a specific ordering rule.

179

The left child has to contain values smaller than the parent, and the right child has to contain values greater than the parent.

180

This makes searching, insertion, and deletion extremely efficient.

181

In terms of the big O, accessing, inserting, and deleting into a binary search tree is an O of log n procedure.

182

Because of the rules of the left, parent, and elements every time we look to access an element, insert an element or delete an element,

183

you can literally eliminate half the tree as we're going through it.

184

So it's like going through the dictionary, trying to find that word because you're just splitting up your search space by half every layer that you're going.

185

But worst case, if your binary search tree is unbalanced for some reason, and it looks something similar to a linked list,

186

each of those operations access insertion and deletion becomes O of N because you might have to go through each element.

187

There's no elimination of is the set and I want you to think of this like Thanos' infinity gauntlet.

188

It can hold powerful stones but each stone is unique.

189

If Thanos tries to add the same stone twice it simply won't work

190

because the gauntlet can only allow one of each kind.

191

Also the order in

192

which he collects the stones doesn't matter at all as long

193

as like he has all the stones in whatever order they're all unique it'll be good.

194

Sets are very useful if you're searching through trees or you're searching a certain node or not.

195

And overall, the definition of a set is an unordered collection of unique elements typically implemented using a hash table.

196

Similarly, the efficiency of a hash map with a hash function, this makes checking for the existence of an element extremely fast, which means O of one on average time.

197

However, similar to all the issues that we had with the hash function and the hash maps causing potential collisions, that can take it all the way up to O of N.

198

Unlike arrays or linked lists, sets don't store duplicates and they don't maintain a specific order.

199

And in coding interview questions such as removing duplicates from a linked list, removing duplicates from a data set, or checking for a certain membership,

200

or performing mathematical set operations.

201

So make sure you know your sets because it's never going to be the main data structure, but it's always going to be something to have in handy just like Thanos' gauntlet.

202

In terms of the big O time complexity, inserting and deleting are going to be O of 1 operations because of the whole hash function.

203

But if there's so many cache collisions, once again, it's going to be O of N

204

if the case is it's run by hash tables in the

205

background there are various other ways to create sets i just gave you an example of a hash set

206

and if you're interested in leveling up your career applying your data structures knowledge to actual lead code problems

207

that show up in top tech interviews for companies like amazon

208

or google you might want to check out my newsletter down

209

below where i'm going to send you guys links for popular

210

leak code problems by each company for different data structures

211

so you guys can practice and really get ahead of the game well that's about

212

you guys enjoyed it and if you did make sure to hit the like button subscribe

213

if you haven't already and now

214

if you're interested in landing a software engineering internship for summer of 2025 check out this video right here

앱 다운로드

유창하게 말하는 데 필요한 모든 것

AI 발음 평가문장마다 점수 확인

IPA 발음 연습모든 소리 마스터

단어 학습나만의 단어장 만들기

단어 게임놀면서 외우기

QR 스캔

Download on theApp Store Get it onGoogle Play

같은 채널

Learn 97% of Harvard's CS50 in 25 minutes

Daily ConversationUniversity Students

How I Would Learn Python FAST (if I could start over)

Business EnglishUniversity StudentsWorking Adults

Creator of C# and TypeScript: "AI will NEVER Replace Coders, Here's Why" | Anders Hejlsberg

Daily ConversationUniversity StudentsWorking Adults

FOR YOU

이 비디오로 말하기 연습을 하는 이유는?

이 비디오는 데이터 구조와 그 중요성에 대해 설명하며, 기술적인 코딩 인터뷰에서 필수적인 지식을 제공합니다. 여기서 말하는 내용은 처음 배우는 사람에게 굉장히 유익할 뿐만 아니라, 영어로 기술적인 주제를 이해하고 말하는 데 도움을 줍니다. 비디오를 통해 배우는 내용을 shadowspeak, 즉 말하기 모방 연습을 통해 습득함으로써, 실전처럼 자연스럽게 표현할 수 있는 능력을 기를 수 있습니다. 이런 연습은 영어 말하기를 개선하고, 자신감을 키우는 데 큰 도움이 됩니다.

문맥 속 문법 및 표현

비디오에서 사용된 몇 가지 주요 문법 구조를 살펴보겠습니다:

“If you're new here” - 이 표현은 청중에게 친근하게 말을 건네는 방식으로, 새로운 청중에게 배려하는 느낌을 줍니다.
“this is our way of measuring” - 관용적인 표현으로, 어떤 개념이나 방식을 소개할 때 유용합니다.
“a level above that” - 비교와 구분을 명확하게 통해 정보를 체계적으로 전달하는 데 도움을 줍니다.

이런 구조를 통해 새로운 정보를 효과적으로 전달하는 방법을 익힐 수 있습니다. 또한, 기술적 설명을 영어로 잘 표현하기 위한 다양한 문법과 어휘를 습득하는 좋은 기회가 됩니다.

일반적인 발음 함정

비디오에서 몇 가지 발음이 어려운 단어와 억양을 찾아보겠습니다:

“data structure” - 이 용어는 특히 다양한 억양이 있을 수 있습니다. 데이터의 발음이 지역에 따라 다를 수 있으니 주의해야 합니다.
“algorithm” - 이 단어는 다양한 발음이 있으니, 자신에게 맞는 발음을 찾는 것이 중요합니다.
“complexity” - 마지막 부분에서 억양이 강해지므로 발음 연습을 통해 자연스럽게 말을 할 수 있도록 해야 합니다.

위의 단어들에 대한 발음 연습은 shadow speech 연습에 매우 유효하며, 다양한 억양에 익숙해지는 데 큰 도움이 됩니다. 영어 말하기를 향상시키기 위해서는 이러한 발음을 자주 연습하는 것이 필수적입니다.

이 영상의 문법

화자가 가장 많이 쓰는 문형을 영상 속 실제 표현과 함께 정리했습니다.

문형	영상 속 표현
수동태 be + 과거분사 — 누가 하는지보다 무슨 일이 일어나는지에 초점	are optimized · are added · are placed
관계절 who / which + 절 — 사람이나 사물에 대한 추가 정보	students that are · element which is · array which is

쉐도잉이란? 영어 실력을 빠르게 키우는 과학적 방법

쉐도잉(Shadowing)은 원래 전문 통역사 훈련을 위해 개발된 언어 학습 기법으로, 다언어 학자인 Dr. Alexander Arguelles에 의해 대중화된 방법입니다. 핵심 원리는 간단하지만 매우 강력합니다: 원어민의 영어를 들으면서 1~2초의 짧은 지연으로 즉시 소리 내어 따라 말하는 것——마치 '그림자(shadow)'처럼 화자를 따라가는 것입니다. 문법 공부나 수동적인 청취와 달리, 쉐도잉은 뇌와 입 근육이 동시에 실시간으로 영어를 처리하고 재현하도록 훈련합니다. 연구에 따르면 이 방법은 발음 정확도, 억양, 리듬, 연음, 청취력, 말하기 유창성을 크게 향상시킵니다. IELTS 스피킹 준비와 자연스러운 영어 소통을 원하는 분들에게 특히 효과적입니다.

섀도잉 방법: 단계별 전체 가이드 읽기 →

쉐도잉 연습: Data Structures Explained for Beginners - How I Wish I was Taught - 영상으로 영어 말하기 배우기

연습 모드 선택

앱 다운로드

같은 채널

Learn 97% of Harvard's CS50 in 25 minutes

How I Would Learn Python FAST (if I could start over)

Creator of C# and TypeScript: "AI will NEVER Replace Coders, Here's Why" | Anders Hejlsberg

추천 영상

Learn Data Modeling in 8 minutes: Dimensional Data Modeling, Data Vault, and One Big Table

3.3k

What is an Organization? - the Nature of Organizations

You are wasting memory

System Design: Why is Kafka fast?

JavaScript Visualized - Event Loop, Web APIs, (Micro)task Queue

How to Become a Great Software Developer — Best Advice from Top-Notch Engineers

What is Statistics? A Beginner's Guide to Statistics (Data Analytics)!

CAP Theorem in System Design Interviews

Object-Oriented UX (OOUX)

8 Years of Data Analytics Advice in 12 Minutes

A/B Testing in Data Science Interviews by a Google Data Scientist | DataInterview

이 비디오로 말하기 연습을 하는 이유는?

문맥 속 문법 및 표현

일반적인 발음 함정

이 영상의 문법

쉐도잉이란? 영어 실력을 빠르게 키우는 과학적 방법