Learn how to represent a directed and weighted graph using an edge list.

We start from a directed unweighted example, add weights to every edge, then store the graph as a tuple of a vertex list and an edge list. Each edge is a tuple of start node, end node, and weight. Order matters because the graph is directed.

Then we convert node values to indexes so you can jump straight to a vertex in constant time instead of scanning the vertex list. That keeps edge scans closer to O(E) instead of O(E + V).

This is part of a series covering all four combinations: directed vs undirected and weighted vs unweighted. Watch the earlier videos for basic graph terms and the other representations.

Leave a comment if you want a topic covered next.

00:00 Intro to directed weighted edge lists
01:05 Starting from the directed unweighted graph
01:35 Adding a weight to every edge
02:48 Graph as a vertex list plus edge list
03:35 Writing the vertex list
04:18 Node classes versus raw values
05:18 Writing directed weighted edges
05:45 Order matters on directed edges
06:38 Walking remaining outgoing edges
09:08 Why value-based edges scan slowly
10:29 Replacing node values with indexes
12:36 Constant-time jumps after an edge scan
14:13 Series wrap-up
14:45 Subscribe and outro

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hello there! Let’s talk about representing a directed and weighted

graph inside your machine using an edge list representation.

That’s a lot of words, a lot of words. Okay, so I hope you watched my previous videos. You didn’t

necessarily need to watch the previous three where we talked about edge list

representation.

where we talked about edgeless representation on the other types of graphs we’re doing a directed

versus uh undirected and weighted versus unweighted and all four combinations of those

so uh you don’t need to watch those others if you’re just only interested in this but it’s

probably a good idea if you watch my other graph videos because we talk about basic graph

terminology and like you know what is a graph and stuff like that but for now we’re just going to

continue um the screenshot you’re looking at right now was the last part of the last video where we

Thank you.

the last part of the last video where we did a directed unweighted graph so I’m

gonna duplicate this real fast and I’m gonna start modifying it so we can

basically just move on with our lives so this is gonna be directed and also

weighted then I’m gonna erase a whole bunch of other stuff because it’s fun to

draw again I don’t know why but it is I like to do my drawings get that and then

And I’m going to get rid of that stuff.

Okay.

that stuff okay and i’ll get rid of this because i’d like to draw it okay i probably should have

gotten rid of it first so i guess the real first thing that i’m going to do after erasing all that

stuff is add weights to all the edges remember this has to be a weighted graph so this particular

graph you’re looking at right now is directed and unweighted so we have to add weights to all of

the edges in my previous videos we talked about what is the meaning of weights you know these

could be a cost these could be like some property like in a video game

property like in a video game uh whatever you want them to mean uh these could even be classes

with like complicated values um but for now i’m going to say i don’t know maybe this is an airport

map and the weights are how much gas it takes to fly from one city to another maybe a node is a

city number six and city number 12 you want to fly between them it’s like five million jillion

gallons of gas so let me just take a look real fast and make sure that i’m not forgetting

I mean, any edge.

getting any edge every single edge should have a weight i think there were nine edges here one two

three four five six seven eight nine so i should see nine weights one two three four five six seven

eight nine okay we’re now ready to start representing this and what’s going on with

this computer okay the first thing uh that we talk about in all of these you know recent related

videos is that in an edge list representation we’ll say

edge list representation, we’ll say that our graph is a tuple, meaning just like a collection of some

things. A tuple where the first item in the tuple is a vertex list or a node list, and the second

item is an edge list. Again, in previous videos, we talked about representing paths using nodes or

using edges. So the edge list path is going to come back to haunt us where we do our edge list

graph representation, which is different than an edge list path.

path. So how do we do our vertex list? That’s going to be pretty easy for this diagram.

I’m going to say that V is equal to, oh, it’s pink. Let me change the color to be more serious.

Okay. The vertex list is going to be a collection of just all the nodes, just naming all the nodes

or having all the nodes. I’m going to say it’s a vertex list or a node list, but really you

probably want this to be a vector I’ve been saying that recently because it’s faster to

because it’s faster to jump to a particular index in a vector

than it is in an actual linked list or some other list-like data structure.

So we’ve got a vertex list.

I’m just going to name all the nodes.

So for me particularly, I like to go from left to right.

You can sort them, you can do whatever you want.

They just need to all be in there.

So I’m just going to say every node that we see in the graph

is going to end up in this vertex list.

So we’ve got 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6.

So we’ve got all the nodes in there.

another point that I’ve been making in the in these recent videos is that in real life in your

code in your in your computer you don’t really want to just have this value three here you don’t

want to have this 12 value here that the 12 value that’s just the value that the node holds I mean

if you want everything to be really fast maybe you know keep it bare bones but for me I like to

have a full node class a full vertex class and make an instance of it so I can add a whole bunch

of custom properties and function

bunch of custom properties and functionality and other stuff onto my node so that that means i

couldn’t really put an integer there i would have to put a full node so keep in mind for yourself

you probably want to try it both ways but um you probably want to want an instance of a node class

and maybe stick the instance right there in the vector or maybe make a smart pointer and so like

you allocate you know a new pointer of an instance of the class or it’s a raw pointer it’s a smart

point or whatever so just keep in mind this diagram is

So just keep in mind, this diagram is more simple than your code, but we’re just diagramming

today.

Anyway, so we put all the nodes in there.

The next thing I need to do is represent the edges.

So I’m going to put E is equal to another list.

And this probably does need to be a linked list or a list like data structure and not

a vector.

There’s not much point in jumping to an index.

I don’t know.

You could probably come up with one.

But anyway, so the edge list is going to be a list of tuples that describe one edge at

a time.

at a time so every little parenthesis that i put here that’s going to represent one edge so again

for me i like to go from left to right i’m going to start on the left node and i’m going to say

that the start node is three and remember this is a directed graph which means the order if you

looked at my previous videos the hang on the order of the nodes actually matters a lot like i can put

3 and 13 but i cannot put 13 comma 3 because the first item in the tuple is supposed to be the

The first item in the tuple is supposed to be the starting node.

And if you see, I only have like an edge going from 3 to 13.

I don’t have one going from 13 to 3.

So 13 comma 3 would be invalid.

It would be totally bad.

So I’m going to say the 3 goes out to the 13.

So the 3 comes first and the 13 is second.

And then I have to describe how much it costs.

So that’s the third item in that one particular tuple.

It’s going to be a 1 because the cost of that one particular edge is 1.

one gasoline one

one millisecond delay one time whatever so then the next item is going to be where else does the

three go to the three doesn’t go anywhere else so we’re done representing the three at least as a

start node so next up uh i’m going to look at the 13 where does the 13 go to it goes to the six it

doesn’t go to the three the three goes to 13 but this the 13 doesn’t go to the three so 13 goes to

six and it costs six because that’s the cost of the edge there’s two sixes here

the edge. There’s two 6s here, a little confusing, but that’s because one is a node and one is a

weight. The 13 does not go out anywhere else, so we’re done with the 13. I like to make, you know,

different rows for every single start node. You don’t have to do that. Next up, I’m going to look

at the 6. The 6 does not go out to the 13. The 6 does not go out to the 18. There is a connection

there, but it’s going in the other direction. The 6 goes to the 12 and also to the 15. So the 6 goes

to the 12, and that cost us $5,000.

to the 12 and that cost us five because that was the weight we assigned and the six also goes to

the 15 with a cost of i think i just wrote seven in a weird way um so we go from six to fifteen it

costs us seven and then we’re done looking at the outgoing edges of these six let me just double

check out out yes now we’re ready to move on to the uh the 12 node the 12 node has one outgoing

connection it goes out to the three did i get that wrong in the last video leave a comment

Did I get that wrong in the last video?

Leave a comment.

I don’t know.

And then we’re done with the 12 node.

Now we look at the 15 node.

Oh, that’s why I had that feeling,

because the 15 didn’t go anywhere.

15 has incoming connections, but no outgoing connections,

so we actually can’t write it down here.

There’s no need.

Then we look at the 18 node.

The 18 has outgoing connections to four other nodes.

To the three, with a cost of three.

Am I mind-tripping myself when I’m doing these duplicates?

18 also goes out to the 6 with the cost of 8.

Didn’t trick myself that time.

The 18 also goes out to the 12 with the cost of 2.

And then the 18 also goes out to 15 with the cost of 9.

I just realized recently it’s a good idea to make faces at the camera for emotional thumbnails.

I don’t know if you’ve picked up on that yet, but yeah.

if you’ve picked up on that yet but yeah so let me just double check that i’ve got like nine edges

and nine entries one two three four five six seven eight nine so i think i probably did it all right

now there’s a problem um i’ve been talking about this in in the recent videos there’s a problem

with this type of representation what if you are scanning through the edge list and you’re like

well i’m scanning this edge and that edge and that edge and that edge and that edge and then i come

to the 18-6 edge

and I think, well now I found

and i think well now i found some edge that was interesting for whatever reason

maybe if i was scanning or doing some kind of like a operation that might have costed linear time so

you don’t have to know about this uh this is in other videos but basically it’s not incredibly

scalable it’s not incredibly fast it is technically scalable just not incredible

linear time based on the number of edges so that kind of sucks because if i wanted to do something

with those nodes with the 18 and

with those nodes with the 18 and the six node i would then have to do another linear scan

to find each node i’d have to go into my vertex list and i’d have to say well where the heck are

those things where’s 18 nope nope nope nope nope uh found the 18 and then there’s another scan

to find the six so really this is going to end up being um linear time based on the number of edges

and also the number of vertices so that’s a little bit slower not

a little bit slower not too great the upgrade that we’re going to do which we’ve been doing

in all the other videos of of these recent edge list representations is i’m going to

first i’m going to duplicate the vertex list like this

and then i’m going to show you that each node each vertex has an index so i’m going to say

one this is index two it’s index three when i type too hard i think my hand shakes the table

that kind of sucks i need shock absorbers for my galumpiness oh so we have uh an index for every

single vertex what if we uh what if we copy pasted the edge list over here on the left

um what’s going on it’s not oh there it is dumb okay what if we copy pasted it and then we

converted all of the values.

at all of the values uh or um i guess you maybe on the left side if you if you’re doing this in

the code you might put pointers instead of values so we’ll just say that we’ll convert the pointers

or these values into indexes so this first tuple we’re describing the edge that goes between 3 and

13 with the cost of 1 3 is sitting at index 0 in the vertex list so i’m going to change it to a 0

13 is sitting at index 1 I’m going to leave the weight alone and

I’m going to leave the weight alone, and then I’m just going to convert every other tuple

to indexes. So the 13 node, that’s sitting at index 1. The 6 node is sitting at index 2,

leave the weight alone. The 6 node is at index 2, the 12 node is at index 3.

The 6 node again is at index 2. The 15 node is at index 4, again leave the weights alone.

The 12 node is sitting at index 3, the 3 node is sitting at index 0, leave the weight alone.

The 18 node is sitting at index 5.

The 3 node is sitting at index 0.

I think I’m going too fast.

I’m probably going to screw something up.

We’ve got index 5 there for the 18, and then 6 is index 2.

18 is index 5.

12 is index 3.

18 is index 5.

15 is index 4.

So all I did was just convert every node value or pointer, if it’s in your code, to an index that references the vertex list.

the vertex list why would I want to do this okay so like last time we said we

would do O of E it would be linear time based on the number of edges if we’re

performing some sort of a search or examination of all the edges so we have

to like scan all the edges and then eventually we come to something we’re

interested in maybe we realize oh that’s that’s a special edge we want to see

what’s going on there maybe we want to grab those nodes and extract more

information from them or modify them or do something to them this representation

tells us

this representation tells us exactly where to go,

because this 5 is an index, it’s not a node value.

Same thing for the 2.

So index 5 gives us the 18,

and index 2 gives us the 6.

Notice how we still actually were looking for the 18 and 6 nodes,

like we were in the previous, I guess, representation.

So now, instead of scanning the vertex list,

we can just jump directly to an index,

jump directly to an index and you know remember like if you’re using an array or a vector it’s

going to be constant time to jump to an index it’s like very very fast it’s the holy grail

of time complexities so it’s really going to be something like o of e plus c or one or whatever

you want to call it but it’s going to reduce to just o of e so it’s going to be a little bit

faster notice how you know this one is going to take more time than that one maybe i’ll put it in

red to make the

it in red to make the the more than the greater than operator feel feel bad and evil but anyway

this is how you do edgeless representation if you’re interested in the in all four uh types

of graphs being represented with an edgeless representation check out all my other videos

please leave a comment with ideas for stuff you want me to go over but i think i’m finished with

this video it’s been 15 minutes already i don’t remember what i forgot to say but i guess we’re

done now thank you so much for watching

we’re done now thank you so much for watching i hope you learned a little bit of stuff and had a

little bit of fun i’ll see you in the next video i’m gonna get my gear i’m just kidding i’m gonna

eat a bunch of cookies i’m just kidding i shouldn’t do that but i probably will

hey everybody thanks for watching this video again from the bottom of my heart i really

appreciate it i do hope you did learn something and have some fun uh if you could do me a please

a small little favor could you please subscribe and follow

subscribe and follow this channel or these videos or whatever it is you do on

the current social media website that you’re looking at right now it would

really mean the world to me and it’ll help make more videos and grow this

community so we’ll be able to do more videos longer videos better videos or

just I’ll be able to keep making videos in general so please do do me a kindness

and and subscribe you know sometimes I’m sleeping in the middle of the night and

I just wake up because I know somebody subscribed or followed it just wakes me

up and I could feel

followed it just wakes me up and i get filled with joy that’s exactly what happens every single time

so you could do it as a nice favor to me or you could you could troll me if you want to just wake

me up in the middle of the night just subscribe and then i’ll i’ll just wake up i promise that’s

what will happen also uh if you look at the middle of the screen right now you should see a qr code

which you can scan in order to go to the website which i think is also named somewhere at the

bottom of this video and it’ll take you to my main website where you can just kind of like see

all the videos I published, and the services, and

I published and the services and tutorials and things that I offer and all that good stuff and

If you have a suggestion for

Clarifications or errata or just future videos that you want to see please leave a comment or if you just want to say hey

What’s up? What’s going on? You know, just send me a comment, whatever

I also wake up for those in the middle of the night. I get I wake up in a cold sweat. I’m like this

It would really it really mean the world to me. I would really appreciate it. So again, thank you

it. So again, thank you so much for watching this video and, um, enjoy the cool music as,

as I fade into the darkness, which is coming for us all.

ご視聴ありがとうございました

Teksting av Nicolai Winther

Hey there!

The post Directed Weighted Graph Edge List Representation appeared first on NeuralLantern.com.

Learn graph basics: nodes, edges, neighbors, adjacency. Undirected vs directed, unweighted vs weighted. Representations including edge list, adjacency list, and matrix. Great intro for computer science students.

00:00 Graph Basics Introduction
00:41 Nodes and Edges
01:20 Node and Edge Classes in C++
03:46 Simple Graph Examples
04:29 Adding Edges – Undirected Unweighted
05:26 Real World Uses of Graphs
07:08 Graph Terminology – Neighbors and Adjacency
08:32 Edges Incident on Nodes
09:20 Graph Representations – Edge List
09:59 Adjacency List
10:27 Adjacency Matrix
11:19 Directed Graphs
13:04 Weighted Graphs and Path Costs
15:24 Video Conclusion

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hello there. Let’s talk about graphs in the context of data structures and computer science.

I just want to talk to you about some of the basics of graphs, some ways that we could

implement them in the future, and some terminology. Okay, so for starters, we have a little

For starters, we have a little blank graph sheet here.

If you saw my previous video, you’ll know already that this is a valid graph.

It’s just totally empty.

There’s nothing on it.

But let me draw some data in this graph.

So graphs are collections of nodes and edges, or vertices and edges, or vertex and edges.

The nodes themselves, they are custom classes sometimes, other times not.

But you can imagine that they hold some sort of custom data.

of custom data so i know i did this in my last video but i just want to emphasize that this graph

class if we’re talking about c plus plus it should be a template class meaning we can specify a

custom data type that the nodes will hold and also a custom data type that the edges will have as

their weight you know typically when you see examples of this in the wild it’s just going to

floats and strings exotic custom classes depending on your use case it may or may not be useful to do

that but so we’ll have a data type for our nodes and i’ll call it like n type for like our node

type and then we’ll do another one called e type for edge type i don’t know if that’s the best way

to write those but i’m just going to do it anyway imagine that your glass your graph like we said

So I’m going to put a node class here.

You can imagine this as a vertex class.

And I’m going to say that this node holds an n type data.

And we’ll just call it data or node value or whatever you want.

And then the same thing for the edges.

We’ll say we have an edge class.

I think in my last video, instead of doing a node class, I did a vertex class.

It’s kind of all the same.

We’ll say we have an e type and we’ll call it weight or value or data if you want.

or value or data if you want but I think weight is a little bit closer to what we’re going to

actually be doing with it and what do I mean by n type and e type like what are those data types

there that just means these are placeholder tokens so when the user actually uses your graph by

making an instance of your graph class like they create an actual graph off of your blueprint

class here they might decide that they want integers inside of their nodes so that’s what

They might decide that they want floats inside of your nodes, inside of their nodes, or some

other data type.

And so that means like at runtime or at, I think actually at compile time for C++, this

end type would actually change to int if they chose to use integers on the inside.

Same thing would happen for the edge, whatever they choose for the E-type token is just going

to end up being used at compile time to replace that E-type.

So I don’t know.

Here’s an example.

example, I got a fly in my room, it’s bothering me. Imagine the user says I want a graph.

And I’ll call it G. And so they just have to kind of specify the two data types, maybe they want the

graph to have integer values in the nodes. And maybe, you know, floating point double precision

floating point values on the edges. In terms of weights, you know, you could do something like

And we have edges and this graph right here is valid.

It’s just one node kind of floating around by itself.

This graph is also still valid, even though we have two nodes that are floating unconnected

and also with the same value.

I’m just going to change the value to be different.

Maybe I’ll get rid of this extra thing here.

So this is a valid graph still.

We could have like a whole bunch of nodes all over the place and they don’t really have

to be connected.

This is still a valid graph.

change this to like a three, maybe change this to like an 11, change that to a six.

What else can I change?

How about like a 13?

How about like a 17?

Are there any duplicates?

I don’t think I see any.

All right.

So this is a valid graph.

The next thing that we could add to our graph is edges.

So edges are, you know, little mini data structures that connect nodes.

In this particular graph, I’m choosing to not have direction on my edges, which means this is a special type of graph.

Or four that we talked about in the previous video.

This is unweighted and also undirected, meaning there’s no weight assigned to the edges,

which means that template weight value or the weight data type that we just talked about before.

It’s kind of useless for this particular graph because I’m saying it’s unweighted.

well uh all the edges if we wanted to travel through the graph along the edges we could just

sort of go in any direction we felt like so this is unweighted and undirected

um let’s see what else can i show you real fast okay so let’s talk about um well really fast let’s

talk about the uses that you can have for a graph i think i talked about this in the last video

but um you know what can we use graphs for some people think they’re databases they’re not really

They’re not really databases.

You could technically do that, but it would be pretty slow.

There are much better data structures for databases.

Really what graphs are mostly used for is to represent relationships between different

things.

I think I said this in the last video.

Imagine if every single node that you see here is a city and the edges represent flight

paths.

So we could fly between city seven and 11.

Oh, that’s funny.

I’m hungry for candy bar now.

between city seven and 11 and back and you know back in the other direction if we want to but we

can’t actually fly from city seven to six because there’s no edge there so we could represent

computer networks we could represent road maps airports dependency graphs game maps you could

say like every node is somewhere your character could stand and an edge represents where your

or represents a connection to another node so that you know your character could move there

there’s all sorts of different things that you could represent with the graph but

it’s not necessarily a fast database it’s more of like a relationship

not to be confused with relational database which is supposed to be lightning fast

like if i wanted to search for the number 17 in this graph it’s not going to be log time like a

proper database should be it’s not going to be constant time like a hash table based database

or like a no sql or whatever um so we have undirected and unweighted uh we talked about

like different uses let’s talk a little bit about terminology okay for starters notice how there’s

no hierarchy in this graph in other videos we’re going to talk about binary search trees and we

have to have like a hierarchy there’s no parent there’s no child in these graphs there’s no uh

you know like grandchildren ancestors descendants because there’s not really like a hierarchy it’s

It’s just things are connected to each other or they’re not.

But we can have something called neighbors.

For example, if you can reach a node in one hop, then you might be able to call that a neighbor.

So 6 and 17, those are neighbors.

Maybe I’ll just type neighbors right here.

Oops, neighbors.

Because we can reach them in one hop.

Later on, or especially if I don’t remember to mention this,

to our graph, then something is only considered a neighbor if you can reach it while respecting

the direction of the graph. So we have like neighbors as 6 and 17. So that means 6 and 11

are also neighbors. 6 and 12, not neighbors because they can’t reach each other in one hop.

Let’s see. Adjacency is basically the same thing. I can’t remember. I think we use adjacency more

often in directed graphs, but we could say that 6 and 17 are adjacent to each other,

adjacent to each other, which is in this context, sort of a synonym for neighbors.

Okay. Something else that I want to talk about in terms of edges,

edges are considered to be incident upon nodes or vertices. So like, you know,

if I have an arrow that just kind of points to these two things, I could say,

you know, edge is incident upon three and 12. It’s just, it just means,

and 12th. Okay, what else should we talk about? We should talk about connected versus, no,

that’s another video. Okay, I’m going to do another video for connected versus not connected graphs.

Maybe I should mention that there are three ways that we can represent a graph, and then maybe I’ll

upgrade to a directed graph in a second. If you want to know about the four different types of

graphs, see my previous video. But for now, I’m going to say there are three ways we could

to represent these graphs. The first way, and I’m talking about how can you represent these

graphs inside of the machine? Like how can your computer store and process this graph and maybe

run algorithms on it? So the first way that we could represent, at least that I’m going to talk

about, is an edge list. Edge lists are super simple. I’m going to do a dedicated video just

for edge lists in the future. They’re not very fast, but they’re very easy to implement. So

So honestly, if you’re just starting with this stuff, I would recommend just implementing an edge list first

The next thing that you can do to represent a graph in the machine is make an adjacency list

Adjacency lists are just a little bit more complicated

But they’re typically faster than edge lists. Not always not in all cases and

In terms of time complexity, you might not feel like you notice much of a difference

but empirically

the option of skipping a lot of examinations when you don’t need to examine something,

you kind of skip it.

We’ll talk more about that in the future.

But we have an edge list and adjacency list of representation.

And then we have an adjacency matrix.

I wish I had spell check on this.

Otherwise, this is going to be humiliating.

An adjacency matrix is sometimes a lightning fast representation of a graph.

At first, you might think, wow, that’s amazing.

I’m always going to use that.

always going to use that. But all of these representations have strengths and weaknesses.

None of them are better than the others in every single circumstance. So, you know, computer science

and data structures, it’s all about weighing the pros and cons and picking the right representation

or algorithm or whatever that’s best for you and the code and the data that you’re actually going

to run. So three different ways that we can represent a graph in the future. And let’s see,

already on this. We talked about the basic ways to use them sort of. We talked about neighbors

and adjacency. Oh, I got to upgrade to a directed graph real fast just to kind of show you the

difference here. Okay, so I’m going to duplicate this and I’m just going to start adding direction

to all my edges. In my previous video, we talked about this. If you add direction to even one edge,

then you have to add direction to all the other edges. Otherwise, you will have an invalid graph.

graph so notice how I add a direction to one edge I now have an invalid graph so

I’m just gonna do this change every single edge so that every single edge

has a direction you know the basic thing we kind of talked about this in my

previous video is that when traveling through the graph you’re supposed to

only be able to travel in the direction of an edge which means if you look at

this thing right now you’re supposed to be able to go from 11 to 7 but you’re

be able to go from 7 to 11 because that violates the direction of the edge. When we add direction

we’re sort of like reducing you know the flexibility of the graph so you can imagine

that the previous version that was undirected it was sort of like every single edge here

was really two edges pointing in opposite directions if that makes sense. So if you

wanted to make sure that you could go back and forth between edge sorry between node 7 and 11

the opposite direction you can also do things called parallel edges which is just to say

i’m going to add multiple edges that that go in the same direction from the same start node to

the same end node but i’m not going to do that here that makes it more complicated for some

representations but we can just sort of add a whole bunch of edges i’m just going to say one

going back and forth there and so forth remember in my previous video we talked about weighted edges

about weighted edges which means we could add a cost to traveling along an edge so you could say

something like uh i don’t know going from 7 to 12 let’s add another edge here if there was a cost

on all these weights maybe i should just add that for fun we could maybe calculate which path would

be better so let’s say we got ones over here and we got fives over here um and maybe like a like

and I’m going to do like an eight.

By the way, these sixes don’t have to be the same.

You could just be two different numbers.

So I’m going to do like a three here.

And let me just see, have I added a weight to every single edge?

So I know I did this in the previous video,

but I want to do it again real fast.

If we chose to take a path from seven to 12,

and we said seven to 11, and then 11 to 12,

that’s a very specific path, which is,

it’s going to cost us five to go along that first,

as you have to go along that first edge and then the second edge is going to cost us six

and we’re only traveling along two edges so the total cost of that path is 11.

On the other hand let me actually make this look pink.

On the other hand if we’re taking a different path we might come up with a different cost

depending on the graph. So let’s say we start at 11 start at 7 maybe we want to go down to 3

to three and then from three we’ll go to 12 well that might be a different cost so i’m going to say

the cost of this particular path is traveling it’s going to cost us one to go down that first edge

and then a two to go down that second edge which means the total cost of getting to 12 is only 3

if we take that orange path versus 11 if we take that pink path i hope you’re starting to visualize

how graphs might be useful to visualize costs if this is a network map we just figured out that

network map we just figured out that one route through the network might be faster or less

costly than the other or if this is like an airport map maybe you do want to take you know

that layover that goes down south instead of that layover that goes east in terms of

i don’t know frequent fire miles that it costs you or money it costs you or jet fuel that it

That’s all I wanted to talk about in this video.

I’m going to make one more video today.

Well, it’ll be released.

I don’t know when, but like in my present moment.

I’m going to make another video right after this

where we just talk about connected graphs versus not connected graphs.

Thank you so much for watching this video.

I hope you learned a little bit of stuff and had a little bit of fun.

See you in the future.

Okay.

In the future.

in the future.

So we’ll be able to do more videos, longer videos, better videos, or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could troll me if you want to just wake me up in the middle of the night.

Just subscribe and then I’ll just wake up.

I promise that’s what will happen.

happen also if you look at the middle of the screen right now you should see a QR code which

you can scan in order to go to the website which I think is also named somewhere at the bottom of

this video and it’ll take you to my main website where you can just kind of like see all the videos

I published and the services and tutorials and things that I offer and all that good stuff and

if you have a suggestion for clarifications or errata or just future videos that you want to

videos that you want to see please leave a comment or if you just want to say hey what’s up what’s

going on you know just send me a comment whatever i also wake up for those in the middle of the

night i get i wake up in a cold sweat and i’m like it would really it really mean the world to me i

would really appreciate it so again thank you so much for watching this video and um enjoy the cool

so

Thank you.

The post Graph Basics in Data Structures: Nodes, Edges, and Representations appeared first on NeuralLantern.com.

In this video we break down the four main types of graphs used in computer science: undirected unweighted, undirected weighted, directed unweighted, and directed weighted.

We start with the basic idea of graphs – collections of nodes (vertices) and edges – and then explore each type with clear examples. Learn how these graphs represent real-world relationships like computer networks, airport routes, road maps, and game maps.

Perfect for anyone learning data structures, algorithms, or preparing for coding interviews.

00:00 Introduction to Graphs
00:19 Basic Graph Definition
00:48 Nodes and Vertices
01:01 Empty Graph Example
01:17 Graph Implementation Concepts
02:02 Node Data and Templates
03:22 Adding Nodes
04:00 Adding Edges
04:44 What Graphs Represent
05:36 Graph Use Cases
06:56 Real-World Examples
08:35 Four Types of Graphs
08:52 Undirected Unweighted Graph
10:40 Unweighted as Unit Weights
11:40 Undirected Weighted Graph
13:32 Weighted Graph Benefits
15:52 Directed Weighted Graph
19:50 Directed Unweighted Graph
20:32 Summary of Four Graph Types
21:19 Closing and Future Videos

=-=-=-=-=-=-=-=-=

Thanks for watching!

Find us on other social media here:

• https://www.NeuralLantern.com/social
• Twitter / X: https://x.com/NeuralLantern
• Rumble: https://rumble.com/c/c-3696939
• BitChute: https://www.bitchute.com/channel/pg1Pvv5dN4Gt
• Daily Motion: https://www.dailymotion.com/neurallantern
• Minds: https://www.minds.com/neurallantern/
• Odysee: https://odysee.com/@NeuralLantern:5

Please show your support!

• Buy me a coffee: https://ko-fi.com/neurallantern
• Subscribe + Sharing on Social Media
• Leave a comment or suggestion
• Subscribe to the Blog: https://www.NeuralLantern.com
• Watch the main “pinned” video of this channel for offers and extras

Hello there! Let’s talk about four different types of graphs that you can use and how they relate to computer science.

Okay, so you can see like I’ve got like a blank little graph paper up here.

I’m going to talk about graphs and just the very basic idea of graphs in general

and then show you the four different types of graphs that we have.

about how to implement graphs inside the machine, time complexities, maybe graph algorithms,

and a whole bunch of stuff, terminology, everything. Okay, so the first thing is, I guess I’m going to

assume probably most of you have sort of seen a graph before and you kind of understand a little

bit about it already, but I’ll say that a graph is basically a collection of nodes, also known as

vertices or vertexes, and edges, which are the lines that connect nodes to each other. This screen

See, this is a valid graph.

I’m not talking about the graphing paper.

It’s just an empty graph.

There’s nothing there.

So it’s still valid.

It’s just blank.

Okay, so then what I want to do is start drawing some nodes.

What are the nodes again?

Those are just vertices.

Those are just like little data structure objects you can imagine in the code.

I don’t want to get too far ahead of myself, but imagine that you have a class called graph.

This is just one way to imagine.

We have a class called graph and then a nested class inside of a graph called a node or a vertex

If you want to be more fancy

So the vertex class itself by the way

This is not always going to be the way that you actually do this in your code the other representations that we’ll talk about sooner a little bit easier, but

The vertex class itself needs to basically hold some data

Depending on your implementation it might know about who it’s connected to maybe the graph knows that instead

instead. In my implementations, the graph is going to know everything, but the vertex or the node

itself needs to hold one piece of data. That’s kind of the whole point. So I’m going to say that

the data type that these nodes hold are just integers. So I’m just going to put like a six in

here just to indicate we have one node and the templated data type that it holds is an integer.

And the specific integer for this specific node is just the number six. You can have any template

any template type if you really want to you can people put floats in there you could put a custom

custom class in there whatever you want but i just want to show you that we have a class called

vertex or node and inside of it’s got a template type maybe just to make this a little bit more

clear i’ll say you can imagine inside the vertex class uh there is a template type and we’ll call

it uh i don’t know node node value type or something and we’ll call it data and then up

I’m doing C++ up here.

We have to kind of define the whole graph class as a template class.

Now, of course, you could define the vertex class as the template class,

but if you define the graph class as a template, then it all kind of falls through.

So I’m just going to say class node value type.

And so if you’ve written template classes before in C++,

now you know that the user can instance the graph and at the same time,

specify what is the data type of the stuff that the nodes hold.

the stuff that the nodes hold.

We do the same thing for edges too,

but notice how there are no nodes that are connected to each other.

So we have no edges in this graph.

This is still a valid graph,

but we could just sort of copy a node just for fun and say,

all right, we’ve got two nodes now, two vertices.

They could have the same value if you want.

Graphs are supposed to, you know, support duplicate values in the nodes,

but I’m just going to change the value here.

This is also a valid graph.

You don’t really need edges to have a valid graph.

edges to have a valid graph. This is just something called a something called a graph that is not

connected. We’ll talk about all that terminology and how to detect it in a future video. For now,

I’m just going to say we have like a little graph here, which is kind of boring, but I’m going to

add an edge. An edge is basically just, you know, a little mini data structure that connects two

nodes. Depending on the way you represent this in the machine, which we’ll talk about in future

well, a whole bunch of different ways.

You could imagine this as a full-fledged class,

although that’s not always going to be the way that we represent an actual edge.

So imagine that we have a nested class called edge.

And inside the edge class, we’ve got, you know, some stuff.

We could have a weight, which means the cost of traveling against the edge.

We could have many other properties.

For now, I’ll just try to keep it simple.

is pretty much a collection of vertices and edges and some sort of connection.

What is a graph really for?

Some people at first think that a graph is another way to represent a database.

I’m going to erase this thing over here.

Graphs, you could sort of use them as databases,

but they’re not very good as databases because

it would be really, really slow to search through the graph

to find some piece of data that you’re looking for.

It could be like a linear time database.

better would be to take this graph and add a bunch of rules as you probably have found

in my other videos by now and turn it into a binary search tree.

A binary search tree is lightning fast.

It runs in log time.

Hash tables are faster than binary search trees, but basically a graph is always going

to be way slower than a binary search tree unless the binary search tree is severely

imbalanced.

But that’s something for another video.

Anyway, so we have a graph and it’s not a good database.

What would a graph be good for?

would a graph be good for? Well, graphs are usually pretty good to help you represent

relationships between things. For example, the six and the one, imagine the six is something,

maybe it’s a computer, maybe it’s a city, maybe it’s, I don’t know, like a train station,

and the edges could represent connections. So I’m just going to start changing these values

have some nodes just kind of hanging out off to the side, not really connected to anything.

Maybe not great for your particular use case, but like it’s a valid graph. So I’m just going to,

I’m just going to connect this and try to make this into a better graph.

That’s a little bit more interesting. So we’ve got graphs that do a whole bunch of different

things. Let me change these values real fast. I’ll maybe turn that into a 13 and turn that

So imagine that we have like a little connection here, a little connection here, maybe another

connection here and another one there.

And you know, you are allowed to have connections that sort of look weird, like going from this

six all the way around to this 13.

That’s totally valid also.

So I’ve basically just drawn a random graph, random nodes and random edges.

Imagine that every single node here is a computer in a computer network and imagine every edge

every edge which connects the nodes is just some sort of a connection let’s say a network cable

or a wi-fi signal or something like that so if you imagine it that way then this graph could

represent a network topology a bunch of computers connected together if these were cities and this

is like actually maybe these are airports in cities you could imagine a graph could represent

the relationship between different airports in which planes will fly notice on this graph just

that the uh you know the uh the city number one uh there are no flights connecting it directly to

city 44 but you could probably imagine well if we take a flight to uh from city one to city 10 and

then from city 10 to 44 then we can get from one to 44 we just have to be clever about our connecting

flights um let’s see so we could do like road maps airport maps the worldwide web is basically a graph

at least from a certain perspective electrical circuits that are connected to each other

are connected to each other even game maps what if your character is allowed to stand here in

in space number three on some map and the character is only allowed to travel to space 13 or

space 6 but not directly to space 1 well it could be a map that helps you understand where your

character can go in a game okay so that’s like the basic idea of of what a graph is and uh how it

actual four types of graphs that I’m going to go over in more detail in future videos. Let’s see,

what time is it right now? We got like 10 minutes. Okay, so I can still kind of make this fast.

So the first type of graph that we’re looking at right now is actually something called an

undirected, unweighted graph. Why is it, let’s see, let me write this down first. It’s an undirected,

undirected, unweighted graph. So why is this undirected? Because the edges don’t have direction.

If I was standing in, you know, city six and I wanted to like drive or fly or whatever

from city six to city three, then I should be able to do it because this edge that connects

them doesn’t really say that I have to go in one direction or the other. I could also go to city

three and then just walk right back or fly right back to city six. There’s no direction. So there’s

no direction. So there’s an this that’s that’s why this is an undirected graph. This is an

unweighted graph because we haven’t specified a cost for traveling along an edge. For example,

if you know, if you’re at city three here, and you want to fly to city 13, how much jet fuel

does it cost? How much time does it cost? If three is a computer and 13 is a computer,

and the edges like a network cable, like how much money does it cost to transmit the data?

transmit the data or what is the lag in milliseconds.

You know, you can represent all sorts of things with these edges,

but there’s no value on these edges,

which means there are no weights to these edges.

So that’s why this is an undirected and also unweighted graph.

Uh, the first upgrade that I want to do is just kind of show you what you can

sort of assume about an unweighted graph. This is not always true.

It just depends on who you talk to and what your application implementations are.

So imagine the node that goes from six, sorry, the edge that goes from six to one.

If it’s an unweighted graph, you could just probably imagine that every weight is just a one.

The point being that it always costs the same amount to travel along every edge,

because in an unweighted graph, we don’t differentiate between the different edges

in terms of their costs.

We could just put a bunch of ones on all these edges.

And it would still, you know, basically be considered an unweighted graph.

It depends on who you talk to.

maybe all the weights are zero, maybe all the weights are 10 or whatever.

But, you know, usually I put a one there because I’d like to imagine the cost could just be the number of hops.

So, for example, if I wanted to go from city six to city 10,

I could probably, you know, start at city six and then go to city one and then hop to city 10.

How many actual hops did I do? I did two.

I could also come up with that number by just looking at the sum of all the weights of all the edges.

all the edges. So notice how when I go from six to one, that costs me one weight or one hop. And

then when I go from one to 10, that’s another one. So if you put ones on all the edges in an

unweighted graph, then you’re kind of saying the total cost of some path is really just the number

of hops. So it’s up to you. Anyway, that’s unweighted and undirected. Let’s upgrade this

see we have an undirected and unweighted and i’m just going to duplicate this real fast and change

this to a weighted graph so undirected but also weighted and the thing is as soon as you start

putting numbers on a graph on the edges of a graph well then it’s considered weighted so even even a

graph that has all ones on all the edges you could also call that weighted but now you have the

freedom since it is considered a weighted graph to just assign different values to all the edges

to all the edges. Again, these edges are a class sometimes, or you can think of them that way

inside the graph. And the edge weights themselves are definitely considered a T type, a templated

type, which means, you know, right now I’m clearly typing integers, but you could type some other

data type. You could type floats. You could type some weird data type, like a string.

Whether or not that’s going to be useful depends on your program, you know, what you’re trying to

you know, what you’re trying to do with the graph. But let’s see, I think I’ve added custom numbers

to every single edge. So now this is definitely an undirected, but weighted graph. That’s the

second type of graph that we’re talking about. Okay, what’s what’s cool about a weighted graph?

Well, imagine again, that this is an airport map, where we’re representing relationships between,

you know, cities, like where can we fly and stuff. We’re basically saying at this point,

it’s going to cost you 44 of something.

Maybe this is a graph representing jet fuel or time or frequent flyer points or something like that.

If you consider your edges to be custom classes,

you could even put a whole bunch of different types of values in your graph at the same time

to make it a little bit more flexible.

But for now, we’ll just say there’s one templated type,

which means if we go back up to this code real fast, where was that code at?

Where was that code at?

And we had, you know, our rough idea of, you know, what the, what the graph holds, you

know, it holds like vertices and edges.

We could upgrade this just a little bit to say that there is a, an edge value type.

So I’m going to say class edge value, edge weight type, something like that.

for the edge so that I can save characters. And then here, I’ll change this to a type for the

node. This is why we call it T type. There’s like, we put the keyword template here in C++.

And then sometimes people just use T’s here for these tokens. So I’m just going to say

the type of data that a node can hold is going to be the T node. And then the type of data that

the edge could hold would be the T edge. We’ll call that data. Or we could call that weight,

because usually that data comes into play when you’re traveling along an edge, right? So there’s

traveling along an edge, right? So there’s like two different types here. Anyway, so we got an

undirected and unweighted graph. If we traveled from city six to city one, that costs us 44. But

if you look at the graph a little bit more closely, we could take the longer way around. We could say

go from six to three, and then go from three to 13. And then actually, let me change the color

to orange so that you can see there’s different paths, six to three, and then three to 13,

and then 13 to one, even though we took more hops,

and that might have been considered more expensive

in an unweighted graph,

you can see that the cost of the first path

from six to one, that’s 44.

And the cost of the second path is seven plus three,

that’s 10, and then plus nine, so that’s 19.

So if we take the long way,

it actually costs us less

of whatever we’ve determined this unit is.

You know, less jet fuel, less time, less whatever.

less whatever these graphs in the machine are not necessarily going to be to scale because the

machine in your computer your computer doesn’t really keep track of like the physical positioning

of all these nodes and edges it just can keeps track of the relationship between the nodes and

the edges and the weights and all that stuff so two different paths that we could take to get

from six to one one of the paths is less expensive um or less time costly or just whatever and a graph

data structure can kind of help us figure that out if we’re using an algorithm that understands

weights okay so undirected and unweighted let’s add direction so um i’m going to erase this stuff

right here real quick and in an undirected graph remember you can just kind of go in either

direction along any edge but in a directed graph every single edge needs to have a direction so as

I change one of the edges to have direction, then I must change all of the edges to have direction

as well. So I’m just saying, okay, as soon as I did that, now this is an invalid graph

because some of the edges don’t have direction. So now I need to fix everything. So I just,

I’m going to arbitrarily and randomly choose a direction for every single edge like this.

And then as soon as I’m done, I’m going to deal, I guess, with that giant edge

that giant edge. So I’m going to go like that. So let’s see, all the edges seem to have direction.

Now I’m just going to hand draw an arrow on one side of this giant edge. Okay. So this is directed

and also weighted. What can we do with the directed graph? Well, it just basically tells

you which direction you’re allowed to travel in. What if you have an airport where city six can

only fly to city one, but city one, for some reason, never flies to city six. You got to take

take like the long way you got to go from city one to 13 to three to six that’s something that

a graph could help you represent what if your character in your game can only go in one direction

but not the other direction okay no problem i mean that’s pretty much it you’re only allowed

to travel in the same direction as the edge points but now we have a graph that is a lot less

flexible because for example before we used to be able to go from city uh 10 to city 44 and then

then come back again later if we wanted in the opposite direction. We can no longer do that

because this edge only goes to 10. It doesn’t even go to 44. We can’t even ever actually get to 44.

How do you sort of solve that? Well, just add another edge in the opposite direction.

In graphs, you are allowed to do something called a parallel edge,

which just basically means, you know, two edges between the same pair of nodes that just point

in the same direction. You’re also allowed to do, you know, opposite facing edges. So

edges so i just added a second edge there going from 10 to 44 and now if i was you know hanging

out in city 10 i could just go back and forth between city 10 and 44 as much as i wanted to

oh i forgot to add an edge weight for that new edge which means i wrote down an invalid graph

so i’m just going to say two so uh maybe the wind is blowing in in your favor when you’re going from

city 10 to city 44 maybe it’s blowing against you if you’re talking about city 44 to city 10 you

you know whatever but you just have to have edge uh edge weight on every single edge

okay so uh that’s directed and also weighted um and you can probably imagine previously when we

had an undirected um graph when there was just like you know one edge going between uh two nodes

and there was no direction on it like you know 44 to 10 if we just had like one edge with no

have two edges each going in the opposite direction so we have directed and weighted i think the last

thing that we didn’t do was directed and unweighted right so we have let me just double check real

fast here we have undirected and unweighted and then we had undirected and weighted and then

directed and weighted okay so now let’s do um i’m getting lost already oh my gosh i can’t believe i

I saw undirected and unweighted so we did undirected twice already undirected so we’re

going to do directed and unweighted next okay so the next graph a little bit less useful than

what we’re looking at this this type of graph is a little bit more useful we’re going to do

directed and unweighted oh my god okay directed and unweighted so directed and unweighted you

Directed and unweighted, you can imagine, just means we get rid of all these weights.

And then we keep the direction on all the edges.

So this means we can keep track of where we’re allowed to go, if we’re pathfinding or just whatever.

But we don’t really know what it costs to travel between the different graphs.

So that’s directed and unweighted.

Let’s see here.

I’m going to just duplicate this or just make a new blank slide.

Okay, undirected, oh gosh, I’ve got pink letters.

Let’s see, undirected plus unweighted.

And we’ve got undirected plus weighted.

And then we’ve got directed plus unweighted.

I don’t think I’m writing these down in the same order,

but that’s okay.

And then we’ve got directed plus weighted.

So basically, you know, four types of graphs

that we can talk about.

In future videos, we’re going to go over graphs

in more detail.

We’ll talk about graph terminology,

maybe some pathfinding algorithms.

And yeah, so this is just a basic intro.

How much time do we spend already?

Oh God, we spent so much time.

Spent like 22 minutes.

Dang, man, even the smallest thing takes time.

So I’ll see you in a future video

when we talk more and more and more about graphs

and other data structures concepts.

Thanks for watching this video.

I hope you learned a little bit of stuff

I hope you learned a little bit of stuff and had a little bit of fun.

I’m out of here.

Go.

Hey, everybody.

Thanks for watching this video again from the bottom of my heart.

I really appreciate it.

I do hope you did learn something and have some fun.

If you could do me a please, a small little favor,

could you please subscribe and follow this channel or these videos

or whatever it is you do on the current social media website that you’re looking at right now,

it would really mean the world to me.

And it’ll help make more videos and grow this community.

So we’ll be able to do more videos, longer videos, better videos,

or just I’ll be able to keep making videos in general.

So please do me a kindness and subscribe.

You know, sometimes I’m sleeping in the middle of the night

and I just wake up because I know somebody subscribed or followed.

It just wakes me up and I get filled with joy.

That’s exactly what happens every single time.

So you could do it as a nice favor to me or you could you control me if you want to just wake me up in the middle

And I just subscribe and then I’ll just wake up. I promise that’s what will happen

Also, if you look at the middle of the screen right now

You should see a QR code which you can scan in order to go to the website

which I think is also named somewhere at the bottom of this video and

It’ll take you to my main website where you can just kind of like see all the videos

I published and the services and tutorials and things that I offer and all that good stuff and

and if you have a suggestion for clarifications or errata or just future

videos that you want to see please leave a comment or if you just want to say hey

what’s up what’s going on you know just send me a comment whatever I also wake

up for those in the middle of the night I get I wake up in a cold sweat I’m like

it would really it really mean the world to me I would really appreciate it so

enjoy the cool music as as I fade into the darkness which is coming for us all.

Thank you.

I’m going to go ahead and get started.

Thank you.

Hello there.

Let’s talk about the four types of…

Hello there.

The post 4 Graph Types: Undirected vs Directed, Weighted vs Unweighted appeared first on NeuralLantern.com.