Question

how do you search for a lastname in a linked list? c++

Answer 1

i have a linked list that stores firstname, lastname, and phone number. i need to find the lastname

Answer 2

Are you using the STL?

Answer 3

I am using visual studio c++

Answer 4

Did you implement the linked list yourself?

Answer 5

i did. ammm can you give me an example of a referenced variable?

Answer 6

Referenced variable is like a pointer that is pretending to be deferenced.

Answer 7

Okay I need to know what your code is like first of all.

Answer 8

bool PhoneBook::Lookup (const string& lname, const string& fname, string& pnum) const
{
PhoneBookItem* p = head;
PhoneBookItem* q = head->next;

if (head == NULL)
return false;
else if (lname == p->lastname)
{
if (fname == p->firstname)
{

return true;
}
else return false;
}
else
{
while (q != NULL && lname != q->lastname)
{
p = q;
}
if (q != NULL && lname == q->lastname)
if (fname == q->firstname)
return true;
else
return false;
else
return false;
}

}

Answer 9

It says that the pnum should be returned to the calling function via a third argument, a reference variable. I don't know how. can you help me with this?

Answer 10

What is pnum supposed to be?

Answer 11

wio..phone number

Answer 12

All you need to do is assign pnum to the pnum of the node with the correct name.

Answer 13

```
while (q != NULL && lname != q->lastname)
{
p = q;
}
```
This code doesn't make sense. You should try something like:
```
while (q != NULL && lname != q->lastname)
{
p = q;
q = q->next;
}
```
You need to update q and p.

Answer 14

So assuming you find it, before you return true, you wanna assign pnum.
```
if (fname == p->firstname)
{
pnum = q->pnum; // put it here
return true;
}
```
```
if (fname == q->firstname)
{
pnum = q->pnum; // here too
return true;
}
else

```

Answer 15

I tried that, but it doesn't work. Here is the code in the main.

void LookupEntry(const PhoneBook& pb) {
string last, first, phone;
cout << "Enter last name: ";
cin >> last;
cout << "Enter first name: ";
cin >> first;
bool success = pb.Lookup(last, first, phone);
if (success) {
cout << "\nThe phone number is " << phone << ". \n";
} else {
cout << "\nError: no one by this name is in the phone book.\n";
}
}

Answer 16

```
string last, first, phone;
```
The problem is that `phone` should be a reference.
```
string last, first;
string& phone;
```

Answer 17

Does it even compile?

Answer 18

It does, but that code in the main cannot be changed since our professor said so.

Answer 19

Okay, what sort of output are you getting? What is happening?

Answer 20

It outputs : Error: no one by this name is in the phone book.
=================================================
if (success) {
cout << "\nThe phone number is " << phone << ". \n";
} else {
cout << "\nError: no one by this name is in the phone book.\n";
}

Answer 21

Alright, are you searching for something that is in the list?

Answer 22

yes

Answer 23

```
else if (lname == p->lastname)
{
if (fname == p->firstname)
{

return true;
}
else return false;
}
```
This code is wrong. If the last name is correct but the first name is not correct, it should continue searching, but your code instead gives up entirely.

Answer 24

```
else if (lname == p->lastname && fname == p->firstname)
{
return true;
}
```
This is what you should be doing.

Answer 25

There are a lot of bugs in your code, it'd be easier to show the correct way...

Answer 26

For example, why have `p` and `q`? You only need one to keep track of where you are, right?

Answer 27

yeah but i need to test this
=============================================
if (head == NULL)
return false;
else if (lname == p->lastname && fname == p->firstname)
{
p->phone = head->phone;
return true;
}
else
{
while (q != NULL && lname != q->lastname)
{
p = q;
p = p->next;
}
if (q != NULL && lname == q->lastname && fname == q->firstname)
{
q->phone = head->phone;
return true;
}
else
return false;
}
=====================================
else
{
while (q != NULL && lname != q->lastname)
{
p = q;
p = p->next;
}
if (q != NULL && lname == q->lastname && fname == q->firstname)
{
q->phone = head->phone;
return true;
}
else
return false;
}

Answer 28

why are you setting `p->phone` to `head->phone`?

Answer 29

those are the variable in my struct
======================================================
struct PhoneBookItem {
string lastname;
string firstname;
string phone;
PhoneBookItem* next;
PhoneBookItem(const string& l, const string& f, const string& ph);
};

Answer 30

Yeah, but you're setting the current item `p` to have the same phone number as the first item `head`. There is no reason to do that.

Answer 31

Okay, you should start out with your current item point to the front:
```
PhoneBookItem* current = head;
```

Answer 32

yes i did that

Answer 33

If you go through the whole list without finding it, then you want to return false.
```
while (current != NULL)
{
// search code here
current = current->next
}
return false;
```

Answer 34

Does that loop make sense so far? @Lynncake

Answer 35

yes it does, i'm writing the rest of it. but i am not sure if this is right

Answer 36

PhoneBookItem* p = head;

if (head == NULL)
return false;
else
{
while (p != NULL)
{
if (lname == p->lastname && fname == p->firstname)
{
return true;
}
p = p->next;
}
return false;
}

Answer 37

Now, for the search code... we just check if the names are correct
```
if (current->firstname == fname && current->lastname == lname)
{
pnum = current->phone;
return true;
}
```

Answer 38

We don't have anything if the names don't match. The loop will take care of that for us.

Answer 39

yes it worked! thank you

Answer 40

One second though.

Answer 41

```
if (head == NULL)
return false;
else
{
while (p != NULL)
```
The `if (head == NULL)` here is pointless. The `while (p != NULL)` already check if `head` is `NULL`.

Answer 42

@Lynncake
Does that make sense?

Answer 43

yes, it does thanks a lot

Answer 44

alright, well good luck then.

Answer 45

for the delete, is this right?
======================================
PhoneBookItem* p = head;

while (p != NULL)
{
if (lname == p->lastname && fname == p->firstname)
{
delete p;
p->next=NULL;
num--;
return true;
}
p = p->next;

}
return false;
======================================
I followed your method/concept.

Answer 46

The problem with this is that you need to keep track of the item before you.

Answer 47

And you set the guy behind you's `next` property to your own `next` property.

Answer 48

so in here i should hava another pointer that points to the next element?

Answer 49

This case is a bit tricky because you have two case:
1) They are deleting the head...

2) They are deleting something in the middle of the list

Answer 50

For 1) you delete it, and set head to NULL

For 2) you need to set the previous guy's next to the deleted guy's next

Answer 51

```
PhoneBookItem* last = head;
PhoneBookItem* current = head->next;

// Check head

// Check guys in the middle of the list
```

Answer 52

For check head, we wanna do:
```
if (head != NULL && head->firstname == fname && head->lastname == lname)
{
delete head;
head = NULL;
}
```

Answer 53

For checking others, we want a loop:
```
while (current != NULL)
{
\\ check current
last = current;
current = current->next;
}
return false;
```

Answer 54

For current, we do something similar to head, but with a change:
```
if (current->firstname == fname && current->lastname == lname)
{
last->next = current->next;
delete head;
return true;
}
```

Answer 55

Hmmm, there should be a `return true;` in the check head part too.

Answer 56

What we are doing is changing this:

Answer 57

so the last is the head?

Answer 58

To this: