Learn how to store an undirected unweighted graph inside a computer using an adjacency matrix. In this video we build a matrix of ones and zeros where each cell shows whether an edge exists between two nodes. Rows represent the starting node and columns represent the ending node. Because the graph is undirected the matrix ends up as a mirror image across the diagonal. We also cover how to add or remove edges by simply changing a cell value, how self-loops appear on the diagonal, and why this representation lets you check any connection in constant time. The computer only needs the connection data, not the physical layout of the nodes. Perfect if you are learning graph theory, data structures, or preparing for algorithm interviews.

0:00 Introduction to Adjacency Matrix
1:16 Arrays as Two Dimensional Matrices
2:20 Ones and Zeros Represent Edges
3:44 Filling the Matrix for Node One
6:20 Completing the Remaining Nodes
10:38 Finished Matrix and Practice Advice
11:02 Computer Stores Only Connections
11:40 Mirror Property of Undirected Graphs
14:17 Adding and Removing Edges
17:31 Parallel Edges Are Not Supported
18:50 Conclusion and Future Topics

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

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

Hey there! Let’s talk about representing an undirected,

unweighted graph in your machine using an adjacency matrix.

All right everybody, so I hope you’ve been watching my previous videos.

I just did some videos on edge list representation. Before that,

I talked about like the basics of graphs and like terminology and stuff like that.

You don’t need

terminology and stuff like that. You don’t need to watch the edge list videos if you’re not

interested in representing using an edge list, but you should probably at least watch the graphing

video basics if you haven’t. Okay, so what are we looking at right here? I’ve just made a graph.

I made a random graph and I kind of like, you know, wired up a bunch of edges to make it kind

of complicated. I then spent a whole bunch of time making this very beautiful two-dimensional

Matrix, just for you. I’m sorry you couldn’t watch me

you i’m sorry you couldn’t watch me write it you know i sometimes i’ll i’ll have people say that

they like when i yell at myself while i’m drawing something sorry it took too long but anyway what

we’re going to do is take these concepts and put them together and we’ll we’ll say this is how we

can represent the graph inside of the machine so what am i even talking about uh well the first

thing is imagine an array in your machine right an array of integers like an array of uh i don’t know

doubles you know an array of whatever so i’m gonna say like 5.4 and like you know 7.7 and

8 and you know like whatever so i’m just like making an array of numbers probably a lot of

you like this notation but inside your machine an array uh that is one-dimensional could be

interpreted as a two-dimensional array so this matrix up here on the top right of the screen

that’s really a one-dimensional ray array inside of the computer it’s just that we choose to treat

it as a two-dimensional array.

a two-dimensional array and um it’s important to understand that you can jump to any cell

in constant time uh just like you can with a one-dimensional array because getting to a certain

cell is really just a simple mathematical formula i think i’m going to do time complexities of this

in a different video so for now i’m just going to say here’s how we represent the diagram first off

let me label this so i don’t forget uh this is definitely where the heck is that how come that’s

That’s not working, okay.

Oh, this is definitely.

okay uh this is definitely an undirected unweighted graph

trying to type with the pen in my hand i have to change my brain okay

so this is an undirected and also unweighted graph

so for the purposes of this particular graph if it’s unweighted that means in the cells um we’re

just we’re not going to put weight because there’s no weight in the graph i mean you could if you

Wanted to.

the graph i mean you could if you wanted to just say that every edge was a weight of one if it was

unweighted but i’m gonna say let’s forget about you know what is the actual value of an edge

because we don’t really have that in this graph and we’ll just say that if an edge exists then uh

we’ll put a we’ll put a one there and if an edge does not exist we’ll put a zero in there

at the corresponding cell we’ll talk about what cells mean you know what edges in a second

The other thing is because it’s undirected, it doesn’t actually matter.

It doesn’t actually matter whether we’re describing a start node or an end node with an edge because it goes in both directions.

So actually what’s going to happen is this graph is going to be a mirror.

I’ll show it to you in a second, but for now we’ll just say it’s not going to matter what the direction is.

I like to do starting nodes as the rows, even though I just said that doesn’t matter.

It’s just the way that I like to do things because it makes it easier to remember how to do this when you start to add direction to the graph.

the graph so one by one i’m going to look at every single node and i’m going to chart what exactly is

going on with that node in the two-dimensional matrix so i’m going to start uh i guess i’m going

to go numerically because that’s kind of easier i’m going to start with the node index 1. so i’m

going to go here at row 1 because i’m going to say that’s my start node and um where does the

one node connect to it connects to node number two so um let’s see actually i think i’m going

I’m going to say that.

actually, I think I’m going to say that it is not self-connected. I mean, if you consider your

graph to have by default every node is connected to itself, you could put a one there across that

little diagonal line that you see. But I’m going to put a zero saying that these nodes are not

connected to themselves, unless we do a little loop from a node to itself. Maybe I should add

that later. So node number one is connected to node number two. I’m going to write a one there

to say that there is a connection.

What do I mean by that?

What do I mean by that? Just to clarify, this, let’s see, the one two edge, that edge that I

just highlighted in pink, that corresponds to this cell. So the start node, I’m going to do

that in maybe orange. The start node is the row number. And maybe I’ll do like, I don’t know,

light blue or something, baby blue for the destination node. And that’s going to be the

column number. So basically just like the row

so basically just like the row number is where the node where you start what node you start at

the column is what node you end at um and then if you see a zero or a one in that particular cell

at that particular row and column it’ll tell you whether there’s an edge there or not

so i’m going to duplicate this real fast so i can erase the markings i just made

and i’m going to say oops whoa whoa what’s happening here i want to get dude

dude are you kidding me can i just erase it like that yeah okay i keep thinking these are lines i

actually made a diagram in a different program so these are not even lines i can’t even erase this

it sucks so um we did the uh the two node so i’m just going to quickly say the one is connected

also to the three yes or no yes that’s a one uh then the one node is connected to the four

uh yes i’m going to put a one the one node is connected to the

the one node is connected to the five yes so i’m going to put a one a lot of connections this is

pretty good uh and then also to the six and not to the seven so if it’s not connected to the seven

i’m going to put a zero there okay we do the same thing for the two node so i’m going to start at

the two node actually let me duplicate this start at the two node and i’m going to say

we’re now looking at the two node oh my gosh

okay I’m gonna put a question mark I guess we’re looking at the two node and

well is the two node connected to the one node yes we just saw that was true

is the two node connected to itself we said in this particular graph there are

no self connections by default because I want to be able to draw them if that

ends up being true is the two connected to the three I see a connection there I

see an edge so I’m gonna put a one is it connected to the four I don’t see an

edge, I’m going to put a zero.

the four i don’t see an edge so i’m gonna put a zero to the five uh yes to the six uh yes and to

the seven um whoops what did i just do uh the two is not connected to the six i was thinking of the

one uh the two connected to the seven yes okay so we just basically do this over and over and

over again until you have a giant matrix of ones and zeros which can very efficiently store um

store um a graph i mean this is pretty much it this is all you have to do i want to do uh let’s

see three is connected to i’m gonna say one one and a two and it’s not connected to itself by

default put a zero it’s connected to the four nope it’s connected to the five

oh gosh i gotta make that even connected to the five

Oh.

i’m losing my brain here uh yes and then uh three connected to the six right three connected to the

seven uh no okay somebody leave me a comment uh if you have a corruption and then for the four

um let’s see dude this is getting out of control for the four um

yes i’m just going to look at the diagram pretty soon we’re going to start realizing something fun

about an underachiever.

realizing something fun about an undirected graph in that it is a mirror in this matrix

so technically you only have to do like one half of the matrix in your code if you wanted to

so i’m gonna say the one exists um one you know what i should have done i should have just filled

this whole thing with zeros and then change the zeros to ones um okay so the four is connected

to the two, yes or no? Nope. All the fours connected to the three? Nope. Fours connect…

Nope, or it’s connected to the 4, we’re going to say no by default, or it’s connected to the 5, nope, it’s only connected to the two things, it’ll just be the 7 I guess, okay, so we’re going to put a nope there, and then a yep for the 7.

Okay, then the 5 is connected to 1, 2, 3, 4, what if I just did a whole bunch of zeros, and then I overwrote only the ones, that would probably be a little bit faster.

bit faster except for this first time i’m doing it okay and then i’ll just copy paste this

tap it past okay i should have done this should i edit that out of the video i don’t know it’s fun

to watch my mistakes so five to one yes five to two no five to three yes uh five to four

we say no by default five to six yes five to seven yes okay i think that was a little bit

faster let’s see how fast it is this time uh the six is connected to the five well let’s say it’s

the one and then uh a one a three a five and a seven right six one three five and seven okay so

going to be one, three, five, seven. That’s probably right. Again, leave me a comment.

probably right again leave me a comment if i screwed something up i did not practice this

i’m just kind of winging it the seven is connected to uh five six two four five six okay so i’m gonna

do two four five six whoops that six didn’t happen let me just do it again okay all right

so now we have it this is a uh an adjacency matrix that represents the graph that you see on the left

Keep in mind that if you saw a matrix, I mean in general you should probably practice doing this both ways, like look at a graph and then you generate the matrix that corresponds to the graph you’re looking at, but also maybe you’re presented with a matrix and you would draw the graph that the matrix represents.

Try to remember that your computer, in almost every program, it doesn’t really know where these nodes are unless it’s a drawing program or something.

if we’re just talking about relationships which is what graphs are kind of good at um then your

computer

um then your computer doesn’t really care that the three is on the top it doesn’t really know that

definitely not with this adjacency matrix representation uh the three in the computer’s

mind could just be anywhere it doesn’t really even think of where the nodes are it’s just

this node is connected to that node and that node is connected to that node and so forth

we just position the nodes somewhere because we’re humans and it’s fun to look at diagrams

but really this is all your computer knows just all these you know little connection numbers here

So, let me duplicate this and I’ll show you something funny about an undirected graph real quick.

Let’s see, how much time? 12? That’s not too bad.

So, if I do, let’s see, I want to do a little highlighter here.

I don’t get a chance to do that very often.

I’m going to do a highlighter across this identity line, you know, the little diagonal.

It’s all zeros for self-connects.

Maybe I’ll change that in a second.

I’ll make one of the nodes connect to itself.

But notice how if I do this.

notice how if i do this in green

notice oh is the highlighter going to be green now keep screwing that up notice how we have

a mirror happening along the identity line so we have like some some ones here right uh so we have

like two three four five six in the one row if we look at the one column we’ll also see two three

four five six it’s a mirror uh pick you know any other numbers you want let’s look at the uh the

The three column.

at the uh the three column the three column has a one there and then it’s got another one and a one

down below at the five and the six so three is hitting two and five and six uh let me look at

the diagram just to make sure i’m doing this right three is hitting uh two and five and six

it should be hitting one also oh right i didn’t highlight that because it was already highlighted

by that other thing okay so then let’s look at the three row and see if we see a mirror also so

two and then the five and the six notice how it’s a mirror you just tilt your head uh and it really

looks like a mirror and sometimes i like to make a joke when i’m explaining this to people uh you

know if you just kind of like tilt your head a little bit it looks like some cheesy broccoli

i’m personally not a fan of cheesy broccoli i mean i love cheese and if you put cheese on my

broccoli i’m gonna be happy but it turns what’s what was healthy food into junk food it’s like

I’m going to be healthy.

I’m going to have broccoli today.

be healthy i’m gonna have broccoli today good for me yay i’ve earned a double bacon cheeseburger

later but then i put cheese all over the broccoli and suddenly it’s junk food again and it’s like i

do get a little fiber and everything but it’s like not really being that healthy anymore so what

should i do i should just get some more healthy food to make up for the junk food broccoli and

then i’m gonna end up putting cheese on the other healthy food and then i just it’s like an endless

cycle and i just keep eating and eating and eating pretty soon there’s no room for a cheeseburger

pretty soon there’s no room for a cheeseburger i don’t know what to tell you anyway um so this

is how you make an undirected unweighted graph uh with an adjacency matrix we’ll talk about time

complexities and other stuff in the future um uh oh i should talk about how to modify edges okay

so first off let me let me create a self loop real fast i’m going to create a self connect

but let’s say that this four is actually connecting to itself uh with like a little

self-loop. Okay. So, oh shoot.

so oh shoot how can i get rid of all those is that going to work yes it’s going to work yes

i should have duplicated this and drawn on the duplicate maybe i actually did that forgot about

it already i don’t even know okay sometimes i have clever ideas and then i forget what i was

doing then the ideas are just not that clever anymore yes okay what about that highlighter

Okay.

i seem to have screwed up the graph somehow

nope okay forget it um we’ll just pretend that it’s fine so i added that four connection

so how do i modify the adjacency matrix well the four uh row starting node with the four column

ending node was a zero indicating no self-connection now that i do have a self-connection

And I’ll just put a one there, four and.

connection i’ll just put a one there four and four and that’s it pretty easy right let me duplicate

this other one so i don’t have to erase that stuff a second time a second time and um what

will we do if we wanted to uh well let me actually sorry everybody let me just do that four one more

time so i think i just erased the wrong thing we’ll say four and four is a one now and so how

can we say that some new edge has been added?

some new edge has been added let’s add an edge between one and seven pretty easy we just go to

the right spot in the adjacency matrix let me add a little orange line here adjacency matrix

to connect number one and number seven that would be uh we could do row one and column seven

so that’s going to be a one and then remember this graph is undirected so it has to be a mirror

so that means uh row seven and column one also has to be a one so it’s still a mirror

so it’s still a mirror that’s pretty much it and remember you can access these cells

in constant time which we’ll talk about more in a future video pretty nice how do you delete

uh an edge let’s pretend that we wanted to delete uh the connection between the five and the three

so i’m going to put maybe like a little squiggly line right here squiggly line saying that that

edge is gone i can’t actually erase that because this is a i guess i could draw white over it but

you would still see that the blue lines are covered so the five and three connection is

gone now how do

and three connection is gone now how do we do that in inside the adjacency matrix again just look at

the uh row five column three change that one to a zero and then row three column five change that

also to a zero oops not a nine that’s how you get rid of something so you add something uh by just

changing a number you get rid of something by just changing a number self connects are pretty easy

um and then of course after you make the matrix you want to just double check that you did it

correctly I’m not going to do that right now

check that you did it correctly i’m not going to do that right now maybe this is a good exercise

for you at home you can just kind of like look and try to find my mistakes because that’s hilarious

right um what else can i tell you uh this particular scheme does not support um parallel

edges or edges that start at the same start node and end at the same end node as well i’m not

really describing that very well so for example what if i had this three node that is connected

to the 2 node and I want it

that is connected to the two node and I wanted to add a second connection for some reason like

there are reasons to do that I want to have another edge going from three to two and from

two to three so now this is a parallel edge it’s the same it’s an edge that connects the same two

nodes as some other edge how can I represent that inside of this matrix right now I can’t

but one way to do this is to say that every cell where’s the three and the two there it is every

cell in your matrix is not a one or a zero integer but every cell

or a zero integer but every cell is its own uh individual linked list or array or vector or

something that can hold multiple numbers so just to add a little notation here if if that’s what

i mean then i can say well we’ll just say that there are two edges by saying that cell has an

array of two numbers each number representing a connection not the not the greatest way to

to represent it, but in our future

greatest way to represent it. But in our future videos, we’re going to do like directed graphs

and weighted graphs. It’ll make a little bit more sense. But long story short, this is how you do it.

Let’s see. We did 20 minutes for this video. I think I’m feeling okay. There’s lots of properties

and other stuff that we can talk about with graphs. But for now, I’m just going to stop right

here. Thank you so much for watching this video. I hope you learned a little bit of stuff and had

a little bit of fun. Tell your friends and I’ll see you in the next video.

next video how do i stop the recording 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

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 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

just subscribe and then I’ll just wake up.

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

tutorials and things that i offer and all that good stuff and uh if you have a suggestion for uh

clarifications or erratics

uh, 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

and I’m like, it would really, it would 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,

coming for us all.

Thanks for watching!

The post How to Represent an Undirected Unweighted Graph with an Adjacency Matrix appeared first on NeuralLantern.com.

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.

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.