Wrong Output while Printing maximum in linked list - c++

Question

I was printing the max of a linked list in C++ language . But I was not getting the desired output. While Building and running the code, the terminal gets stuck in building it. I tried it in VS Code and Sublime text both. I am using mingw64 compiler.
After the run the program this happens Gets stuck after displaying the linked list
#include <stdlib.h>
#include <stdio.h>
using namespace std;
struct node {
int data;
struct node *next;
} *first = NULL;
//declaring a global head/first pointer which stores the address of first node
void create(int a[], int n) {
int i;
struct node *t, *last;
first = (struct node *)malloc(sizeof(struct node));
first->data = a[0];
first->next = NULL;
last = first;
for (i = 1; i < n; i++) {
// t = new node;
t = (struct node *)malloc(sizeof(struct node));
t->data = a[i];
t->next = NULL;
last->next = t;
last = t;
}
}
void display(struct node *p) {
while (p != NULL) {
printf("%d ", p->data);
p = p->next;
}
}
int Max(struct node *p) {
int max = -100;
while (p != NULL) {
if (p->data > max) {
max = p->data;
p = p->next;
}
}
return max;
}
int main() {
int m = 0;
int a[] = { 3, 5, 7, 10, 15, 8, 12, 20 };
create(a, 8);
display(first);
printf("\n");
m = Max(first);
cout << "The maximum of the linked list is : " << m;
return 0;
}

Answer 1

while (p != NULL)
{
if (p->data > max)
{
max = p->data;
p = p->next;
}
}
Update this to
while (p != NULL)
{
if (p->data > max)
{
max = p->data;
}
p = p->next;
}
Otherwise your code will STUCK in infinite loop.

Answer 2

I usually prefer one line comparison so that code is easy to understand and no bus will appear
int Max(struct node *p) {
int max_number = INT_MIN;
while (p != NULL) {
max_number = max(max_number, p->data);
p = p->next;
}
return max_number;
}

Answer 3

Your code is a mixture of C and C++ code. You should settle for one or the other and use idioms appropriate for the one you choose. Using a mixture of C and C++ is a recipe for failure. As coded, the program is closer to C than C++, just remove the C++isms and program in C.
The reason it gets stuck is p does not get updated in the while loop when the value p->data is not greater than max. Note however that there are other problems: the code will not find the maximum value if all values are less than -100 and it will return -100 if the list is empty.
Here is a modified version, in C, with both issues corrected:
#include <stdio.h>
#include <stdlib.h>
//declaring a global head/first pointer which stores the address of first node
struct node {
int data;
struct node *next;
} *first = NULL;
/* append the elements from a[] to the end of the linked list */
void create(const int a[], int n) {
struct node *last;
last = first;
while (last && last->next) {
last = last->next;
}
for (int i = 0; i < n; i++) {
// t = new node;
struct node *t = (struct node *)malloc(sizeof(struct node));
if (t == NULL)
return;
t->data = a[i];
t->next = NULL;
if (last)
last->next = t;
else
first = t;
last = t;
}
}
void display(const struct node *p) {
while (p != NULL) {
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
int getmax(struct node *p) {
int max = 0;
if (p != NULL) {
max = p->data;
p = p->next;
while (p != NULL) {
if (max < p->data) {
max = p->data;
}
p = p->next;
}
}
return max;
}
int main() {
int a[] = { 3, 5, 7, 10, 15, 8, 12, 20 };
create(a, sizeof(a) / sizeof(a[0]));
display(first);
printf("The maximum of the linked list is: %d\n", getmax(first));
return 0;
}

Answer 4

Except these two lines
using namespace std;
and
cout << "The maximum of the linked list is : " << m;
there is nothing in the program that could be referenced as a C++ code and not C code. Moreover you even forgot to include the header <iostream>.
Also the program has an inconsistence interface. Some functions deal directly with the global variable first while other functions accept the variable through parameters.
Even the function create can invoke undefined behavior because the user can pass as the second argument zero or a negative number.
void create(int a[], int n) {
int i;
struct node *t, *last;
first = (struct node *)malloc(sizeof(struct node));
first->data = a[0];
//...
In this case the expression a[0] has an indeterminate value.
The function Max (Why does its name start with an upper case letter?) has a bug. Moving to a next node occurs only in case when p->data > max
if (p->data > max) {
max = p->data;
p = p->next;
}
You need to place the statement
p = p->next;
after the if statement
int Max(struct node *p) {
int max = -100;
while (p != NULL) {
if (p->data > max) {
max = p->data;
}
p = p->next;
}
return max;
}
But in any case the function does not make a great sense because the returned value -100 for an empty list can be a valid data for the list.
If you are learning C++ then start to learn it from the C++ 17 Standard and use features of C++ instead of features of C as the C++ operator new instead of the C function malloc.
Your program as indeed a C++ program can look for example the following way.
#include <iostream>
#include <optional>
#include <functional>
#include <iterator>
struct node
{
int data;
node *next;
};
void clear( node * &head )
{
while ( head ) delete std::exchange( head, head->next );
}
void create( node *&head, const int a[], size_t n )
{
clear( head );
node **current = &head;
for (size_t i = 0; i < n; i++)
{
*current = new node{ a[i], nullptr };
current = &( *current )->next;
}
}
std::ostream &display( const node *head, std::ostream &os = std::cout )
{
for (const node *current = head; current; current = current->next)
{
os << current->data << " -> ";
}
return os << "null";
}
std::optional<int> max( const node *head )
{
std::optional<int> max_value;
if (head)
{
max_value = head->data;
for (const node *current = head->next; current; current = current->next)
{
if (max_value < current->data) max_value = current->data;
}
}
return max_value;
}
int main()
{
node *head = nullptr;
int a[] = { 3, 5, 7, 10, 15, 8, 12, 20 };
create( head, a, std::size( a ) );
display( head ) << '\n';
auto max_value = max( head );
if ( max_value )
{
std::cout << "The maximum of the linked list is : " << *max_value << '\n';
}
else
{
std::cout << "The list is empty.\n";
}
clear( head );
max_value = max( head );
if ( max_value )
{
std::cout << "The maximum of the linked list is : " << *max_value << '\n';
}
else
{
std::cout << "The list is empty.\n";
}
return 0;
}
The program output is
3 -> 5 -> 7 -> 10 -> 15 -> 8 -> 12 -> 20 -> null
The maximum of the linked list is : 20
The list is empty.