C Programming

Let N = the number of nodes, F = number of full nodes, L = the

number of leaves, and H = the number of nodes with one child (or half nodes).

The total number of nodes in a binary tree equals N = F + H + L.

Because each full node is incident on two outgoing edges, each half node is

incident on one outgoing edge, and each leaf is incident on no outgoing edge it

follows that the total number of edges in a binary tree equals 2F + H. It is also

true that the total number of edges in a tree equals N 1. Thus,

2F + H = N 1

H = N 1 2F

Subbing this value of H into N = F + H + L gives,

N = F + N 1 2F + L

N N + 1 = F + L

F + 1 = L

2 on top and bottom 4 in the middle on right and left

cars was

for(int i= 51;i<=60;i++)

cout<<i;

Check out supportsoft.com. See something familiar? I had to go into the registry and delete all the supportsoft entries. Don't mess with the registry unless you know what you're doing though. Misty

it just represents a slightly below average grade, it does not stand for anything

rong, it means could do better... da

A virtual table, or "vtable", is a mechanism used in Programming languages to support dynamic polymorphism, i.e., run-time method binding. Hope ive helped. Each function has an address in memory somewhere. Function names are just pretty ways of referring to a position in memory. When a program is linked (after the compiler is finished compiling) all those names are replaced with hardcoded memory addresses.

class Foobar

{

public:

int i;

void Something() {i = 0;}

};

int main()

{

Foobar f;

f.Something();

return 0;

}

You can tell even before execution that f.Something() is referring to the Something in Foobar. The linker will be able to replace that with an address pointing directly at Something.Draw().

This works pretty well until you bring in polymorphism because the linker is unable to tell which function to call. For example in C++:

class Foobar

{

public:

int i;

Foobar() {i = -1;}

virtual void FuncA() {i = 0;}

void FuncB() {i = 10;}

};

class Foo: public Foobar

{

public:

virtual void FuncA() {i = 1;}

void FuncB() {i = 11;}

};

class Bar: public Foobar

{

public:

virtual void FuncA() {i = 2;}

void FuncB() {i = 12;}

};

void FoobarFunc(Foobar* fb)

{

cout << fb->i << endl;

fb->FuncA();

cout << fb->i << endl;

fb->FuncB();

cout << fb->i << endl << endl;

}

void FooFunc(Foo* f)

{

cout << f->i << endl;

f->FuncA();

cout << f->i << endl;

f->FuncB();

cout << f->i << endl << endl;

}

int main()

{

Foobar fb;

Foo f;

Bar b;

Foo OtherFoo;

FoobarFunc(&fb);

FoobarFunc(&f);

FoobarFunc(&b);

FooFunc(&OtherFoo);

return 0;

}

In this excerpt, both Foo and Bar inherit from Foobar. FuncA is a virtual function while FuncB is not. The integer i is being set to see the results of our actions.

Notice how in FoobarFunc, you are unable to tell beforehand what address to replace FuncA and FuncB with! In order to solve this, virtual tables are created.

Normally, functions are not stored with the data of the class at all. So in our very first Foobar example with no inheritance, the class would only be 4 bytes long (excluding any compiler magic). However, when you declare something virtual, you're actually declaring a pointer to a function so each virtual function you have will increase the class size by the size of a pointer. The pointers will be populated by the constructors under the hood which is one reason why you cannot have virtual constructors. If you have many virtual functions, you end up with many pointers, which are organized into a table... the v-table. Each class will have its own unique v-table.

When a child class is constructed, the parent class's constructor is called before the child class's constructor is called. Each classes constructor will put the addresses of all the virtual functions it has into the v-table. In our example, when Foo is instantiated, Foobar's constructor is called first. Foobar's constructor will place the memory location of Foobar.FuncA into the v-table. Once Foobar's constructor is done, Foo's constructor will execute, placing Foo.FuncA into the table.

In FoobarFunc the line fb->FuncA(), actually replaced by an address to the v-table. When that line is executed, the computer will go to that location in the v-table, fetch the address of the function, and then jump to that location in memory. Because of how the constructors setup the v-table, you end up calling the correct function.

If you look at the example, you'll notice I have included FuncB which is not declared virtual to highlight the difference between virtual and nonvirtual functions. In FoobarFunc, the parameter is Foobar. Because FuncB is not virtual, there is no entry for FuncB in the v-table. The compiler/linker will hardcode the address in the binary and cause the program to always execute Foobar.FuncB no matter what gets passed in as the parameter. No polymorphism. In FooFunc, the parameter is Foo. Foo.FuncB will always execute in that function. Again, no polymorphism.

class-leading performance / top-tier performance / advanced performance

#include<stdio.h>

void main()

{

FILE *fp;

char name[20],ch;

char *roll;

fp=fopen("specifies file path","w");

if(fp!=NULL)

{

do{

printf("input roll_no");

gets(roll);

printf("\ninput student name");

gets(name);

fputs(roll,fp);

fputs("\t",fp);

fputs(name,fp);

fputs("\n",fp);

printf("you want to continue y/n");

ch=getch();

}while(ch=='y');

}

}

#include
#include

using std::cout;
using std::cin;
using std::endl;
using std::string;

int main()
{
string myNumber = "";
cout << endl << "Enter a number: ";
cin >> myNumber;

cout << endl << "You number was saved as string: "" << myNumber << """ << endl;

system("PAUSE");
return 0;
}

A Looping Structure

#include<iostream.h>

main()

{

int C,D,E;

cout<<"Number at location C=";

cin>>C;

cout<<"Number at location D=";

cin>>D;

E=C;

C=D;

D=E;

cout<<"New Number At Location C="<<C<<endl;

cout<<"New Number At Location D="<<D<<endl;

}

With a negative discriminant, the two solutions are imaginary.

yes

Well, if you are referring to booking for a flight or travel via airplane then you will need a valid ID, for international you need your passport then basic personal information for the online forms and then a credit card info for the payment. You can also pay over the counter using the booking confirmation code.

By using that one thing.

Arrays are datastructures which use continguous memory , and data allocation happens at compilation, so it is faster in execution . similarly in stacks and queue. The memory usage is lesser compared to other data type as it does not require pointers. It is fixed memory allocation so cannot be used until u are sure about the size of the data. Moreover if u do a wrong estimation about the size of data required then can lead to memory shortage or if declared more then it leads to Memory wastage.Searching can be easy in arrays,stacks and queues,however insertion and deletion is quite difficult in these data structures. Searching can also be easy in binary trees as data is sorted and stored . Accessing data is faster here as it allows random access to data.In arrays u can use only one type of data.

Linked list, graphs, trees are non continguous memory ,i.e they use heap memory. Here data is allocated in run time so execution may take more time compared to above, As data is allocated in run time u will also need memory allocator to keep track of available memory and allocate them. Memory usage is also more as we each node has to have the additional info about the address of the next data.so its time consuming compared to above. As the size of data is not fixed can be used in programs where we are not aware of size of data before execution. Here data is sequencially accessed which means accessing data is slow .to access 30th element u will have to traverse through 30 elements. However data insertion and deletion is faster all that we need to do is change address of the pointer. There is no memory wastage here as memory is not stored for this but its more flexible. Here u can store different data types unlike arrays. -

Shruthi.B.O

an arrow with a paint brush

It is an initialisation. You cannot assign values to a dynamic array until it has been initialised. Static arrays can be initialised at compile time. They can also be assigned at compile time.

void main()

{

// Compile time:

// =========

// Initialise a static array.

int arr1[10];

// Initialise and assign a static array.

int arr2[10] = {0,1,2,3,4,5,6,7,8,9};

// Runtime:

// ======

// Dynamic array (size unknown, no memory allocated)

int* pArr[];

// Initialise (size known, allocate memory, 40 bytes):

pArr = ( int* ) malloc( 10 * sizeof( int ));

// Assign (set values of elements):

int x;

for(x=0;x<10;++x)

pArr[x] = x;

// Uninitialise (release memory).

free( pArr );

return( 0 );

}

It is 'pre-test' and 'post-test'.

Yes.