DOMAIN NAME SYSTEM

Domain Name System Architecture

The Domain name system comprises of Domain Names, Domain Name Space, Name Server that have been described below:

Domain Names:

Domain Name is a symbolic string associated with an IP address. There are several domain names available; some of them are generic such as com, edu, gov, net etc, while some country level domain names such as au, in, za, us etc.

The following table shows the Generic Top-Level Domain names:

Domain Name	Meaning
Com	Commercial business
Edu	Education
Gov	U.S. government agency
Int	International entity
Mil	U.S. military
Net	Networking organization
Org	Non profit organization

The following table shows the Country top-level domain names:

Domain Name	Meaning
Au	Australia
In	India
Cl	Chile
Fr	France
Us	United States
Za	South Africa
Uk	United Kingdom
Jp	Japan
Es	Spain
De	Germany
Ca	Canada
Ee	Estonia
Hk	Hong Kong

Domain Name Space:

The domain name space refers a hierarchy in the internet naming structure. This hierarchy has multiple levels (from 0 to 127), with a root at the top. The following diagram shows the domain name space hierarchy:

In the above diagram each subtree represents a domain. Each domain can be partitioned into sub domains and these can be further partitioned and so on.

Name Server:

Name server contains the DNS database. This database comprises of various names and their corresponding IP addresses. Since it is not possible for a single server to maintain entire DNS database, therefore, the information is distributed among many DNS servers.

·        Hierarchy of server is same as hierarchy of names.

·        The entire name space is divided into the zones

Zones

Zone is collection of nodes (sub domains) under the main domain. The server maintains a database called zone file for every zone.

If the domain is not further divided into sub domains then domain and zone refers to the same thing.

The information about the nodes in the sub domain is stored in the servers at the lower levels however; the original server keeps reference to these lower levels of servers.

 

TYPES OF NAME SERVERS

Following are the three categories of Name Servers that manages the entire Domain Name System:

1.    Root Server

2.    Primary Server

3.    Secondary Server

ROOT SERVER

Root Server is the top level server which consists of the entire DNS tree. It does not contain the information about domains but delegates the authority to the other server

PRIMARY SERVERS

Primary Server stores a file about its zone. It has authority to create, maintain, and update the zone file.

SECONDARY SERVER

Secondary Server transfers complete information about a zone from another server which may be primary or secondary server. The secondary server does not have authority to create or update a zone file.

Priority Queue:

Priority Queue is more specialized data structure than Queue. Like ordinary queue, priority queue has same method but with a major difference. In Priority queue items are ordered by key value so that item with the lowest value of key is at front and item with the highest value of key is at rear or vice versa. So we're assigned priority to item based on its key value. Lower the value, higher the priority. Following are the principal methods of a Priority Queue.

Basic Operations:

insert / enqueue − add an item to the rear of the queue.

remove / dequeue − remove an item from the front of the queue.

Priority Queue Representation

We're going to implement Queue using array in this article. There is few more operations

supported by queue which are following.

Peek − get the element at front of the queue.

isFull − check if queue is full.

isEmpty − check if queue is empty.

Insert / Enqueue Operation

Whenever an element is inserted into queue, priority queue inserts the item according to its order.

Here we're assuming that data with high value has low priority.

void insert(int data)

{

int i = 0;

if(!isFull())

{

// if queue is em pty, insert the data

if(item Count == 0){

intArray[item Count++] = data;

}

Else

{

// start from the right end of the queue

for(i = item Count - 1; i >= 0; i-- )

{

// if data is larger, shift existing item to right end

if(data > intArray[i])

{

intArray[i+1] = intArray[i];

}else

{

break;

}

}

// insert the data

intArray[i+1] = data;

item Count++;

}

}

}

Remove / Dequeue Operation

Whenever an element is to be removed from queue, queue get the element using item count. Once element is removed. Item count is reduced by one.

int rem oveData()

{

return intArray[--item Count];

}

BINARY SEARCH TREE

A binary search tree (BST) is a tree in which all nodes follows the below mentioned properties −

• The left sub-tree of a node has key less than or equal to its parent node's key.
• The right sub-tree of a node has key greater than or equal to its parent node's key.

Thus, a binary search tree (BST) divides all its sub-trees into two segments; left sub-tree and right sub-tree and can be defined as −

left_subtree (keys)  ≤  node (key)  ≤  right_subtree (keys)

Representation

BST is a collection of nodes arranged in a way where they maintain BST properties. Each node has key and associated value. While searching, the desired key is compared to the keys in BST and if found, the associated value is retrieved.

An example of BST −

We observe that the root node key (27) has all less-valued keys on the left sub-tree and higher valued keys on the right sub-tree.

Basic Operations

Following are basic primary operations of a tree which are following.

• Search − search an element in a tree.
• Insert − insert an element in a tree.
• Delete – delete an element in a tree.
• Preorder Traversal − traverse a tree in a preorder manner.
• Inorder Traversal − traverse a tree in an inorder manner.
• Postorder Traversal − traverse a tree in a postorder manner.

Node

Define a node having some data, references to its left and right child nodes.

struct node {

   int data;  

   struct node *leftChild;

   struct node *rightChild;

};

Search Operation

Whenever an element is to be search. Start search from root node then if data is less than key value, search element in left subtree otherwise search element in right subtree.

Insert Operation

Whenever an element is to be inserted. First locate its proper location. Start search from root node then if data is less than key value, search empty location in left subtree and insert the data. Otherwise search empty location in right subtree and insert the data.

Delete Operation

In this, we can delete a element .

·        First we search the our required element.

·        Removal is also going to be search process.

·        The BST is un-balanced tree during deletion and insertion

#include<conio.h>
#include<stdlib.h>
#include<iostream.h>
struct node
{
  int info;
  struct node *left;
  struct node *right;
};
typedef struct node tree ;
tree *root=NULL;
class BIN
{
  int num;
  tree *p,*prev,*temp;
  public:
  void insert();
  void inorder(tree *);
  void postorder(tree *);
  void preorder(tree *);
  void display();
};
void BIN:: insert()
{
  p=new(tree);
  cout<<"\n Enter  number:";
  cin>>num;
  p->info=num;
  p->left=p->right=NULL;
  if(root==NULL)
  {
    root=p;
    return;
  }
  temp=root;
  while(temp!=NULL)
  {
    if(num>=temp->info)
    {
      prev=temp;
      temp=temp->right;
    }
    else
    {
      prev=temp;
      temp=temp->left;
    }
  }
  if(num>=prev->info)
    prev->right=p;
  else
    prev->left=p;
}
void BIN::preorder(tree *temp)
{
  if(temp!=NULL)
  {
    cout<<" "<<temp->info;
    preorder(temp->left);
    preorder(temp->right);
  }
}
void BIN:: inorder(tree *temp)
{
  if(temp!=NULL)
  {
    inorder(temp->left);
    cout<<" "<<temp->info;
    inorder(temp->right);
  }
}
void  BIN::postorder(tree *temp)
{
  if(temp!=NULL)
  {
    postorder(temp->left);
    postorder(temp->right);
    cout<<" "<<temp->info;
  }
}
void BIN:: display()
{
  if(root==NULL)
  {
    cout<<"\n ***EMPTY TREE**** \n";
    return;
  }
  cout<<"\n\n THE PREORDER DISPLAY IS:   ";
  preorder(root);
  cout<<"\n\n THE INORDER DISPLAY IS:   ";
  inorder(root);
  cout<<"\n\n THE POSTORDER DISPLAY IS:   ";
  postorder(root);
}
void main()
{
  BIN o;
  int ch=1;
  int count=0;
  clrscr();
  while(ch)
  {
    cout<<"\n***********MENU***********";
    cout<<"\n1:INSERT-IN-TREE\n2:DISPLAY\n3.QUIT\n";
    cout<<"\nEnter your choice:\n";
    cin>>ch;
    switch(ch)
    {
      case 1:clrscr();
         count++;
         o.insert();
         break;
      case 2:clrscr();
      cout<<"\n\n THE NUMBER OF NODES IN THE BST is "<< count;
      o.display();
      break;
      case 3:exit(0);
    }
  }
  getch();
}

C++ Program for Quick Sort

#include<iostream.h>

#include<conio.h>

int a[10],l,u,i,j;

void quick(int *,int,int);

void main()

{

clrscr();

cout <<"enter 10 elements";

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

cin >> a[i];

l=0;

u=9;

quick(a,l,u);

cout <<"sorted elements";

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

cout << a[i] << " ";

getch();

}

void quick(int a[],int l,int u)

{

   int p,temp;

   if(l<u)

   {

   p=a[l];

   i=l;

   j=u;

    while(i<j)

   {

      while(a[i] <= p && i<j )

                i++;

      while(a[j]>p && i<=j )

                  j--;

      if(i<=j)

      {

      temp=a[i];

      a[i]=a[j];

      a[j]=temp;}

  }

  temp=a[j];

  a[j]=a[l];

  a[l]=temp;

  cout <<"\n";

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

  cout <<a[i]<<" ";

  quick(a,l,j-1);

  quick(a,j+1,u); 

 }

}