COMP(1511|1911) Week 8 Lecture 2

[00:00:07]Okay. Hello everyone. I won't get started right now. I just really wanted to go live to check that I'd set everything up properly.

[00:00:15]So, I'll just wait a couple of minutes till people join.

[00:01:58]Okay.

[00:02:06]All right. Hi everybody. Um I hope you can still hear me now. I was just waiting for a few more people to join and um yeah, welcome to yeah the week eight lecture two. So we're going to continue with link list. We're going to do a bit of a recap on deletion and we're going to look at a sort of more real world type of application to use link lists with. So yeah, let me know if at any point I'm screeching or you can't hear me or anything like that. Ah, I can see someone in the chat. Hello. Um, all right. A few announcements. They're the same announcements I made yesterday, but just a reminder, you're going to have your mini uh exams as check offs this week. You need to attend in person. You can get more details on the forum. You can sign up for an in-person lab time if you don't normally have an in-person lab time or you can't make your regular one.

[00:03:11]Um, and if you can't make it in person at all for the lab this week, please just email the CS1511 account. Um, and please ask questions in the chat or on the forum if you're not sure what I'm talking about or you're not sure what to do. and the mini exam. You'll be spending an hour in your in-person lab.

[00:03:34]You'll be going through um in the exam environment that you'll be using in the final exam. You'll be uh doing four questions depending on how much time you have. Uh but you just have to attempt and submit at least one to get checked off for the lab. And then there's the regular questions uh the regular lab exercises that you'll do for the marks for the lab. So that's just a reminder. Some of you might have already done it today. So I hope if you did it was a really good chance to see the exam environment and to attempt some questions. Okay. So yeah, look into that exam info, ask questions about it if you've got any questions.

[00:04:18]Uh the other reminder is tomorrow there's a revision session. It will be on things like pointers, strings, link lists. You can sign up and get more information on the forum.

[00:04:31]Um so this is just a reminder and of course I was about to say hands up. Well, I hope uh most of you have started the assignment. I hope you've looked at the assignment 2 video which will really help you get started. Um, don't forget if you run into any problems with it. There's plenty of help sessions. And if you go to help sessions now, they're probably not as busy as they might get later um, closer to the deadline. So, now's a really good time to get started.

[00:05:08]Go to help sessions, ask all your questions. You can also ask questions to your tutor and your lab assists in the labs as well.

[00:05:16]If you feel you need additional help on top of that, then that's okay as well.

[00:05:22]You can organize like a 30 minute one-on-one drop-in session with a tutor.

[00:05:27]And to do that, just email the admin cs1511 unsw.edu.au and they will do their best to organize a good time for you to go to something like that.

[00:05:41]All right.

[00:05:43]So, you get started on CS Duck Life.

[00:05:48]That's it for the announcements.

[00:05:50]So, for today's lecture, we're going to do a bit of a recap on deletion and free.

[00:05:58]And we're going to potentially look at extending one of our deletion functions depending on how we're going for time.

[00:06:06]But then we're going to look at an email management system. It's just like a a very simplified one. Um but it's sort of a more real world application where we won't just have standalone integer link lists. We'll have link lists that are fields in other strrus and there'll be more complex data.

[00:06:29]So hopefully this will be helpful because these are the types of things you'll have to think about and work with in assignment two. Okay. So we'll do that. We'll we'll start off with some deletion recap and yeah please ask questions in the chat of course.

[00:06:50]All right.

[00:06:52]So I'm just going to start like recapping the deletion part. So we recapped kind of insertion yesterday.

[00:07:02]Seems weird that it was only yesterday.

[00:07:04]Um anyway, so let's have a look at this deletion situation.

[00:07:10]So we've already done this. I'm just recapping it.

[00:07:15]So imagine we're just doing the simplest case of trying to delete the first node in a link list.

[00:07:22]Now, whenever we write any code for link lists, we've really got to think about, you know, is the code I'm writing or about to write, is that going to work even if we've got an empty link list with no nodes in it?

[00:07:37]But to start with, um, let's assume that we we do have some nodes and we are going to delete something.

[00:07:46]Well, what do we want to do if we're deleting this? Well, if I'm trying to delete this first node, uh, I'm just going to change my pen color.

[00:08:00]If I'm trying to delete the first node, well, the head of the list is going to change. So, if I'm trying to delete the first node, the head of the list should move to here, and this should be the first node in the list. And we're going to want to free the data from this one.

[00:08:17]Okay, so we want to change the head of the list. We want to actually free the the d the the memory we maloclocked, I should say. And we should end up with a link list like this.

[00:08:30]So that's what we're trying to do. Now on the next page, just to really hurt your brain, I've got two sort of chunks of code that attempt to do this for this list.

[00:08:45]So, what are the problems with these solutions? So, there's two solutions here.

[00:08:53]Are either of them good? Do either of them work? Are they both bad? What's going on? I'll give you a moment to think about it.

[00:09:03]And you can write in the chat what you think, whether solution one would work, whether solution two would, whether none of them do, what's wrong.

[00:09:52]Oh, cool. There's a poll.

[00:09:56]Okay, now it looks like Oh, things are changing.

[00:10:23]Okay. Well, not everyone's voted, but so far we've got Actually, I shouldn't say, should I? I'll just be quiet. I'll give you about two more minutes.

[00:11:04]So yeah, we've got a few comments saying exactly what they think is wrong. Okay, so let's go through it. So if you said, yeah, neither are any neither work, that that's the right answer. So what's wrong with this? Um, let's have a look. Well, the first one, and look, both of these look like they're trying to do something, you know, reasonable here. We do want to free the head. So, head's pointing to this chunk of memory, and we want to delete it. Um, so we do want to free that memory.

[00:11:53]That's correct. But unfortunately, if we free it first and then say head equals head next, we're actually reusing this piece of memory that we just freed. I mean, head next is going to come from this field in here and we've already deleted it. We've already freed it. I mean, so once we've freed this head, we can't then go accessing this data inside it, right?

[00:12:22]We're going into something that's been freed. And we talked about that yesterday, how that's actually it's potentially will crash your program.

[00:12:32]Well, it will on dcc, but if you're not using dcc, you're out in the real world, this can create security vulnerabilities.

[00:12:40]So, this one isn't good.

[00:12:45]All right. Hopefully that makes sense.

[00:12:48]Now, the second one, it's doing this first. It's saying, let's move head.

[00:12:54]Head's pointing to here. Let's get it to point to head next. And that's correct in that we do want the head to end up pointing to that node.

[00:13:04]But now we're actually freeing the head.

[00:13:09]And um this is the head now. This is where the head's pointing. So we're freeing this node.

[00:13:20]And then we're returning that node that we've just freed.

[00:13:24]Uh and that's not great either. But we've also just ended up breaking this list into parts and we've lost all these nodes. So, this one, if I had to choose which is worse, maybe this one's even worse than that one. But they both look at first glance fairly reasonable, like maybe they're doing something that's going to work.

[00:13:49]Hopefully, that makes sense as well. I can't see puzzled faces or smiling faces, so it's hard to know.

[00:13:59]All right, what about these two solutions? I'll give you a few minutes to think about this. Do either of these work? Do both of them work?

[00:14:11]I'll tell you after these. I won't give you 50 million solutions. These are the last two.

[00:15:08]Did I just accidentally end the poll?

[00:15:12]I'm sorry if I did. Um, I clicked on something. Maybe I ended it. But what are we saying? I think the the winning vote was solution three.

[00:15:27]Okay, let's have a look. So, solution three, uh, they've worked out, hang on, we can't do this with just one pointer to one node. We need, uh, a pointer, you know, a second pointer.

[00:15:41]So, it's saying temp equals head, and that's good. That's a very good step.

[00:15:47]Then, it's saying, well, we know that we want head to move to the next one. Let's make head equal head next. That's a very good step. And then we're saying let's free temp. Temp is pointing to this node. We don't want it anymore. Oops, that's the wrong one.

[00:16:05]So, let's free it.

[00:16:10]Free the memory here. Um, and that's great. That does work. We return the head. The head is pointing to something that hasn't been freed. That's all great. And we just make sure if temp is still here, we just never use this. We don't go and access that memory that was just freed.

[00:16:31]Uh so that's a good solution that will work.

[00:16:35]Now this solution here is on the right track. I guess temp is pointing to here.

[00:16:44]But now they free temp. Now, when you free temp, you're freeing the memory that temp is pointing to. So, you're still freeing this node um that head's pointing to. So, then when you say head equals head next, you're trying to access this free node and you're going to crash it with a a free after use. Um, so this one's not as obvious that we're using it after free because when we're calling the free, we're using the variable temp, but it was pointing to that same chunk of memory that head was pointing to. So this is not going to go well.

[00:17:31]So this is this is the one.

[00:17:35]All right. Hope again hopefully that made sense. Does anyone if you've got questions, please ask. So just to remind you this is our beautiful picture showing it.

[00:17:45]We have created a pointer to this node.

[00:17:51]We move head then we can free temp. And that's a safe way to delete the first node in a link list.

[00:17:58]Okay. And we looked at that the other day and we ran our code and checked that it that it seemed to work. Okay.

[00:18:08]All right. the other code we looked at.

[00:18:11]Oh, and what I forgot though, gosh, a very important point. Um, when we put this together into a function, so this is deleting the first node in a list and we return the list, the new head of the list. Uh, we have to have a special case for if the list was empty. So, if we have an empty link list, the head will be null. Um, and if we didn't have this code here, we would end up well temp would be null, but we'd end up with this line here where we're trying to say head equals next when head is equal to null. So, if you're ever in a situation where it's going to result in an attempt to do something like this, go and go to null, dreference it, get data out of it.

[00:19:02]That's going to crash and you're going to have a null. I keep saying null pointer exception but dreferencering a null pointer.

[00:19:10]So like a lot of our link list code, we will have a special case for if the link list is empty. So if head's null, we can't be moving pointers around in the list. Um because there's no nodes, we can't be deleting things. We just return null or return the head. It's the same thing in this case.

[00:19:33]All right. So, that was deleting the first node.

[00:19:38]And just to remind us of what we were doing, we had this list C where we were writing this, you know, the implementation of the functions and we had a main function over here.

[00:19:57]Uh, I inserted a few nodes. We tested it out. Okay. The other thing we looked at was basically freeing the whole list. So whenever we are working with a link list, every time we add something to the list, we're doing a maloc.

[00:20:24]Oops.

[00:20:28]Now, if we just keep doing malocs and malocs and malocs, eventually we can run out of memory. Uh, maybe I won't suggest that you try it, but imagine you just had a loop that kept maloclocking lots of memory. You'd run out of memory. Um, and look, sometimes that's because maybe you're really trying to use a lot of memory.

[00:20:50]Like in a game, you might be trying to do something really fancy and really using up all the memory. But often you might be using memory. You could free it and you haven't. And you you've got memory leaks and you're gradually using more and more memory.

[00:21:07]So, what we want to make sure we get used to doing is freeing memory from our linked lists or really anything that we're malocing once we've finished with it. So, if we finished with our list, there's still some nodes in there. We want to go free them all. So, this is what this particular um function is trying to do. And I believe this is the correct one because I did have a incorrect one yesterday to show you. Fingers crossed.

[00:21:39]So yeah, we're trying to basically just go from the first node. So if we run through this with a drawing, which I really recommend you do when you're programming, uh we've got current pointing to head.

[00:21:53]And we want to keep going because we want to free every single node in the list. Now again, we've got to be careful we don't just free current and say current equals current next because then we're using memory after we've freed it.

[00:22:08]Now because we're trying to destroy this whole list, we might as well just keep moving head along because we're just destroying everything as we go. So we're going to say head equals head next, right? Because that's I guess the head of the rest of the list that we haven't freed yet. Then we free current.

[00:22:32]And then we've got to again resist typing in current equals current next because that would be using memory after we freed it. So then we say current equals head. And now we've deleted the first node. We just keep repeating it until currents null. So we've got head equals head next. So head will be moved over to there.

[00:22:58]Uh we free current and we move current.

[00:23:05]I'm changing all my colors to where head is one more time. Head ends up being equal to null. We free current.

[00:23:17]Current equals head. Now it equals null.

[00:23:19]And this whole loop finishes. So this is how we can free up a whole list.

[00:23:26]So you can't just call free on the head and just free the first node. You've got to go through and do it like this.

[00:23:33]All right.

[00:23:36]So when we ran this the other day, I won't call free list.

[00:23:49]When we run it like this, we've added some nodes. We've deleted one, but we we've got memory leaks. Now, unless we were really using a lot of uh memory and doing a lot of malocs, um we're probably not going to realize this without running leak check. So, if I run leak check, I'll see that we did not do all the freeze for all of the malocs. And it tells us, you know, that was line six.

[00:24:21]Line six is, yeah, we mlocked nodes when we created them. We haven't freed them all. So, in your assignment stage three, you've got to start thinking about these sorts of things um with memory leaks.

[00:24:37]So, if we call the function we just wrote that hopefully works and frees any memory that's left in our list.

[00:24:47]And if we um compile it with leak check, we're hoping it doesn't have this thing at the bottom telling us we haven't freed it all, but let's try it.

[00:24:59]Yeah, that that's what you're hoping to see if you're testing things with memory leak checking.

[00:25:06]All right. Any questions about deleting the first node, freeing the list? How are we feeling about it?

[00:25:21]Okay.

[00:25:24]Hm.

[00:25:27]I might I might skip search and delete for now um and come back to it because I want to get started on the link list application.

[00:25:40]Um and when we get up to the deletion part in that, I'll come back to it if that's okay.

[00:25:47]All right. So, here's an email management system. Again, it's very simplified. In fact, our emails don't even have any contents. Um but that's okay. Uh so in this this is a little bit similar to the assignment in that you know we've got a number of these files that we've been given. We've got a bunch of prototypes in ah file. We've got to go and implement them in a C file. We've got some files that have mains in them.

[00:26:17]And you know we've got to work out what on earth is going on and what we have to do.

[00:26:25]And you know like the assignment as well, you can't just launch into coding.

[00:26:29]You've really got to think about what what's the code that I've been given, how does it fit together, what do I have to do, etc. So yeah, before you start coding, and this sounds pretty obvious, but you really need to understand the problem.

[00:26:47]What is the code doing that you've got?

[00:26:51]I've already said this. How does it fit together? How do you compile it and run it? Um, you might want to draw some diagrams if you know you've got some link lists involved. You might want to think about the different test cases, etc. Okay. Now, in this particular problem, uh, I might quit out of here.

[00:27:21]Oh, don't worry about what I'm doing right now.

[00:27:45]Okay. So yeah, we've got these four files. So I'm just going to open them up.

[00:27:54]We've got our email management system.h file.

[00:27:58]Uh it's got hash define.

[00:28:01]It's defined a few enums um which you would be familiar with enums. There's different types of emails, different priorities, but the main thing is that we've got some strcts that I'll go through in more detail. a strct for an email folder and a strct for an email.

[00:28:21]Uh, and then we've got all these prototypes for different functions. So, that's what's in our.h file.

[00:28:30]Then over in our C file, this is well, it's hash including theh file. Um, but this is where we've got a whole bunch of stub code or, you know, code that really hasn't been implemented for all of these different functions and they're all just printing out that we haven't done them yet and then exiting.

[00:28:56]We're going to go and implement these.

[00:28:58]We may not finish them all in this lecture, but we'll see how we go.

[00:29:04]Um, and then we've got a file that we can use to test it.

[00:29:12]All right.

[00:29:15]Now, let's just talk about the the strrus that we've got here. So, in this email system, these are the two important strus. Now, we're not calling things strruct node. We're not calling things, you know, strct node star head. So if we're looking at these strrus, do we see anything that might be the equivalent of a node? And do we see anything that might be the equivalent of like the head of a link list?

[00:29:51]How do we work out where our link lists even are in these strcts?

[00:30:02]or where they potentially are.

[00:30:24]Now, obviously in an assignment, you'd have um more instructions that I've given you so far and some text explaining things, but yeah. So, we've got some good answers in the chat. So, I guess this keyword next might give things away a little bit. Um, so our strruct email has a pointer to another strruct email.

[00:31:00]So, the key is if we've got like to have a link list node, it has to have a pointer to another strct of the same type. And the fact we've called it next makes it a little bit easier to work out. Okay, these are our nodes. So, we're going to be having link lists of emails in this.

[00:31:24]Now, in our emails or in our nodes, we don't just have an int for our data.

[00:31:29]We've got a whole bunch of different data. some strings like sender, subject, size, email type, email priority, everything but the actual email contents, it would seem.

[00:31:42]Uh, but that would be easy to put in later.

[00:31:46]All right, the strruct folder. Well, this couldn't be a link list. There's no pointer to a strruct folder inside it, but this is basically like a container and emails is basically like the head of the link list.

[00:32:04]So this is like the head of the link list and it's pointing to a link list of emails.

[00:32:12]Does that make sense? So instead of just having a standalone linked list, we've got a folder and that has one of the fields in the folder is a link list and this is the head of it. Now we need to understand that if we're going to be able to program with this and not just be kind of guessing and triing and erroring, which we don't want to do.

[00:32:37]Any questions about that?

[00:32:44]Now, having all this extra stuff uh can make it a little bit more confusing, but all the underlying link list logic is really going to be the same as what you've seen when we did just have the list of integers.

[00:32:59]All right, so let's keep going.

[00:33:06]Now again, like here's some diagrams to help us understand what's going on.

[00:33:13]And I forgot I always forget there's no numbum emails. Just ignore this drawing. I've commented out that field in here. So our folder, our strruct folder will have a name and this uh head of an email list. Right? These are the two fields or members it has.

[00:33:39]Uh and if we create an empty folder, an empty folder will start off having no emails in it. And you know it'll look something like this. We'll initialize the head of the email list to be null and gradually we'll add emails to it.

[00:33:58]So this is what it might look like if we had three emails in our link list.

[00:34:04]Again, pretend that's not happening. So, these are of typestruct email. This is of typestruct folder. These are all the same types. They're all linked together.

[00:34:15]This is a different type.

[00:34:20]All right. Any questions about how this fits together.

[00:34:28]Uh we can also have more than one folder. And to start with, these folders are just independent folders. So you can have one folder that has a list of emails in it and another folder that has a different list of emails in it. Um, we'll we'll look at that later. Um, and the other thing is we'll start with this test main. Test main just has some code in it to help us run um, and test some of our functions.

[00:35:01]Okay, if we got all those functions working, we could then try and run this other main which sort of lets you add and delete emails. But we're going to start with this test main just to check, can I make a folder? Can I add an email to this email list, etc. So, if I go here, how do I compile this?

[00:35:27]Well, I'm going to work with test main.

[00:35:30]So, I've got to use that code. I've also got to compile the code from my email management system that has all the different functions in it.

[00:35:41]Now, if I do that and I try and run it, it's not going to do much now because test main tries to create a folder and my create folder function just prints out something. It exits the whole program.

[00:35:57]So the first thing we're going to do is actually implement create folder.

[00:36:02]I'll just move this across a bit.

[00:36:08]All right. So all we're trying to do really is, you know, create a folder that's a bit like this.

[00:36:23]So, what's the first step going to be when I want to create my folder?

[00:36:33]Can I just do something like this and then set the data inside it and then try and return that at the end?

[00:36:56]Oh, someone's asking does exit instantly like finish the program. Yes. So, you can call exit from any function in your program and it'll just yeah, exit the whole program. I'm not sure whether you're advised to be doing that in your code all the time, but we've just done it. I've just done it for this.

[00:37:18]Uh, yes. So, is this a good idea or a bad idea if it's on the stack?

[00:37:33]And where where might we want it instead?

[00:37:43]Yeah. So if we put this if we have a local variable like this on the stack and we try to return it one it's not going to compile but even if we return the address of it this will be destroyed when the function finishes. So we're really going to have to maloclock our folder and return a pointer to it which shouldn't really be a surprise.

[00:38:11]So we're going to maloclock our folder.

[00:38:13]We want a chunk of memory big enough I can't type for a strruct folder.

[00:38:22]Okay. Uh so now I've created just this chunk of memory for new folder.

[00:38:31]It's beautiful. Looks beautiful. Now in it I might want to go and refer back to myh file to remind myself of what all the fields are. So this one's been commented out. We just have to make sure we set and initialize all the fields in this strct. So when you know whatever part of the code calls this function, it's going to give it a name. So maybe the name is travel or whatever, we've got to go and put that name inside this strct.

[00:39:09]Oh, I just wrote yes, thank you. I left out the size of Thank you very much. And I didn't even notice. Um, yes, we've got to find out the size of the strct.

[00:39:28]Okay, it's good. I've It's good. I've got people helping me. Um, now we want to set data inside this strct we've just made and it's called folder.

[00:39:42]Now the field we're trying to initialize is the name. We've got to make sure we're setting the data for the name because we've got a pointer. We use this uh stab notation.

[00:39:54]So we're trying to set this name field that's inside our strct to be the name that we were passed in. So if if you know we travel was passed in we're trying to put this in the strct.

[00:40:11]Now, what's wrong with doing this?

[00:40:26]What's wrong with saying new folder arrow name equals name?

[00:40:30]And it's got nothing to do with link lists.

[00:40:52]Yeah, it's a string. So, this field's a string.

[00:40:57]Strings are really arrays. You can't just say this array equals this array.

[00:41:01]You either have to write a loop or you have to write use stir copy. Yeah, exactly. People screaming in the chat saying string copy.

[00:41:14]Okay, so we copy this in. So, it's going to have the name of it, you know, and let's pretend it said travel, not that you can read my writing.

[00:41:25]And then the other field we have to worry about is emails. So, we don't want to forget about it just because there's no um argument setting it to something.

[00:41:35]If we've got a link list, we often initialize it or we usually initialize it to be null.

[00:41:45]So this is like saying the head is null.

[00:41:48]It's just that the head of the list is buried in this strct. Then at the end we return the new folder.

[00:41:56]Okay. Now, if we've done this correctly, um first of all, it should compile if we've done it correctly.

[00:42:08]Second of all, when we run it, we should get the right output. What's the right output going to be?

[00:42:16]We don't I haven't set up wonderful auto tests like you have in the assignment where it tells you whether it works or not. We're gonna have to look at the output and work out, okay, so is this what we were supposed to get or not? So, we're trying to create a folder called folder one. We're printing out how many emails are inside it. There's already code written that can go and count how many emails are in our folders for us.

[00:42:40]We've already done that. Um, and then it's going to go ahead and print the emails. Again, there's provided code that can print all the emails.

[00:42:49]So given that our folder is empty right now, it should really tell us there's no emails in this folder.

[00:43:01]Okay, so printing.

[00:43:16]Oops.

[00:43:18]This looks weird. Folder one.

[00:43:22]Yeah, print. I can't even see what's happening. Ah, here we go. I didn't scroll up high enough. Creating folder one. Well, that's just a print. Anyway, number of emails in the empty folder.

[00:43:34]Zero.

[00:43:36]Printing empty folder one. The folder one names been set. There's no emails in this folder. Okay, it seems to work. Um, the next thing we're going to do is we're actually going to try and add some emails to this. So, we're inserting the emails at the head of the list. So, we're given the sender subject size type priority. We've got to actually create an email node.

[00:44:06]We want it to end up at the beginning.

[00:44:08]So, we're going to have to connect this new node to the first node in the list.

[00:44:17]And then we're going to have to make sure we update this uh which is showing us the first node in the list. It's going to be this new node we've just inserted. Okay. So, we're just adding it to the front of the list.

[00:44:38]um adding this to the back of the list, the front of the list. Um yeah, it it and this is really the same logic you would have used with your integer link list, but we've just got all these other things now to think about.

[00:44:53]So let's go and try and do that.

[00:44:58]Now the first thing I probably want to do is actually create another function called create email maybe. So I might um that does the maloc a bit like create node. So, unfortunately, this is the tedious part when you've got sort of more real world like data.

[00:45:31]Instead of just having to worry about an int, uh, we've got all of these different inputs that we're storing.

[00:45:40]Okay.

[00:45:51]and then gets too wide.

[00:45:58]All right. So I'm going to do strct email new email and again I'm going to maloc this. This is like a node. I'm going to remember size of this time.

[00:46:13]Now when we do a maloc, I think I can see discussion about how much space do we have on the heap. Yeah, in this course we will assume that we won't run out of anything on the heap. Um unless we've made a mistake.

[00:46:28]We're not doing anything that uses that much memory. But theoretically, Maloc could return null to say, "No, I can't give you that much memory." And generally in real life, you want to check for that. I'm not going to check for it in this example. I'm not sure whether you need to check for that in the assignment, but you should always make sure you're reading instructions and understanding whether you need to check for it or not in a course like this.

[00:46:57]All right. So, I'm creating my new email. Again, I've done my maloc for my email, but now I've got the tedious thing of copying all these fields into it.

[00:47:10]And again, I'm dealing with strings. So when I say new email, okay, new email. Uh let's go to this sender.

[00:47:34]I I can't just say sender. I've got to use string copy.

[00:47:44]Let me know if I'm doing anything wrong.

[00:47:47]I've also got to use string copy for the subject.

[00:47:57]I've also Oh, no. That's it.

[00:48:03]The next piece of data I'm copying into this node is the size and it is a double. Oh, writing double.

[00:48:13]So I can just use equals the enums. So I can just use equals and then I return this new email.

[00:48:41]Okay.

[00:48:42]Again, this isn't going to do anything because I haven't used this function yet, but I'm just checking I don't have typos.

[00:48:51]So, I've got something that can create one of these email nodes.

[00:48:56]So, I'm going to actually use it down here.

[00:49:12]Oh, now I've got to type all this in again. Might have been easier not to do it.

[00:49:19]Now, it's good to have a create node function type priority.

[00:49:34]Hm. What would you say about my style here?

[00:49:41]I'm going over the line like this line. I don't know if you've got it set up in your editors as well. This is telling me these lines of code are too wide.

[00:50:01]Yeah, I might leave that for now. Um, so 1511 style and your tutor might complain. All right, once I do this, I actually want to connect it to the list. So, imagine I've got my email folder.

[00:50:25]It's got a list to some emails. Maybe there's some emails in there already.

[00:50:29]Maybe there's not.

[00:50:31]I've created this new email.

[00:50:35]This is my new email.

[00:50:38]I need to link it up. So, the first thing I want to do is create this link here that joins it up before the first email we already have.

[00:50:53]So, to do that, I'm going to take my new email and I'm basically trying to say, well, the next one after this is the one that's the head of the list. Now, we don't have anything called head. We've got our email folder and inside there we've got our field called emails.

[00:51:16]So this field here is called emails.

[00:51:21]So if we say new email next equals email folder emails, it's going to connect this up, I think.

[00:51:40]Then what do we have to do?

[00:51:43]Well, we've got to make sure our folder.

[00:51:55]Sorry, I'm getting distracted by the chat. Um, we've got to make sure our folder knows which is the first email, right? So, right now our folder thinks the one that's now the second email is the first email. We've got to fix that.

[00:52:07]We've got to say email folder emails.

[00:52:14]Well, the first email in this email list is this new email.

[00:52:24]Okay. So now that is being updated like this.

[00:52:29]So I think this will work. Now a quick question before we go for a break. I mean should I be returning the new head of this list?

[00:52:43]If not, why not?

[00:52:51]So often if I'm changing the first node in the list or I'm basically in all of our insert and delete functions that we did with link list of integers, we returned the new head of the list. Do I have to do that now? No, that's right.

[00:53:13]Well, yeah, the return type is void, so we can't. But is that wrong? Should I have changed it to return the head of this email list?

[00:53:21]Yeah, that's right. We don't need to.

[00:53:24]It's stored um we've actually stored it in this folder.

[00:53:30]So if we've changed the head of the list, this strct folder has that information already. So it's already taken care of. We don't need to return it. Yeah, that's right. All right, let's try and make this or compile it. Does it work?

[00:53:49]It seems to. Is it going to work if there's nothing in the email list already? Let's just quickly think through that.

[00:54:00]Well, if there's nothing in the email list, emails will be null.

[00:54:06]Our new node will say email next equals email folder emails.

[00:54:14]It'll also be pointing to null. That's okay. So, If the list is empty, this will be null, but we're assigning it to something.

[00:54:24]That's okay.

[00:54:26]Um, then we're updating this to point to here. I think it it should be all good.

[00:54:33]All right, let's quickly run it, then go for a break. So, in my test again, we're in a situation where we might have to think about what should be in our list.

[00:54:48]And when it gets printed out, check whether that is what we're looking for.

[00:54:53]So into our folder, we're inserting 1 2 3 4 five emails.

[00:55:01]We know we're inserting them all at the head of the folder, folder one. So, we would expecting we'd be expecting the first thing in the folder to be Sophia's email, then Tammy's, then Brianna's, then Tim, then John's. So, we'll have a quick look.

[00:55:27]Yep, we've got Sofia and and Tammy, Brianna, Tim, and John. And there's five. So, that looks all good.

[00:55:48]Now, we're going to have about I don't know, we'll come back at about 5.

[00:55:55]So, when we come back, we'll do we'll search for an email and then we'll start trying to do some trickier stuff with deletion of emails and stuff like that.

[00:56:05]So, let's come back at about 5 and we're going to continue with this and we might do a cahoot. We'll do a poll uh as to whether we do a cahoot about halfway Sorry.

[01:03:05]Okay, we're just about to come back. Yeah, sorry I didn't explain why there was suddenly a cat on the screen. Um, hey, I do like cats and I thought it was cute.

[01:03:15]But yeah, that's my thing for a break. I probably should have explained that first.

[01:03:20]Uh so let's get back to it. Um is there any way we can do a quick poll to see if people are understanding how to work with these strcts? Like are they getting confused about having a folder and then having the strruct emails or are people sort of okay on that?

[01:03:54]Okay, while that's that's happening.

[01:04:59]Okay. Right. There's only 12 votes. Um 14 votes. Most people are yes or somewhat. Okay. Um All right. The next one that we're doing is I'll try and just to make sure we I solidify what's going on when I explain explain the next one. So the next one what we're doing is we're searching for a particular subject. So you know this is like the subject when you send an email.

[01:05:31]Um it might be I don't know meeting piano lesson I don't know what it might be. Now to make them easy our subjects are just all like a a bbb ccc but again what we're doing is we're just looking through a folder for a particular subject or particular subjects. So if we're looking for any email that has BBB as the entire subject, we're not just going to do a partial search or anything like that. If there's a entire subject in an email called BBB, we're finding it. So really, we're just doing a search, but the search that we're the the data we're searching on is the subject field. So if we're doing a search, all we're really doing is a traversal.

[01:06:34]So I think yeah, I think we can end it.

[01:06:36]I might end that. Thank you.

[01:06:39]Oh, there's a few not at alls. Okay.

[01:06:51]Okay.

[01:06:52]So I'll just I'll just go through it again. So we've got um we've got two different kinds of strcts. We've got a strct for a folder and ignore this field here. Every folder has a name uh like you know travel or folder one or whatever we've called it. And every folder has a linked list field. So this field called email is really like the head of a link list but it's in this sort of strruct.

[01:07:30]Um then the actual link list itself are these strruct emails. So these strruct emails are like nodes and instead of just storing an int node, we've got all of this data.

[01:07:47]So there's lots and bits and pieces of data, senders, subject, size, etc. But that's all the data and they've all got a connection to another node. So these are just like nodes. This emails field inside this other strct is like the head of the link list.

[01:08:05]So it's buried inside this folder. So often in our code in link list, we might say head equals null or something like that. Well, we'll have some kind of folder. So imagine this folder is called folder. We would be saying folder arrow cuz we need this field which is called emails equals null. That would be the way we would do it in this circumstance.

[01:08:34]So where you'd usually see head is equal to null is initializing the link list to have nothing in it. In this scenario, we would be saying folder arrow emails and making that equal to null. For example, now what we're trying to do here is we're trying to basically do a traversal.

[01:08:56]And we've seen traversals before. We often make current point to the first note in the list and we just keep going, you know, maybe until we reach the end.

[01:09:08]In this case, if we're searching for something, we're going to stop if we find it. So, imagine we're searching for the subject BBB.

[01:09:20]Uh, we want to start looking from the first node. We're going to look at the subject. Is this BBB?

[01:09:30]And imagine the subject here is AAA. No.

[01:09:33]So, we go to the next one. And to do that, we'd say current equals current.

[01:09:38]Next, just like we would in any link list. Uh, then we check, is this the subject we're looking for?

[01:09:46]Imagine we're looking Oh, this is just like a like a subject in an email. So when you send an email to somebody, you might your subject might be um party on the weekend or surfing or I don't know what people write in their emails.

[01:10:07]Um so maybe I'll use realistic ones. So imagine we're looking for the subject holiday or not holiday subject I don't know uh golf this subject is babysitting.

[01:10:32]This subject is piano.

[01:10:35]Right? These are email subjects. So imagine you're looking for all of the emails that have the subject golf.

[01:10:43]So we want to set current to the first email and we're going to check. Is this one about golf? No, it's about babysitting. We move to the next one. Is this one about golf? Yes, it is. So we're going to stop traversing and we're going to return and say yes, we found the email about golf or whatever it is.

[01:11:04]We might get to the end. We might be looking for an email about surfing. We get to the end of the list. It's null.

[01:11:11]There was no emails with a subject surfing in it. Okay. So, we're just doing a search.

[01:11:18]All right.

[01:11:22]So, when we go down here to our code, but in ours, I wasn't very um imaginative. instead of having surfing and piano and golf, my uh subjects were a a bb ccc d e. So I apologize for that.

[01:11:40]Uh but we're going to go and write our search function.

[01:11:46]Okay.

[01:11:49]So, keep in mind we've got our email folder that possibly has a bunch of emails in it.

[01:12:09]Okay? And that's what we're searching through.

[01:12:17]So the first thing we want to do is basically yeah make a pointer to the first node in the list.

[01:12:27]And to do that in this scenario our nodes are called strruct email and we're looking for the first node or the first email I should say in this particular folder.

[01:12:45]So in this particular folder that we're given, there's going to be an emails list and this is going to give us the head of it. And we're going to make current point to the head.

[01:13:13]And that's how we're doing it in this scenario because this emails is the head of the list. It's inside this email folder.

[01:13:29]Okay. So now we're just going to do a traversal. Now reg usually a traversal we just start at the beginning and we go right to the end.

[01:13:49]Okay. So we're going to be checking every single node until we get to null potentially.

[01:13:56]But for every node, we're just checking well in this current node that I'm looking at.

[01:14:03]If I go to the subject field, so remember every single email has a sender and it has a subject.

[01:14:21]So in this example, we're looking inside that node to see what subject uh was in the email and we're just searching for the one that uh has been given to this particular function to find. All right. So basically we're checking gosh there's planes and sirens everywhere and stuff over here where I am. We're trying to check whether the subject in the current email in the current node that we're pointing to is equal to the subject we're looking for. Now again, what's wrong with this? If we remember that our subjects are strings, how do we compare two strings?

[01:15:37]Yes, string compare. So, we've got to use string compare.

[01:15:42]We can't just use equals equals. And we're going to have to make sure that we know what string compare returns. String compare returns zero if the strings are equal because there's no differences. So if we get to a particular node and it matches the subject we're looking for, we we found it and we're going to stop and we're going to return it. We're just going to return the first one that we find.

[01:16:12]So I would return that whole node and by returning that whole node the code that's using it can go and access all the other fields. They'll know oh I was looking for that uh email about golf.

[01:16:26]I found it and it was sent by Sofia and it was this size and that size etc. Now, if we haven't found it yet, we have to keep going. And we do our old favorite current equals current next.

[01:16:48]Oops.

[01:16:55]To move our pointer along.

[01:16:59]So, current will move to the next node.

[01:17:04]And oh, I've just destroyed something.

[01:17:14]At the end, if we haven't found it, we'll just return null to indicate no, we never found any node with that particular email subject in it. Okay, so eventually if current gets to the end, we know we didn't find it. We return null.

[01:17:35]Yeah, instead of putting the if statement inside the while loop, we could have it as part of the actual condition. So I could say we want to keep searching while current is not equal to null and while this while string compared does not return zero. So while we haven't reached the end and while we haven't found the one we're looking for, keep looking. Keep looking. When we get to the end, we just return current. Now either current will have stopped because it found the particular email it was looking for and you'll return it or current found nothing and will be null.

[01:18:26]So either way it'll return the right thing. So this is another way you could do it. Um yeah, exactly. Either way is fine. It depends how your brain works and how many conditions you like for your brain. Anyway, either is fine.

[01:18:46]Okay. Now, what wouldn't be fine? Yeah, we definitely need to use string compare for strings.

[01:18:56]What wouldn't be fine is if we only went to current next.

[01:19:05]What would happen if we had this in our loop instead?

[01:19:08]If we had current condition while current next is not equal to null, what would this not work for?

[01:19:54]So yeah, if we're traversing and we stop when current next is equal to null, that means we're stopping when when we get to the last one.

[01:20:05]Yeah. And that means we wouldn't actually go in and check the last one.

[01:20:10]So, if we were searching for party and the last one had party, well, we would stop before we actually went um and checked it. We'd be stopping and stopping the loop right there. As soon as we got there, we wouldn't even get to this line to check if um actually that would still work, but it would always return the last node. Yeah, it's it's going to break.

[01:20:36]So, we want to make sure we Yeah, this time we want to go right to the end. We want to check inside that node to know whether it matched or not and keep going if it didn't.

[01:20:50]All right.

[01:20:56]Now, there's a bunch of tests for that.

[01:20:58]I'm just going to assume that that search worked, which might come back and um cause problems, but we'll see cuz I want to get on to the next part where we're deleting stuff and clearing stuff.

[01:21:10]So, let's just do clear folders. Now, we looked at this today already. Um, okay. We looked at the code that we wrote to clear just a link list. Sorry for my scrolling. Ah, free list. So, this was just freeing a regular list of integers. Could we use this code to free our list of emails?

[01:21:57]And if so, how would we use it?

[01:22:03]I'm actually going to copy it over.

[01:22:11]So, we already kind of looked at this today.

[01:22:18]I'm just going to shove it in here. This is not a good idea.

[01:22:22]If you create your own helper functions, make sure you place them somewhere appropriate. Um, I'm just wanting to have it all on the the same screen.

[01:22:39]Okay. So we know that this can take a list and free it all. In our application, we don't have nodes. We've got emails instead of nodes.

[01:22:56]But other than that, if I passed in, so if I had a folder and I passed in like the head of this link list of emails, would this code be able to go through and free them all for me.

[01:23:34]So, I've got my email folder.

[01:23:39]We know it's got a field called emails.

[01:23:46]And I want to free all of the memory associated with those emails.

[01:23:53]Could I just call free list like this and say okay I've got my email folder and emails gives me the head and then that free list is just going to free all of these emails for me. Is this going to work?

[01:24:29]Let's try it.

[01:24:36]It should potentially work unless I've done the wrong like, you know, made typos. Do do a million things. Now, how am I even going to know if I haven't compiled it correctly? Let's do leak check.

[01:24:55]And just to show you what's happening in the test code, we've created just so we know what's happening. Uh we've created one folder.

[01:25:08]I'm going to get it rid of this for now with a bunch of emails in it. We've printed them out. We've gone and searched. So, we should be able to find the email with a aaa ddd e. We shouldn't find one with holiday.

[01:25:26]Then we're making a second folder and inserting a bunch of emails into that and printing them out. And then we're trying to free it. So, basically at the end we're trying to free folder one and folder two. And honestly, between them all, there should be I don't know, quite a few emails. So, we'll soon find out whether this freed things properly or not.

[01:25:59]Oh, it doesn't look like it did.

[01:26:02]So, what's it complaining about though?

[01:26:04]It says actually the things that it looks like it is complaining about the fact we didn't clear the folder.

[01:26:14]So or free the folder. So on line 32 when we wrote this create folder we did a meal.

[01:26:23]I've gone and I've tried to free all the emails but I haven't freed the actual folder. So that's all a bit messy.

[01:26:38]So So I've freed freed the emails I hope but I haven't freed this folder. I should do that next.

[01:26:45]So in clear folder I go call my free list function and then I say okay let's actually free the folder itself because that too is a strct that was maloclocked.

[01:27:00]Okay.

[01:27:02]And of course, we don't want to free the folder first and then try and traverse the list that you know was inside it. That's going to cause problems.

[01:27:16]Generally speaking, you you free the inner contents of things and then the containers afterwards.

[01:27:24]So hopefully this will free our folder and hopefully all of the emails are freed as well.

[01:27:35]Okay, so it looks like this freed everything properly.

[01:27:40]Um, so a lot of the code that we've already written for integers will really directly apply. We've just got to, you know, change it slightly to to fit in in this scenario.

[01:27:54]Okay. Does anyone have any questions?

[01:27:59]And maybe let's do a poll to see if we want to do the next function in this or do a cahoot.

[01:28:15]The next function in this is to search for and delete emails of a particular priority or we can do a cahoot.

[01:29:25]Okay.

[01:29:32]Okay. We've only got 11 votes, but right now the next function is winning over the Cahoot.

[01:29:39]So, I'm going to go with that.

[01:29:42]Yeah, it's still winning.

[01:29:45]All right. So, let's get on to the next function.

[01:29:51]Yeah.

[01:29:53]Okay. I'm going to end it and just do the next function.

[01:29:57]All right. So, the next function is um delete email of priority. Now, this one's tough. Now, we did something like this before, so let me scroll. Shut your eyes if you don't like watching a lot of scrolling and it's safe to open your eyes now.

[01:30:22]Now, we did something like this yesterday. We were searching for integers in our integer link list and we looked at all these cases. If we're searching for something in a list, we may not find it because it might not be in the list. The list might be empty. So that might be why we not might not find it. We could find it at the beginning.

[01:30:45]We could find it in the middle. We could find it at the end.

[01:30:51]Um, and we're deleting it. So all of these cases are really going to need to make sure they're handled properly. And the thing that we didn't look at was what if there are multiple occurrences we want to delete. So we're going to look at that today.

[01:31:06]So, just to remind you of the way I did it. I showed you a different approach, but I didn't code it up. Um, so we use this previous pointer.

[01:31:25]Yeah. And somebody's suggesting we just build on what we've got and make sure we keep iterating and move the pointers on to the next one. So, that's what we're going to do. We're going to modify what we did yesterday. Um, and just make sure we're not breaking anything as we do it.

[01:31:40]So, the way we did it yesterday, we had this previous pointer and the current pointer because to delete something, we need to make sure we've got a pointer to the previous node. So, the previous always starts at null. And I was saying the other day, you know, the previous node is kind of creeping up behind current who's running away from it. I mean, not really, but that's what I think of. And we're going to keep going. We're searching for 42 in this example. And in this example, we just were searching and deleting one thing, but I'll still explain it. Um, so we're checking is the current node null? No. Is it equal to 42? Cuz imagine we're searching for 42 in this example. No. So we move along.

[01:32:27]And to move along, we're going to move previous to where current is. And then we're going to move current along. Then we do it again. Is current equal to null? No. Is current equal to the one we're looking for? No. Let's move previous along. Let's move current along. So, is current equal to null? No.

[01:32:48]Is current equal to the one we're looking for? Yes. So, we've now found the one that we want to delete.

[01:32:56]And then what we then worked out that we needed to do was connect previous to the one after current.

[01:33:10]And to do that, we said, okay, well, previous should equal current next.

[01:33:17]All right. And that connects it up. Then basically, we were trying to free this.

[01:33:23]So we just call free on current. We're not using current anymore, so that's all fine. And basically, we've deleted it.

[01:33:31]And really, we could just keep going because we were only trying to delete one thing. But now, we've got to make sure we change things up a bit. Um, and we keep going in case we're looking for more things.

[01:33:44]So, first of all, we're definitely going to have to change our loop.

[01:33:50]We don't want to stop when we find the value. we're going to have to have an if statement to check if we found the value because we might we're going to maybe find multiple values that we're going to delete. So, we'll have to change that up.

[01:34:07]Um, and we've got to think about what we're going to do. Like, we can't keep saying previous current equals current next and all that sort of stuff if we've just deleted current.

[01:34:20]So yeah, imagine our loop is just current is just going to keep going till it gets to null. Now as we go along, we find one we want to delete. We're still going to say previous next equals current next and hook it up like this. We're still going to free current.

[01:34:43]But now we have to keep going.

[01:34:46]If we want to keep going and keep searching, what do we want to do with previous?

[01:34:55]If we've deleted this node here, what do we want to do with previous? And what do we want to do with current? If we say current equals current next, we'll be using this memory after we've freed it.

[01:35:21]So, what would we have to do? Cuz we probably want to move current along to here so we can keep searching. How do we do that? Yeah, we've got to say current equals previous next. We've put this link in. We say current equals previous next. And we just leave previous where it is.

[01:35:43]And then we can keep going. Current equals previous next. We keep going. And look, we need to delete it again.

[01:35:49]Oh, but we would do the same thing. We would say previous next equals current next.

[01:35:57]We would delete or free current. And then we'd say current equals previous next again, etc. Okay, so this is the kind of thing we have to do. So before we try and implement it in the email thing, which is a little bit more confusing, maybe we'll just try to extend this version in our integer version right now if that's all right with everyone. Um, and just check that first.

[01:36:30]So I'll just get rid of this for now.

[01:36:40]So, this was our search and delete.

[01:36:48]We're going to try and modify it like we just saw to search and delete all.

[01:36:57]Okay. So yeah, we don't want to have this as part of our condition because we need to get all the way through the whole list and check every value cuz we might need to delete lots of things. So this is going to have to be an if statement. We're going to have to check it in here and say basically if this is the value we're looking for, then we've got to do something to delete it.

[01:37:30]Otherwise, if it's not, then we just move on as normal.

[01:37:48]Okay, so we're traversing through. If this is a value we need to delete, delete it. Otherwise, just move preven current along.

[01:37:57]So, how do we delete it? Well, we already had code that we'd thought through that we put down here.

[01:38:05]Um, and in this case, we had to check before we did it that we hadn't finished the loop and found nothing. So, we had to check whether current was null or not before we deleted it.

[01:38:20]If we're doing this inside the loop, we don't have to do that check for whether current's null.

[01:38:26]cuz inside the loop current can't be null. So we can basically steal the code we already wrote and just put it inside this loop.

[01:38:40]And this is the code that deletes stuff.

[01:38:43]Now this is the main case that we just looked at in the slide where where we've got pre pointing to some node. We've got current pointing to the one we want to delete and we're saying let's make previous next equal current next. So we've done that step and we're saying let's free current.

[01:39:37]And then in the slide when we're thinking about it, we decided that after that we say well current equals previous next.

[01:39:51]And that's going to move current along to here.

[01:39:55]And then we just keep going through the loop.

[01:39:59]So that's what we'd worked out for that situation.

[01:40:03]Now, what on earth was this thing about?

[01:40:09]When would we ever be trying to delete a node and previous is null?

[01:40:25]When would that case be? We found a null a node to delete. Previous is null.

[01:40:31]Yeah. So we've got we had a special case for if we were deleting the first node.

[01:40:37]So if we were trying to delete 42 pre would be equal to null.

[01:40:58]And what we did before uh when we were just going to delete one thing, we just said okay well we don't want to say previous next equals anything cuz previous is null. It's the first node so we need to move head along. This is like deleting the first node. We say head equals head next.

[01:41:19]And then we do our free So, we freed this, but now we need to keep going.

[01:41:34]So, what are we going to do? We can't say current equals current next. We can't say current equals pre next cuz pre's null. Where's current going to go?

[01:41:46]Well, we just need to move current to where head is. That's going to be the next note in the list because we just deleted the first one.

[01:41:57]So we can say current equals head and we're back to the situation where we're looking through the list and we're at the first node and pre is still null.

[01:42:10]So does that look right? If pres null we move headto head next free current and now current is going to keep going from the new head onwards.

[01:42:22]If we did this again um cuz we'd go through the loop again we would have the same situation. We would say previous null head equals head next we'd be freeing car and we'd be saying current equals head and pre wouldn't have done anything.

[01:42:48]Why wouldn't it be current equals head next? Because we've already moved the head along. So imagine we're trying to delete this node and it's the first node.

[01:43:00]We're saying head equals head next. So we're actually moving the head to this node here.

[01:43:11]Then we're freeing this node.

[01:43:14]So we want current to continue. It hasn't checked this node. Oops. To see what's in it. We want it to continue from where the head is now.

[01:43:25]Okay. So yeah, the problem was I'll just go back again. I'll go back again to when we've got Yeah, this is better. So the first thing we do is preview is null. We can't say current. We can't use pre at all. But when we delete this, we want the new head of the list to be this second node. So we've changed head. It's pointing here. Then we free current.

[01:43:54]But now we want current to keep going from here on in. And that's now called head.

[01:44:00]Yeah.

[01:44:02]To not skip a node cuz yeah, we might want to delete that. We're just going to keep going from there. So it's really I don't know how people would write this kind of code without drawing it. And even though I'm a terrible terrible drawer and I'm very messy. Sorry everyone. That's the thing I think that helps me work this stuff out. Having said that, let's see if it actually works. Right now, have I forgotten anything?

[01:44:28]I haven't purposely forgotten anything.

[01:44:31]So, if it doesn't work, it's just cuz I've made a mistake. Um, and we'll have to try and fix it. I say we you'll have to help me. Now, this is what I've been doing a lot lately.

[01:44:47]not saving my files.

[01:44:50]Okay. And I've gone for gold. I'm not even in the right directory.

[01:45:02]Okay.

[01:45:06]Split. Right.

[01:45:09]Okay. Okay, so I've got my main um and now the most diabolical case to test this would be just having a whole list with everything have the same value in it and try and delete it. But I won't do the diabolical case first. Let's just add everything.

[01:45:32]I'm just going to get rid of some of this extra stuff. Let's just add everything twice.

[01:45:52]And instead of calling search and delete, I'll call search and delete all. Is that what I called it?

[01:46:11]All right, let me scroll down and find it.

[01:46:19]And yeah, this code is starting to get quite tricky, these functions.

[01:46:25]Uh, delete main.

[01:46:34]Well, let's just see if it works and then we'll do the leak check on it.

[01:46:39]Well, it have I just destroyed the whole list somehow.

[01:47:30]Okay. All right.

[01:47:33]So, it looks like something's gone wrong.

[01:47:36]Terribly wrong.

[01:47:41]So, I might get rid of some of these tests to find out where it is.

[01:48:16]Oh, that was control D where I kept selecting the code. Now, what have I done wrong? I really don't know.

[01:48:25]So, just the main case didn't work.

[01:48:30]So, I tried to delete one and I wrecked everything.

[01:48:36]Oh, does anyone know what it is? Yes.

[01:48:42]I copied the condition from the while loop and it should be the opposite condition. So, that's why it was destroying everything in the whole list.

[01:48:51]So, it wasn't even the tricky part. It was like, well, we don't know. There could be more wrong with it. But whoever found that, that was good. I was just looking at the same thing. Um, okay. So, we've deleted all of the ones. So, we've got this list. We've deleted all of the ones.

[01:49:11]That looks okay. Let's test it more carefully.

[01:49:19]Um, what about if we're trying to find something and it's not in there?

[01:49:30]Yep, that works fine.

[01:49:34]What if we're trying to delete all the threes, which should be the first node and also, you know, repeated.

[01:49:46]That works.

[01:49:48]Um, if you've got bugs, always work from the first case, like one case at a time that you know has failed. It's too overwhelming to see all the cases that have failed. Just look at the first one that's failed and try and work out why that failed. All right, we've deleted all of the zeros.

[01:50:18]We should end up with just a list that has four in it because at the beginning we did just a normal delete of four. It didn't delete all the copies.

[01:50:29]All right. So, that seems to have worked.

[01:50:33]Let's just check.

[01:50:36]Oh, well, the time's nearly up.

[01:50:43]if it worked from with with leaks. It seems to have worked with leaks. Now, we don't have much time now. We've got about two seconds. No, a couple of minutes.

[01:51:00]Now that we've got the code we want cuz we want to do basically exactly the same thing over here.

[01:51:09]But unfortunately we've got the more complicated uh environment. But can we get this same code to work? We've debugged it with simple integer list. Can we get it to work with our folder and our everything else?

[01:51:28]Well, we've got about 3 minutes. What could possibly go wrong?

[01:51:35]Um, okay.

[01:51:49]Pre.

[01:51:50]Now, of course, these are all called emails. It's not going to be as simple as just changing the word to email instead of node.

[01:51:59]We can still say pre equals null. That's fine.

[01:52:06]We can't say current equals head.

[01:52:08]There's no head. Hopefully by now we know the head is just in this email folder though. Email folder emails. That's the head. That's going to set our current.

[01:52:26]Okay.

[01:52:29]Now, we're not searching for a data field in this particular one. Every email has a priority field and we're going to search for that.

[01:52:42]Priority is uh an enumerated type. We can use equals equals. So, we're just searching for the correctly named piece of data.

[01:52:52]Now, every time we talk about pre or current, that's fine. It's just anytime we talk about head, that's no good.

[01:53:02]Anytime we're talking about head in this one, we're talking about the emails list that's in the email folder.

[01:53:20]It's a lot harder to read though, isn't it? Um, but other than that, all the logic of what we're doing is identical. We've just got these this extra folder thing that makes it a bit tougher. But because we've got that extra folder, we don't have to return the head at the end. Now, this one's tricky and I've gone through it quite quickly, so don't be beating yourself up if you're confused. That's probably my fault.

[01:53:53]Let's try it. We've only got about a minute left.

[01:54:01]Uh, test main It compiles.

[01:54:28]I think I've got to comment out stuff in the test file.

[01:54:33]Sorry again for scrolling.

[01:54:39]There we go.

[01:54:50]Well, it did something.

[01:54:54]Now, it was meant to delete. You can take my word for it. It was meant to take this email list that had Bella, Eby, Holly, Andrew, Grace, Sophie, Liam.

[01:55:09]It was meant to delete all the low priority ones. So, we should be left with Sophie, Grace, and Eby.

[01:55:21]Again, a lot of scrolling. Sophie, Grace, and I think it worked. I didn't check the leaks though.

[01:55:37]It should work. That's what I You know, we always think that and then we do it and it doesn't work. I think that worked. Um yeah, you'll still need still need the mini freeze. So, look, that's all we've got time for, I think, today, right?

[01:55:53]What's the time? 56 past. So yeah, we didn't finish everything.

[01:56:00]You can go play around and see if you can implement I'm I'm sad we didn't get to merge um merge two folders together and then split two folders apart, but we did the basics of how to work with this extra strruct folder that has the the list inside it. So hopefully that was helpful. Um, yeah. So, we did a recap of deletion. We looked at this sort of more real world application that is more like what you're going to face in assignment two.

[01:56:35]And then next week, Henry's back. Um, I'm not sure exactly what he's doing next week, but it'll either be link lists or exam revision or something like that. I'll let let him tell you. All right. Thanks so much everybody. Thanks for participating and asking heaps of good questions, answering heaps of good questions, and enjoy your dinner if you're having some now. I certainly will be.

[01:57:02]All right, see you later. Bye-bye.

[01:57:15]Thanks. And the code will all be there.

[01:57:16]Okay, bye.