DBMS

Que :- Discuss concepts of  RDBMS with Codde Rule ?

                                   or

                    Discuss 12th Rule of Coddes?

Any RDBMS package is bashed on  coddes rule. Dr E.F codde is a mathematician  that provide 12th rule of Relational Data Model. These are follow :-

1)  Information Rule 

2)  Granted access Rule

3) Systematic Treatment of Null value

4) Active Online Catalog Based on relational principle 

5) View  Updating Rule 

6) Integrity Independence Rule 

7) Relational Manipulation Rule

8) Physical Data In dependency  

9) Logical Data in dependency

10) High Level Insert, Delete and update

11) Non-sub version Rule

12) Distribution Independence

1)  Information Rule :-

        
 This rule is about the storing the information  Dr. E.F codde suggest that information storage in relational data model in the form of relation where relation as treated as table with in intersection of row and column where each row represent one record and where each column represent field create a record it create database.

                                                                                   If we want to store information about any course then we have to create  a relation with required number of attributes (Field) in any RDBMS package.

2) Granted access Rule:-

       
 This rule about the accessing of data in each relation Dr. E.F Codde suggest that every piece  of information in a relation is uniquely access with any ambiguity (with out any confusion) after getting this rule all RDBMS package suggest a concept of primary key it is that field in table that never be duplicate and that never be NULL.using this field we can access all other field within a relation uniquely  there is only one primary key in each relation.

              This concept is given functional dependency where another attribute of a relation is dependent on primary key of that relation.

                                                                           

3) Systematic Treatment of Null value :-

        
 During collecting information about entity many of the information is missing for ex:-if we collect information about any employee i,e newly join in an organisation  then all his information feed in employee relation but till now his department is  not decided now question is that what is the value of Department field,some people suggest about this situation that is if field type is character put space,if field type is numeric  put zero (0) but Dr. E.F codde suggest that put NULL in missing information .

4) Active Online Catalog Based on relational principle  :-

      Dr. E.F codde suggest that there must be a provision to store data about data means if we want to create any data in relation database like tupple , processor, view etc then all RDBMS package store information about this object i.e on which date is create  and time is created whose reader of that object on which time which is created. storing data about data should be in the form of relation it should be or created automatically.




5) View  Updating Rule  :-

This rule  about the user view if we create any view for any user then it should be up datable.each user required different amount of data for this purpose codde`s suggest that RDBMS package should has a provision to create a view for different user.

6) Integrity Independence Rule  :-

This rule about the integrity about of database if any integrity (rule) is impose on any attributes then the maintains of this integrity  should be independence from data.

7) Relational Manipulation Rule :-

In all RDBMS package data are store in the form of relation then DR. E.F codde  suggest there  should be a language that perform operation on relation. Relational algebra and relational calculus is prosigeral RDBMS package that has tools to perform operation on relation there are the some basic operation perform by relational algebra 
i.e as follow :-
   
select, projection, Division, Cartesian product, join, set different, union, intersection etc.



8) Physical Data Independency  :-

This rule about the data independency it suggest that physical data of a database should independence from logical data. 


9) Logical Data in dependency :-

This rule about the maintaining of logical data independence from the external data.


10) High Level Insert, Delete and update :-

This rule is about the interface  to performing operation with any RDBMS generally we perform three operations i.e insert,delete and update.this three operation can be perfome sucessfully.


11) Non-sub version Rule :-

This rule about the low level language for handing the database. if it is used then relational principle should not be violate (break down).

 12) Distribution Independence :-

This rule about the data distribution  if more than one user perform operation on  single database then they are unaware from data. 

Stack vs Queue

Stack vs Queue 

Stack is an ordered list in which insertion and deletion of list items can be done only in one end called the top. Due to this reason, stack is considered as a Last in First out (LIFO) data structure. Queue is also an ordered list in which insertion of list items are done in one end called the rear, and the deletion of items are done in the other end called the front. This insertion and deletion mechanism makes the queue a First in First out (FIFO) data structure.

What is Stack?

As mentioned earlier, stack is a data structure in which elements are added and removed from only one end called the top. Stacks allow only two fundamental operations called push and pop. The push operation adds a new element to the top of the stack. The pop operation removes an element from the top of the stack. If the stack is already full, when a push operation is performed, it is considered as a stack overflow. If a pop operation is performed on an already empty stack, it is considered as a stack underflow. Due to the small number of operations that could be performed on a stack, it is considered as a restricted data structure. Additionally, according to the way that the push and pop operations are defined, it is clear that elements that were added last in to the stack go out of the stack first. Therefore stack is considered as a LIFO data structure.

What is Queue?

In a queue, elements are added from the rear of the queue and removed from the front of the queue. Since the elements that are added first will be removed from the queue first, it maintains the FIFO order. Due to this order of adding and removing elements, queue represents the idea of a checkout line. General operations supported by a queue are en-queue and de-queue operations. En-queue operation will add an element at the rear of the queue, while the de-queue operation removes an element from the front of the queue. In general, queues do not have a limit on the number of elements that can be added to the queue besides the memory constraints.

What is the difference between Stack and Queue?

Even though both the stacks and queues are kinds of ordered lists, they have some important differences. In stacks, adding or deleting items can be done only from one end called the top, while in queues adding items is done from one end called the rear and deleting items is done from the other end called the front. In a stack, items that are added last to the stack will be removed first from the stack. Therefore stack is considered as a LIFO data structure. In queues, items that are added first will be removed from the queue first. Therefore queue is considered as a FIFO data structure.

What are the Differences between stack and queue?

• A stack is generally First In, Last Out,  and a queue is First In First Out.
• Data or elements can be added or removed only at one end in stack and in a queue insertion at the rear and deletion from the front.
• The basic operation of stack are 'push' and 'pop', on other hand of queue are 'enque' and 'dequeue'.
•  STACK = LIFO Last In First Out .  
•  Stack is a data dtructure in which addition of new element or deletion of an existing element pop.
•  Stack is also called last-in-first-out list.  

                                  

•  QUEUES = FIFO First In First Out .
• Queues is a linear data structure that permits insertion of new element at one end and deletion of element at the other end. 

What Is a Data Structure?

A data structure is a particular way of storing and organising data in computer so that it can be used efficiently. Data structures make it easy to manage huge amounts of data for instance databases and internet indexing services. Data structures are used in almost every program or software.

Advantage and Disadvantage of singly Linked list and Doubly Linked list

Que-    Advantage and Disadvantage of singly Linked list and Doubly Linked list


SINGLY LINKED LIST
*ADVANTAGE :-
1) Insertions and Deletions can be done easily.
2) It does not need movement of elements for insertion and deletion.
3) It space is not wasted as we can get space according to our requirements.
4) Its size is not fixed.
5) It can be extended or reduced according to requirements.
6) Elements may or may not be stored in consecutive memory available,even then we can store the data in computer.
7) It is less expensive.


*DISADVANTAGE :-
1) It requires more space as pointers  are also stored  with information.
2) Different amount of time is required to access each element.
3) If we have to go to a particular element then we have to go through all those elements that come before that element.
4) we can not traverse it from last & only from the beginning.
5) It is not easy to sort the elements stored in the linear linked list.



-----------------------------------------------------------------------------------------------------------

DOUBLY LINKED LIST

*ADVANTAGE :-

1) We can traverse in both direction i.e from starting to end & as well as from end to starting.
2) It is easy to reverse the linked list.
3) If we are at a node,the we can go at any node.But in linked list,it is not possible to reach the previous node.



*DISADVANTAGE :-

1) It requires more space per space per node because extra field is required for pointer to previous node.
20 Insertion and Deletion take more time than linear linked list because more pointer operations are required than linear linked list. 

Recursive algorithms

What is an recursive algorithm?

A recursive algorithm calls itself which usually passes the return value as a parameter to the algorithm again. This parameter is the input while the return value is the output.

What is an recursive algorithm?

Recursive algorithm is a method of simplification that divides the problem into sub-problems of the same nature. The result of one recursion is the input for the next recursion. The repletion is in the self-similar fashion. The algorithm calls itself with smaller input values and obtains the results by simply performing the operations on these smaller values. Generation of factorial, Fibonacci number series are the examples of recursive algorithms.

Que- write a program to construct B.S.T or it`s traversing algorithm in recursive way.

              #include<stdio.h>

              #include<conio.h>

              #include<process.h>

          

               struct BST*LC;

               int data;

               struct BST*RC;

               struct BST*start=NULL;

               void create( );

               void insert (int d);

               void inorder (struct BST*tmp);

               void preorder(struct BST*tmp);

               void postorder (struct BST*tmp);

               void main( )

               {

               int ch;

               while(1)

               {

               printf("press 1 for create\n");

               printf("press 2 for insert\n");

               printf("press 3 for inorder traversing\n");

               printf("press 4 for preorder traversing\n");

               printf("press 5 for postorder traversing\n");

               printf("press 6 for exit\n");

               printf("enter your choice\n")

               scanf("%d",&ch);

               switch(ch)

               {

               case 1:

               create();

               break;

               case 2:

               printf("enter data\n");

               scanf("%d",&d);

               insert(d);

               break;

               case 3:

              inorder(start);

              getch();

              break;

              case 4:

             preorder(start);

             getch();

             break;

             case 5:

            postorder(start);

            getch();

            break;

void creat()

{

struct BST*tmp;

if(start==NULL)

{

tmp=(struct BST*)malloc(sizeof(struct BST));

tmp-->LC=tmp-->RC=NULL;

printf("enter value\n");

scanf("%d",&tmp-->data);

start=tmp;

}

}

void insert(int d)

{

struct BST* tmp,*tmp1;

tmp=start;

while(1)

{

if(d==tmp-->data)

{

printf("duplicate not allow\n");

return;

}

if(d>tmp-->data)

{

if(tmp-->RC!= NULL)

{

tmp=tmp-->RC;

}

else

{

tmp1=(struct BST*)malloc(sizeof(struct BST));

tmp-->RC=tmp;

tmp-->RC=tmp1-->LC=NULL;

tmp-->data=d;

return;

}

else

{

if(tmp-->LC!=NULL)

{

tmp=tmp-->LC;

}

else

{

tmp1=(struct BST*)malloc(sizeof(struct BST));

tmp1-->LC=tmp1-->RC=NULL;

tmp1-->data=d;

tmp-->LC=tmp;

return;

}

}

}

}