Ερωτήσεις Κατανόησης Δέντρων tree C#

MpOuKaLAs · 7 Ιουλίου 2010

Ξερει καποιος να μου εξηγησει την διαφορα μεταξυ

>for(i=0;i<5;i++)

με 

for(i=0;i<5;[color="Red"]++[/color]i)

αλλα και η διαφορα

int push( int stack[] , int x ){

return push( stack , x );
}


με 


int push( int stack[] , int x ){

push( stack , x );
}

Pantelwolf · 7 Ιουλίου 2010

for(i=0;i<5;i++)

με

for(i=0;i<5;++i)

Σε αυτήν την περίπτωση δεν έχει καμία απολύτως διαφορά.

Θα είχε αν είχες πχ

i=1;

a= ++i ;

αποτελ:a=2 i=2

i=1;

a= i++ ;

αποτελ:a=1 i=2

λέει δλδ το ++ οτι αν μπει μπροστά κάνε πρώτα την αύξηση και μετά τα υπόλοιπα ενω αν μπει μετά κάνε το ανάποδο.

Στο δεύτερο ή είναι πολύ αργά ή δε βγάζει νόημα.

έστω οτι ξεπερνώ οτι πιθανόν οι λέξεις stack και push να χρησιμοποιούνται ήδη, προσπαθείς να κάνεις κάτι σαν αναδρομή αλλά ??...

το return είναι η εντολή που λέει "το αποτέλεσμα του συνοθυλεύματος δεξιά μου ότι και να είναι αυτό στείλε το σαν τιμή επιστροφής της συνάρτησης"

MpOuKaLAs · 7 Ιουλίου 2010

Ας απαντησει καποιος στα σιγουρα...

RubiksCube · 7 Ιουλίου 2010

Ας απαντησει καποιος στα σιγουρα...

Για να απαντήσει κάποιος στα σίγουρα πρέπει να δώσεις περισσότερες πληροφορίες. Πχ αυτό που δίνεις σε ποια γλώσσα υποτίθεται ότι είναι? Έτσι όπως το βλέπω δεν κάνει κάν compile. Όταν μια συνάρτηση πρέπει να επιστρέψει κάτι (άρα όχι void) πρέπει να έχει return οπωσδήποτε.

Επίσης χρησιμοποιείς την push() με διαφορετικού τύπου formal parameters. Είναι overloaded? Γεινικά μην περιμένεις πολλά απο αυτό το post, δώσε πληροφορίες.

MpOuKaLAs · 7 Ιουλίου 2010

>for(i=0;i<5;i++)

με 

for(i=0;i<5;[color="Red"]++[/color]i)

αλλα και η διαφορα

int push( int stack[] , int x ){

       //υποθετουμε εδω οτι καποτε τερματιζει η αναδρομη οταν φτασει π.χ το x στο 0
       
[color="Red"][b]	return ( push( stack , x ) +  push( stack , x ) + 1 );[/b][/color]
}

C ειναι η γλωσσα και η αποριες μου ειναι για ποιο λογο πολλες φορες χρησιμοποιουν οι προγραμματιστες το ++i αντι του i++ !!

Επισης τι συμβαινει με την return και την αναδρομικη κληση της συναρτησης

μην λαμβανετε υπ'οψην σας τα ονοματα των συναρτησεων

RubiksCube · 7 Ιουλίου 2010

i++ σημαίνει ότι πρώτα εκτελείται η εντολή και ΑΦΟΥ εκτελεστεί η τιμή του i αυξάνεται (post increment). Αντιθέτως ++i σημαίνει ότι πρώτα αυξάνεται η τιμή και μετά εκτελείται η εντολή. Στο παράδειγμα του for που έχεις, δεν έχει καμιά διαφορά γιατί το i++ είναι μόνο του σε μια εντολή.

Αλλά το παρακάτω θα στο ξεκαθαρίσει.

δοκίμασε

int x =10;

int y = x++;

αποτέλεσμα μετά την εκτέλεση, y=10, x=11

ενώ

int x =10;

int y = ++x;

αποτέλεσμα μετά την εκτέλεση, y=11, x=11

Όσο για την αναδρομή, θέλει λίγο παραπάνω εξήγηση, ίσως αργότερα, γιατί έχω δουλειά.

MpOuKaLAs · 7 Ιουλίου 2010

>for(i=0;i<5;i++)

με 

for(i=0;i<5;[color="Red"]++[/color]i)

αλλα και η διαφορα

int push( int stack[] , int x ){

       //υποθετουμε εδω οτι καποτε τερματιζει η αναδρομη οταν φτασει π.χ το x στο 0
       
[color="Red"][b]	return ( push( stack , x ) +  push( stack , x ) + 1 );[/b][/color]
}
C ειναι η γλωσσα και η αποριες μου ειναι για ποιο λογο πολλες φορες χρησιμοποιουν οι προγραμματιστες το ++i αντι του i++ !!

Επισης τι συμβαινει με την return και την αναδρομικη κληση της συναρτησης

μην λαμβανετε υπ'οψην σας τα ονοματα των συναρτησεων

Η ΜΠΟΡΕΙΤΕ ΝΑ ΤΡΕΞΕΤΕ ΤΟΝ ΠΑΡΑΚΑΤΩ ΚΩΔΙΚΑ ΜΕ ΤΑ ΙΔΙΕΣ ΑΠΟΡΙΕΣ

>//---------------------------------------------------------------------------

#include <stdio.h>
#pragma hdrstop

#include <tchar.h>
//---------------------------------------------------------------------------

struct node{

int data;
int fui;
int skata;
struct node *next;

};

typedef struct node *PTR;


int push( PTR nod_1 , PTR nod_2 , int x ){

int num1=0 , num2=0;

printf("\nDose x:");
scanf("%d",&x);
while( x != 0 ){

	nod_1->next = malloc(sizeof(struct node));
	nod_1 = nod_1->next;
	nod_1->data = x;
	nod_1->fui = 1000000;
	nod_1->skata =12233;

	nod_2->next = malloc(sizeof(struct node));
	nod_2 = nod_2->next;
	nod_2->data = x;

	printf("\nnod_1 is:%d",nod_1);
	printf("\nnod_2 is:%d",nod_2);
	num1 = nod_1;
	num2 = nod_2;
	num1=(num1+num2);
	printf("\n\neinai to teliko:%d",num1);
	getchar();

	return(push( nod_1 , nod_2 , x ) + push( nod_1 , nod_2 , x )+1);

}
}


#pragma argsused
int _tmain(int argc, _TCHAR* argv[])
{
int x;
PTR nod_1, nod_2 ;

nod_1 = malloc(sizeof(struct node));
nod_1->data = 10;
nod_1->next = NULL;

nod_2 = malloc(sizeof(struct node));
nod_2->data = 5;
nod_2->next = NULL;


printf("\nto arxiko nod_1 is:%d",nod_1);
printf("\nto arxiko nod_2 is:%d",nod_2);

push( nod_1 , nod_2 , x );

getchar();
getchar();
getchar();
return 0;
}
//---------------------------------------------------------------------------

---------- Προσθήκη στις 04:36 ---------- Προηγούμενο μήνυμα στις 04:34 ----------

i++ σημαίνει ότι πρώτα εκτελείται η εντολή και ΑΦΟΥ εκτελεστεί η τιμή του i αυξάνεται (post increment). Αντιθέτως ++i σημαίνει ότι πρώτα αυξάνεται η τιμή και μετά εκτελείται η εντολή. Στο παράδειγμα του for που έχεις, δεν έχει καμιά διαφορά γιατί το i++ είναι μόνο του σε μια εντολή.

Αλλά το παρακάτω θα στο ξεκαθαρίσει.

δοκίμασε

int x =10;

int y = x++;

αποτέλεσμα μετά την εκτέλεση, y=10, x=11

ενώ

int x =10;

int y = ++x;

αποτέλεσμα μετά την εκτέλεση, y=11, x=11

Όσο για την αναδρομή, θέλει λίγο παραπάνω εξήγηση, ίσως αργότερα, γιατί έχω δουλειά.

thanks!!!

Το παραδειγμα σου τελειο!!

Με την αναδρομη να δω τι θα γινει!

εχω και ετοιμο κωδικα παραπανω ριξε την ματια σου!

V.I.Smirnov · 7 Ιουλίου 2010

Δοθείσης της ευκαιρίας θέλω να κάνω μια ερώτηση που έχω από καιρό.

Θυμάμαι ότι ο τελεστής προθέματος (δηλ. το ++i) και επιθέματος (δηλ. το i++) όταν υφίστανται υπέρβαση (overloading) δεν υπάρχει τρόπος να διακριθούν μεταξύ τους.

Δεδομένου ότι το βιβλίο όπου το διάβασα αυτό ήταν παλιό ('91 έκδοση) και ότι ήδη από τότε είχαν προταθεί στο standard διάφοροι τρόποι για να αρθεί αυτή η ατέλεια,

θέλω να ρωτήσω αν τελικά έγινε κάτι ή όχι.

Κοντολογίς, το τωρινά ισχύον standard της C++ υποδεικνύει πώς γίνεται το overloading προθέματος και επιθέματος ώστε να διακρίνονται μεταξύ τους ;

Kαι αν ναι, το υποστηρίζουν αυτό οι συνήθεις compilers που δουλεύουμε ;

3c0r1z · 7 Ιουλίου 2010

Δοθείσης της ευκαιρίας θέλω να κάνω μια ερώτηση που έχω από καιρό.

Θυμάμαι ότι ο τελεστής προθέματος (δηλ. το ++i) και επιθέματος (δηλ. το i++) όταν υφίστανται υπέρβαση (overloading) δεν υπάρχει τρόπος να διακριθούν μεταξύ τους.

Δεδομένου ότι το βιβλίο όπου το διάβασα αυτό ήταν παλιό ('91 έκδοση) και ότι ήδη από τότε είχαν προταθεί στο standard διάφοροι τρόποι για να αρθεί αυτή η ατέλεια,

θέλω να ρωτήσω αν τελικά έγινε κάτι ή όχι.

Κοντολογίς, το τωρινά ισχύον standard της C++ υποδεικνύει πώς γίνεται το overloading προθέματος και επιθέματος ώστε να διακρίνονται μεταξύ τους ;

Kαι αν ναι, το υποστηρίζουν αυτό οι συνήθεις compilers που δουλεύουμε ;

Σοβαρά διαβάζεις βιβλίο για C++ απο το 91; Εγώ δεν θα το διάβαζα πάντως διότι είναι πλέον ξεπερασμένο. Στο ερώτημα σου τώρα. Ο διαχωρισμός είναι δυνατόν γιατί ο τελεστής χρησιμοποιεί διαφορετική υπογραφή. Συγκεκριμένα:

>// ++obj
Foo& operator++();
// obj++
const Foo operator++(int);

Όπως καταλαβαίνεις η παράμετρος στον τελεστή απλά υπάρχει για να γίνεται ο διαχωρισμός. Η χρησιμοποίηση ή χειρότερα πιθανή επιστροφή της παραμέτρου μπορεί να προκαλέσει απροσδιόριστη συμπεριφορά. Το const στην αρχή του τελεστή είναι απαραίτητο διότι είναι απαραίτητη για τη σωστή χρήση του τελεστή. Χωρίς το const θα μπορούσαμε να γράψουμε κάτι σαν το παρακάτω:

>Foo bar(10);
Foo tmp = bar++++;

Φυσικά ο παραπάνω κώδικας δεν βγάζει νόημα απλά θεωρείται καλή προγραμματιστική αρχή. Επίσης η υλοποίηση των δυο τελεστών συνήθως πηγαίνει μαζί διότι στην υλοποίηση του τελεστή επιθέματος χρησιμοποιείται ο προθεματικός τελεστής.

Τέλος οποιονδήποτε πρόσφατο μεταγλωττιστή και να χρησιμοποιήσεις υποστηρίζει κανονικά την υπερφόρτωση των παραπάνω τελεστών.

Υ.Γ. Για όποιον ενδιαφέρεται ακολουθεί παρακάτω η υλοποίηση των τελεστών μιας και κάναμε τον κόπο να τον γράψουμε

Y.Γ2: Αυτά που γράφω στο post αυτό ισχύουν μόνο για C++ όχι για C.

Foo.h

>#ifndef FOO_INCLUDED
#define FOO_INCLUDED

#include <iostream>

class Foo
{
public:
   explicit Foo(int num = 0) { num_ = num; }

   Foo& operator++();
   const Foo operator++(int);

   int Num() const;
private:
   int num_;
};

inline int Foo::
Num() const
{
   return num_;
}

#endif //FOO_INCLUDED

Foo.cpp

>#include "Foo.h"
Foo& Foo::
operator++()
{
   ++num_;
   return *this;
}

const Foo Foo::
operator++(int)
{
   Foo temp(num_);
   ++(*this);

   return temp;
}

main.cpp

>#include "Foo.h"
using namespace std;
int main()
{
   Foo bar(10);
   cout << "Number bar:" << bar.Num() << '\n';

   ++bar;
   cout << "Number bar:" << bar.Num() << '\n';

   Foo tmp = bar++;
   cout << "Number bar:" << bar.Num() << '\n';
   cout << "Number tmp:" << tmp.Num() << '\n';

   return 0;
}

V.I.Smirnov · 7 Ιουλίου 2010

Σοβαρά διαβάζεις βιβλίο για C++ απο το 91; Εγώ δεν θα το διάβαζα πάντως διότι είναι πλέον ξεπερασμένο. Στο ερώτημα σου τώρα....

Καταρχήν, σε ευχαριστώ για την απάντηση.

Το βιβλίο που διάβασα ήταν ένα εξαιρετικό κείμενο που υφίσταται και σήμερα - φυσικά σε νεότερη έκδοση.

Δεν είμαι τόσο αφελής, ξέρω τι και πώς να μελετάω.

Το βιβλίο αυτό ήδη από τότε ( το '91 !! ) ανέφερε ότι η σύνταξη

>// ++obj
Foo& operator++();
// obj++
const Foo operator++(int);

είναι ένας τρόπος που υπέδειξαν οι Ellis & Stroustroup να αρθεί το πρόβλημα αλλά τότε δεν είχε ακόμη εισαχθεί στο standard και δεν την υποστήριζαν οι compilers.

Εξάλλου ο υπαινιγμός μου "ήδη από τότε είχαν προταθεί στο standard διάφοροι τρόποι για να αρθεί αυτή η ατέλεια" δείχνει ότι ήμουν ενήμερος για την υποψήφια λύση.

Παρόλο που πέρασαν χρόνια, το θυμήθηκα και ρώτησα για να μάθω αν τελικά υιοθετήθηκε από το standard ή όχι για να μην ψάχνω αν μου χρειαστεί.

Και πάλι ευχαριστώ.

disqualified · 7 Ιουλίου 2010

παρε ενα πιο συγχρονο βιβλιο. Ειμαι σεχδον σιγουρος πως οποιδηποτε συγχρονο βιβλιο διαβασεις εχει ακριβως το ιδιο παραδειγμα που σου εδωσε ο Pantelwolf και ο RubiksCube και καταλαβες τη διαφορα

MpOuKaLAs · 7 Ιουλίου 2010

Μπορει καποιος να μου εξηγησει πως εκτελειτε ο παρακατω κώδικας?

>//---------------------------------------------------------------------------

#include <stdio.h>
#pragma hdrstop

#include <tchar.h>
//---------------------------------------------------------------------------

int anadromh( int num ){

anadromh( num-1 ) + anadromh( num-5 );
}

#pragma argsused
int _tmain(int argc, _TCHAR* argv[])
{
int a=10;


a = anadromh(a);
printf("teliko:%d",a);



getchar();
return 0;
}
//---------------------------------------------------------------------------

pinball_elf · 7 Ιουλίου 2010

Μπορει καποιος να μου εξηγησει πως εκτελειτε ο παρακατω κώδικας?

>//---------------------------------------------------------------------------

#include <stdio.h>
#pragma hdrstop

#include <tchar.h>
//---------------------------------------------------------------------------

int anadromh( int num ){

anadromh( num-1 ) + anadromh( num-5 );
}

#pragma argsused
int _tmain(int argc, _TCHAR* argv[])
{
int a=10;


a = anadromh(a);
printf("teliko:%d",a);



getchar();
return 0;
}
//---------------------------------------------------------------------------

Συμφωνα με την λογική του παραπάνω κώδικα το πρόγραμμα στην ουσία δεν τελειώνει ποτέ, άσε που δεν περνάει την μεταγλώτηση. Η συνάρτηση anadromh δεν επιστρέφει τίποτα και το πιο σοβαρό είναι οτί δεν τελειώνε ποτέ, διότι καλεί συνέχεια τον εαυτό της.

Παράδειγμα αναδρομικής

>
#include <stdio.h>

int paragontiko (int num) {
   if (num == 1)
       return 1;
   else
       return (num*(paragontiko(num-1)));
}

int main(void)
{
   printf("paragontiko(5) = %d\n", paragontiko(5));
   getch();
   return 0;
}

V.I.Smirnov · 7 Ιουλίου 2010

H σωστή κατασκευή/χρήση μιας αναδρομικής συνάρτησης απαιτεί κατανόηση κάποιων βασικών

αρχών όπως βασική υπόθεση τερματισμού, διαμέριση του προβλήματος σε μικρότερα, σχέση την

επαγωγική μέθοδο κ.α.

Για να καταλάβεις πώς λειτουργεί και να τη φτιάξεις σωστά πρέπει να τα ξέρεις αυτά,

αλλιώς παιδεύεσαι δίχως αποτέλεσμα...

MpOuKaLAs · 7 Ιουλίου 2010

Μην κολλατε μωρε στο αν επιστρεφει τιποτα η οχι και μου γραφετε τις παρατηρησεις σας.

αυτο που θελω να μαθω ειναι τα εξης:

π.χ εχω την παρακατω συναρτηση

>
void function(int number){

function(number)+function(number);

}

Προκειται για ανδρομη κατα καποιο τροπο και καλω δυο φορες τον εαυτο τους

προσθετοντας τες μεταξυ τους.

Ποια ειναι τα βηματα ?

δλδ θα εκτελεστει πρωτα η πρωτη function(number) Και μετα η δευτερη κ.τ.λ ?

τα βηματα θελω να καταλαβω.

αν μπορειτε φτιαξτε και εσεις ενα παραδειγματακι να κατανοησω την λειτουργια αυτο θελω

ΔΕΙΤΕ ΚΑΙ ΑΥΤΟ

>int count(PTR t)
{
if (t==NULL) return(0);
return(count(t->left)+count(t->right)+1);
}

Σύνδεση

Ερωτήσεις Κατανόησης Δέντρων tree C#

Προτεινόμενες αναρτήσεις

MpOuKaLAs

Pantelwolf

MpOuKaLAs

RubiksCube

MpOuKaLAs

RubiksCube

MpOuKaLAs

V.I.Smirnov

3c0r1z

V.I.Smirnov

disqualified

MpOuKaLAs

pinball_elf

V.I.Smirnov

MpOuKaLAs

Αρχειοθετημένο

Σύνδεση