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.