Learn how to represent an unweighted undirected graph using an edge list. We build a sample graph with nodes and edges, then show the vertex list and edge list as tuples. See why storing indexes instead of node values makes lookups faster in constant time. Follow along as we list every connection without duplicates. This is the first in a series covering all four combinations of weighted and directed graphs with edge lists.

00:00 Introduction to Edge List Representation
00:56 Drawing a Sample Graph with Nodes
02:05 Adding Undirected Unweighted Edges
03:10 Graph as a Tuple of Vertex and Edge Lists
03:40 Building the Vertex List
04:24 Storing Nodes as Objects with Indexes
06:13 Creating the Edge List of Tuples
07:00 Listing Edges by Node Values
11:36 Limitations of Storing Node Values
12:30 Switching to Index-Based Edge List
14:08 Constant-Time Lookups with Indexes
16:54 Summary of the Edge List Method
17:16 Preview of Next Videos in the Series
17:44 Closing Remarks and Subscribe Request

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

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 an unweighted,

undirected graph in your machine using an edge list representation.

Okay, so hopefully you watched my previous videos. If you haven’t, you might want to take a step back

and check them out. We talked about, you know, what is a graph? What are some basic rules and

terminology of a graph? Not graph and paper, but a graph. And we talked about representing paths

in graphs.

representing paths in graphs using either a list of nodes or a list of edges and we’re going to

take the edge list concept one step further and we’re going to actually just say this whole graph

is being represented as an edge list it’ll make sense in a little bit but uh so the first thing

i’m going to do is try to set up my stuff which is always set up wrong because i’m the one setting it

up and it always gets messed up okay so i got a graph paper and uh oh i got to make this other

thing full screen. Sorry.

um i’m going to draw a random graph just real fast so i’m going to do i don’t know just some random

nodes so remember a graph is a collection of nodes and edges doesn’t even have to have edges but you

know we’ll just say so we’re going to do that’s bad let me try one more time we’ll get that okay

so we get i’m trying to get this circle perfect because i’m gonna have to duplicate it rare okay

i’ve got a node here and i’m just going to give it an arbitrary value i’m going to say it’s got a 3

and then i’m going to duplicate it a few times just to make a graph that is a little bit

interesting so we have something uh something to kind of challenge us i guess so it’s not

incredibly boring um and then i’m going to change some of the values here and then well i’ll change

the next ones and then we’ll start looking at edges which edges do we want to make okay so

right now we’re just making a graph make this graph along with me if you want to or uh you

you know, after you.

to or uh you know after you think you understand do another graph on your own

okay so i’m gonna make some edges right now remember this is going to be an undirected

unweighted graph so the edges are just going to be lines they’re not going to have direction on

them and they’re not going to have weights on them i’m going to do a line over here i’m just

randomly doing lines doesn’t really matter um what we do exactly the point is going to be let’s

practice represented

be let’s practice representing this graph okay so i’m just making a random graph it’s kind of like

a little bit dense i don’t know um maybe i’ll just stop there and then i’ll add a wonky line just

just to prove we can be cool about this i don’t know we’ll do another one right here so it’s a

slightly more interesting graph okay so um that’s just a graph and uh what i’m going to do is i’m

going to say this is a, you know, an unweighted, oops, weighted.

oops waited undirected uh graph and we’re going to use the edge list of representation

i have spell check on this i really hope i do nope okay i guess i forgot to fix that months ago

all right so then the next thing we’re going to do is uh we’re going to look at the idea of like

how do we start with the edge list representation okay um the first thing i’m going to say is that

our graph

that the our graph in an edge list representation is a tuple just meaning it’s you know some things

put together if you know tuples encoding already uh the tuple is going to consist of a collection

of vertices and edges what’s going to be an edge list don’t make fun of my ease please

anyway so uh let’s do the first thing is going to be the vertex list so how do we represent the

vertex list or the node list well i’m just going to say that my vertex list v

to say that my vertex list v is equal to something and we’ll just put inside of this

some vertices so the easiest way when you’re kind of drawing this right now is i’m just going to

start putting the values of the node i’m going to say well here’s a three and uh i guess i could

sort them for whatever reason uh if we’re going to do binary search on them later but we’re not

going to i’m just going to maybe you know what i’ll go from left to right so that’ll make more

sense, just visually. So I’ll go from left to right. 3, 13, 6, 12.

3, 13, 6, 12, and a 15, and an 18.

You can see all of those are nodes, right?

Somebody stop me if I forgot a node.

Okay, here’s the thing though.

What are we actually storing in this vertex list?

You probably don’t want to store the node values.

I mean, you could be a little slow and dumb though,

but we want the option to be a little bit faster later

and also the option to turn these vertices into full classes,

like give them extra properties and whatever.

So what I’m going to say is that…

So what I’m going to say is that I’m writing down the number 3 and the number 13 here for you, but you should imagine in your code you would have an object of type vertex or node, like a full class, and you would basically be stuffing pointers inside of that vector, inside of that list.

I keep saying list. It is called an edge list representation, but you can probably imagine

that this could just as easily be a vector. If you’ve seen my other videos, you know what that is.

but uh so i want to be able to index this uh faster so for me personally i make this a vector

and not an actual list but we’re going to call it a list anyway so three should be a pointer

uh to a full node object uh smart pointer raw pointer whatever you want 13 should be a full

pointer to an entire uh entirely different node object with just 13 assigned as its uh template

type value because we’re making this a vector we can actually index

can actually index uh the nodes right so like this is like index 0 for the 3 node index 1 for the 13

node so i’m just going to put the indexes here whoops just to drive the point home a little

bit further so if i told you hey let’s do uh the node at index 2 you would know that is the node

that is in the very middle with the value of 6 because index 0 and 1 and 2 brings you to this

node right here um which is a 6 so this is going to this is going to help us later let me save this

Real fast, by the way.

let me save this real fast by the way i’m just going to do that okay so uh the next thing that

we need to do is uh make an edge list the edge list is really where it’s all at that’s really

where all the data is it’s going to tell us exactly where everything is or it’s going to

describe the whole graph pretty much so the edge list is another we’ll say that’s a list this could

be like a linked list or vector or whatever you want i’m just going to say it’s a linked list

and every item in the list is going to be another tuple so remember above the graph itself was a

tuple containing a vertex list and an edge list so the edge list is a list of tuples

meaning you know items bundled together for one tuple and then just like a list of those

so what i’m going to try to do is describe every single edge uh one by one using one tuple each

inside of the edge list so the first thing i’m going to do just you know to make this a little

little bit easier.

thing I want to do just you know to make this a little bit easier is I’m going to ignore the

indexes for the vertex list and I’m going to say let’s describe everything happening from the three

node outwards or just to every other node so the three node itself I’m going to look at its

connections from left to right so the three node let’s just start by putting a three here

maybe I should describe the legend real fast the tuples will basically be the start node

and then the end node

and then the end node and then the uh well the weight if there was a weight but we’re doing an

unweighted graph so it’s really just going to be a tuple of two items the other thing to keep

in mind is that because this is an undirected graph it really doesn’t make a difference what

node is the start node and what node is the end node you can just swap them and it’s totally fine

for me personally i’d rather you know sort before assigning the start node and end node that way

when i read the graph later it’s a little bit faster because i wouldn’t have to check in both

directions but

wouldn’t have to check in both directions but it really honestly doesn’t matter right now so

start node and end node so the start node here is 3 and the end node is going to be 13 so that’s the

first thing that we’re doing that’s the first tuple and then i’m going to say what else does

the 3 connect to it connects to the not the 6 it connects to the 12. okay so the 3 connects to the

12. again we could have said 12 comma 3 wouldn’t have mattered but i’m just going to try to keep

it sorted so then

keep it sorted so then what else does the three connect to it connects to the uh the 18 doesn’t

connect to the 15 and just confirm that if i’m looking at the three i can see three lines

touching it so that means okay there’s got to be three tuples for the for the e for the three so

i’m going to say three connects to the 18. and now i’ve described everything happened to do with the

three note i will simply continue let’s see should i do like a new line maybe i should try to do a

new line for every

try to do a new line for every start node so this is easier to look at okay so i’m going to do that

and i’m going to say the next line is we’ll start at the 13 this time so the 13 the 13 is also

connected to the 3 because it goes in both directions with an undirected graph but we

already described that connection with that first row so 3 comma 13 describes 13 comma 3 i don’t

want to duplicate edges so forget about that let’s look at what else 13 is connected to it’s connected

it to the six

connected to it’s connected to the six so I’m just going to put 13 comma 6 and then that’s the end of

the 13’s connections oh I could have used tabs for that hang on let me do that okay so now let’s look

at the six node six is not connected to the three it is connected to the 13 but we already described

the 13 6 connection in the previous row so forget that and then I’m just going to look to the right

So the 6 is connected to the 12 and the 15.

the 12 and the 15 12 and the 15 and also the 18 so i’m going to do 6 comma 12 maybe i’m going to

do a copy paste here real fast just to make it easier 6 12 and 6 15 and 6 18 so again all i’m

doing is describing you know what other nodes the current node is touching and i’m going to do that

using a tuple that just has one node and has another node and that’s pretty much it so when

we’re done with this

it so when we’re done with this uh we’re going to look at the 12 node 12 node it’s connected to

the six already handled it’s connected to the three it’s already handled and it’s connected

to the 18 not handled yet so i’m going to say 12 goes out to 18. okay then we’re going to look at

the 15 node 15 and 6 that’s already handled in that third row so forget that 15 and 18 that is

is not

15 and 18 that is not handled yet so we’re going to do 15.18 by the way this is one benefit of

going from left to right visually all i really have to do is just look my eyes to the right and

i’ll see nodes that i need to take care of and if i look my eyes to the left i’ll see nodes that i

already took care of if that makes sense so now that we’re done with the 15 let’s see we did 3 13

6 12 15 let’s just take care of the 18 if there’s anything left to take care of i can guarantee

there’s not going to be.

there’s not going to be because every node the 18 is the node on the farthest you know the furthest

to the right so everything on the left is already handled so we don’t even have to put anything for

the 18 node okay give me a second to clean up this graph real fast i think i want to maybe

move this up a little bit okay uh now here’s the thing though we’ve only named node values so if

we wanted to i don’t know let’s say check to see if the uh let’s say we have an edge we’re looking

Thank you.

let’s say we have an edge we’re looking at the 3 comma 13 edge and we’re asking now do both of

those nodes exist the edge describes these two nodes do they exist or uh maybe let’s look at

the three here and we want to figure out just you know what other nodes does three touch so we start

iterating through all the edges here how can we actually get a pointer to that node to manipulate

it in the code right now it’s okay because it’s a diagram but you know this is not very

diagram but you know this is not very good storing values directly in this notation in your code you

probably want to store pointer uh pointers there but maybe not necessarily smart pointers they take

a little bit of extra memory and it’s kind of cumbersome but um we could store an index into

this vertex list to make things a little bit faster let me show you what i mean but first i’m

going to duplicate this list that we just made already, duplicate it over here, and

over here and maybe i’ll label the first one and i’ll say so we already have start node and end

node i’m going to say e underscore by value so we’re storing the edge list by node values and

then here we’re going to store nodes by their index in the vertex list so what do i mean by

index well okay right here the first node that we’re mentioning is the three well look at the

three node in the vertex list it’s at index zero right so i’m just going to put a zero

zero right so i’m just gonna put a zero that’s it change it to an index then i look at the 13

that’s index one and then i look at the three again that’s index zero um and then the 12 is

index three and then the three again is index zero and the 18 is index five um if that was too fast

i’m sorry just rewind and play it back in slow motion i think this video is already getting way

too long so then i do the same thing for every single other tuple so the 13 node um that is

node um that is index one so i’m going to put a one there the sixth node is index two go on to

the next node so the sixth node is index two and then the 12 is index three and the six is two and

the 15 is actually four the six again is two the 18 is five move on to the 12 node here uh that’s

index 3, 18 node is index 5, and then

the 15

and then uh the 15 is index 4 and then 18 again is index 5 so now on you know on both sides like

in both of these edge lists uh i’m representing the graph it’s just that one can be a little bit

more efficient than the other uh for example if i was going to let’s just say i wanted to scan

every single edge in the graph well i could scan this list right here in linear time so linear time

based on the number of edges and every single time i see an edge i can jump directly to the

Corresponding.

jump directly to the corresponding vertex or node in constant time because i have an index

so for example let’s say uh you know this uh the sixth node um touching the 15 node so that

particular edge right there let me i want to be more interactive here how can i do this okay

uh suppose i want to do

612 node and so that’s going to be pointing to this edge right up here i want to see you know

what’s going on with both of those nodes well if i was looking at the value-based edge list

and i wanted to get a hold of let’s say the sixth node itself so i can like do something with that

vertex like delete it or move it or just whatever i would have to then scan the entire vertex list

i’d have to go you know this one this one this one this one this one until i eventually found

the corresponding value.

uh the corresponding value this wouldn’t really support duplicate values either

uh it would be kind of hard to do that but uh i’ve i’ve slowed down the program it’s linear

time based on the number of vertexes and if you’re already doing linear time based on the number of

edges this is like it’s technically still a scalable data structure but it’s not super fast

it could be faster on the other hand uh so like i just said uh sorry for repeating myself if we did

the index

the index based uh edge list it says two three here which is the 612 how can i find the sixth

node well i just look at index two and instead of scanning oh gosh hang on

i’m not as fast as i used to be okay dude there’s like did you see that uh

a whole bunch of pink dots everywhere now what have i done okay

So, uh…

so uh i’m looking at the 612 edge i see that the indexes are two and three that means in constant

time i can just jump directly to i guess i’ll put it in red in constant time index two right there

and index three right there i do not have to scan the vertex list or the vector i guess if it was a

vertex list like an actual linked list then i’d still have to scan because it’s linear time to do

it but if it’s a vector

But if it’s a vector or an array, I can just jump to an index in constant time, so it’s way faster.

So what I’m trying to say is that this representation is what you want to do in the code when it comes to, I don’t know, representing diagrams and stuff.

I don’t know. The one on the left is more human friendly.

So this is the basic idea for how to represent an unweighted and also undirected graph in the machine using the edge list method of representation.

i guess i’m going to cut the video i hope you learned a little bit of stuff and had

a little bit of fun in the next video i think i’m going to do uh weighted uh undirected graphs

and this i’m going to do four videos for this one representation type i’m going to do unweighted

undirected and then weighted and undirected and then unweighted and directed i’m gonna

do all four combinations all right see you in the next video thanks for watching

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.

just i’ll be able to keep making videos in general so please do do me a kindness and uh 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 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

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 see please leave a comment or if you just want to say

hey what’s up what’s going on you know just send

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 music as, as I fade into the darkness, which is coming for us all.

Thanks for watching!

The post How to Represent an Unweighted Undirected Graph with an Edge List 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.