Здравейте,

имам следната задача:

Да се състави функция за извличане от дадена опашка от цели числа на най-големия елемент.

Т.е. разбирам че при въвеждане на определен брой числа да ми се изведе най голямото число.

Ето и кода.

#include <iostream>
using namespace std;

struct elem
{ int key;
elem *next;
}
*start=NULL, *p;



void push(int n)
{
	elem *p=start;
	start=new elem;
	start->key=n;
	start->next=p;


}
int pop(int &n)
{
	if(start)
	{
		n=start->key;
		elem *p=start;
		start=start->next;
		delete p;
		return 1;
	}
	else
		return ;
}
int main()
{
	int num;
	do
	{
		cin>>num;
		if(num) push(num);
	}
	while(num!=);
	while(pop(num))
		cout<<num<<"Nai golqmoto vuvedeno chislo e:";
return ;
}

Опитах се при въвеждане на 0 да ми извежда крайния резултат, но ми извежда въведените числа по много особен начин.

Къде ми е грешката?

Редактирано 10 април 201610 г. от Maria11 (преглед на промените)

х = минус безкрайност

цикъл:

у = поп (опашката)

ако (у е по голямо от х) х = у

ако не е свършила опашката гоуту цикъл

х вече съдържа най голямото число от тези, които са били в опашката

Редактирано 10 април 201610 г. от Реджеп Иведик (преглед на промените)

преди 2 часа, Реджеп Иведик написа:

х = минус безкрайност

цикъл:

у = поп (опашката)

ако (у е по голямо от х) х = у

ако не е свършила опашката гоуту цикъл

х вече съдържа най голямото число от тези, които са били в опашката

Не е правилно да ползваш вариант на общ алгоритъм, който работи в частен случай, без основателна причина. Алгоритъмът може да се ползва в случаи, в които изобщо не знаеш, какво сравняваш, камо ли най-малката възможна стойност. Съответно е много лошо да учиш хората да инициализират началото на нея.

Редактирано 10 април 201610 г. от flare (преглед на промените)

Прочети внимателно условието. Става въпрос за цели числа. В <climits> има дефинирана константа INT_MIN. Не ме учи на какво е лошо и на какво е добро да уча хората. Темата е за да помогнеш на момичето, а не за да ме кастриш заради виждането ми за случая с Хайдукпикасо. Домързяло те е даже да напишеш алгоритъма, който имаш предвид, за да се поне малко замаскираш.

 

ако опашката е празна значи опашката е празна и край

ако опашката има един елемент, той е най големия - пак край

х = поп (опашката)

цикъл:

у = поп (опашката)

ако (у е по голямо от х) х = у

ако не е свършила опашката гоуту цикъл

х вече съдържа най големия елемент от тези, които са били в опашката

Редактирано 11 април 201610 г. от Реджеп Иведик (преглед на промените)

int max(queue<int> &q)
{
    int s=q.size();
    int m=q.front(); 
    q.push(m); q.pop();
    for (int i=1; i<s; ++i)
    {
        if (q.front()>m) m=q.front();
        q.push(q.front()); q.pop();
    }
    return m;
}

а ако сам си пишеш функциите на опашката може да ползваш и вътрешната и структура 

struct elem
{
    int key;
    elem *next;
};

class queue
{
     elem *start;
     elem *end;
public:
     queue();
     ~queue();
     void push(int);
     int pop();
     int max();
     int empty();
};

...
int queue::max()
{
    if (start==NULL) return 0;
    int n=start->key;
    elem *p=start->next;
    while (p)
    {
        if (p->key > n) n=p->key;
        p=p->next;
    }
    return n;
}

 

Редактирано 11 април 201610 г. от ined (преглед на промените)

Ето моето решение. Тествал съм го, работи.

#include <iostream>
#include <queue>
#include <ctime>
#include<cstdlib>
using namespace std;

int main(){

    srand(time(NULL));

    queue<int> n;

    for(int i=;i<10;i++){

        n.push(rand()%10);
    }


    int max = 0;


while(n.empty() == 0)
{                
        max = n.front();
        cout << n.front();
        if(n.back() > max){max = n.back();}
        n.pop();
}
  
cout << endl;
cout << max << endl;

    return 0;
}

Редакторът за код е бъгав и ми трие нулите при задаване на С синтаксисно оцветяване Това го казвам, за да си знаят модераторите.

Редактирано 11 април 201610 г. от frozener (преглед на промените)

Само дето така се скапва садържанието на опашката, иначе на мене не ми е много ясно условието - трябва да се определи кой е най-големия елемент или освен това той трябва да се махне от опашката? И освен това ако са повече от един - първия ли трябва да се махне или всичките?

преди 7 минути, ined написа:

Само дето така се скапва садържанието на опашката, иначе на мене не ми е много ясно условието - трябва да се определи кой е най-големия елемент или освен това той трябва да се махне от опашката? И освен това ако са повече от един - първия ли трябва да се махне или всичките?

За моя код ли говориш? Аз си попвам съдържанието на опашката, да. Забелязал съм, че условията на задачите не са много пояснителни.

Може би нещо от рода на:

int max(queue<int> &q)
{
    queue<int> s;
    int n,m=q.front(); 
    s.push(m); q.pop();
    while(!q.empty())
    {
        n=q.front();
        if (n>m) m=n;
        s.push(n);
        q.pop();
    }
    while(!s.empty())
    {
        n=s.front();
        if (n<m) q.push(n);
        s.pop();
    }
    return m;
}

 

 

Написах я така но не се получава

#include <iostream>
using namespace std;
struct elem
{
	int key;
	elem *next;
}
*first=NULL, *last=NULL, *p;
void push(int n)
{
	p=last;
	last=new elem;
	last->key=n;
	last->next=NULL;
	if (p!=NULL)
		p->next=last;
	if (first=last)
	{
		first=last; }
}
int pop(int &n)
{
	if (first)
	{
		p=first;
		n=first->key;
		first=first->next;
		if (first==NULL) // Kogato first e null togava delete...
			last=first;
		delete p;
		return 1;
	}
	else
		return ;
}
int main()
{
int num;
cout<<" Vuvedete stoinost";
cin>>num;
{
    if (p==NULL) 
		return ;
    int num=p->key;
    elem *p=p->next;
    while (p)
    {
        if (p->key > num) 
			num=p->key;
        p=p->next;
    }
    return num;
}
system("pause");
return ;
}

 

Редактирано 16 април 201610 г. от Maria11 (преглед на промените)

Ми нормално да не се получава, първоначално опашката ти е празна - трябва да вкараш някакви числа в нея, и вече от тия числа да търсиш максимума.

 

#include <iostream>
using namespace std;
struct elem
{
	int key;
	elem *next;
}
*first = NULL, *last = NULL, *p;
void push(int n)
{
	p = last;
	last = new elem;
	last->key = n;
	last->next = NULL;
	if (p != NULL)
		p->next = last;
	if (first == 0)
	{
		first = last;
	}
}
int pop(int &n)
{
	if (first)
	{
		p = first;
		n = first->key;
		first = first->next;
		if (first == NULL) // Kogato first e null togava delete...
			last = first;
		delete p;
		return 1;
	}
	else
		return 0;
}


int main()
{
	int num;
	int maxim;
	for (;;)
	{
		cout << " Vuvedete stoinost -> ";
		cin >> num;
		if (num == 0) break;
		push(num);
	}
	if (first == 0) return 0;
	maxim = first->key;
	p = first;
	while (p->next != 0)
	{
		p = p->next;
		if (maxim < p->key) maxim = p->key;
	}
	cout << endl << endl << "maxim = " << maxim;
	return 0;
}