NQueen problem implementation

 /***********************************************************
* You can use all the programs on  www.engineercse.blogspot.com
* for personal and learning purposes. For permissions to use the
* programs for commercial purposes,
* contact azam.ruet10@gmail.com
* To find more C programs, do visit www.engineercse.blogspot.com
* and browse!
*
*                            Coding is poetry!!!
***********************************************************/
#include
#include
#include
void print_solution(int n,int x[]){
      int i,j;
      char c[100][100];
   for(i=1;i<=n;i++){
   for(j=1;j<=n;j++){
          c[i][j]='X';}
        }
   for(i=1;i<=n;i++){
          c[i][x[i]] ='Q';
           }
           for(i=1;i<=n;i++){
           for(j=1;j<=n;j++){
                printf("%c\t",c[i][j]);
                      }
                  printf("\n");
                  }
    }

int place(int x[],int n){

   int i;
   for(i=1;i        if((x[i] == x[n]) || (i-x[i] == n-x[n]) || (i+x[i]==n +x[n])){
       return 0;
         }
           }
    return 1;
       }

void nqueens(int n){
      int x[100],count=0,k=1;

         x[k] = 0;

        while(k != 0){
          x[k] +=1;
          while((x[k] <= n) && ( !place(x,k))){
              x[k] +=1;
                 }
            if(x[k] <= n){
              if(k == n){
                  count++;
                     printf("solution:%d\n",count);
                      print_solution(n,x);
                        }
               else{
                     k++;
                     x[k]=0;
                     }
                }
             else{
                 k--;
                 }

}
}
int main()
{
int n;
printf("enter number of queens\n");
scanf("%d",&n);

nqueens(n);
getch();
return 0;
}

To get more C Program go here
To get more DFS algorithmic code click

Data Structures

Prims Algorithm

Learn C Programming

Implementing BFS(Breath's First Search) using C++

/***********************************************************
* You can use all the programs on  www.engineercse.blogspot.comprogrammers' blog
* for personal and learning purposes. For permissions to use the
* programs for commercial purposes,
* contact azam.ruet10@gmail.com
* To find more C programs, do visit www.engineercse.blogspot.com
* and browse!
*
*                            Coding is poetry!!!
***********************************************************/

#include
#include
#include
#include
#define inf 1000000
#define clear(x,a) memeset(x,a,sizeof(x))
using namespace std;

bool adj[100][100];
int n, white=1, gray=2, black=3, color[100],d[100],edge, node[100],parent[100],source;
queue Q;
void bfs();

int main()
{
   int start,end;
   cout<<"vertices::";
   cin>>n;
   cout<<"\nedges::";
   for(int i=1;i<=n;i++)
     color[i]=white,d[i]=inf,parent[i]=-1;
     cin>>edge;
     cout<<"\nstart and ending vertex::";
     while(edge--)
     cin>>start>>end,adj[start][end]=true,adj[end][start]=true;
     cout<<"\nsource vertex:";
     cin>>source;
     bfs();
     for(int i=1;i<=n;i++)
     cout<     return 0;
}

void bfs()
{
    d[source]=0;
    Q.push(source);
    color[source]=gray;
    while(!Q.empty())
    {
        int s=Q.front();
        for(int i=0;i<=n;++i)
        {
            if(adj[s][i]and color[i]==white)
            Q.push(i), color[i]=gray, d[i]=d[s]+1, parent[i]=s;
        }
        Q.pop();
    }
}

To get more C Program go here
To get more DFS algorithmic code click

Insertion, Deletion & searching operation in BST using Code::Blocks

#include
  #include

  struct treeNode {
        int data;
        struct treeNode *left, *right;
  };

  struct treeNode *root = NULL;

  /* create a new node with the given data */
  struct treeNode* createNode(int data) {
        struct treeNode *newNode;
        newNode = (struct treeNode *) malloc(sizeof (struct treeNode));
        newNode->data = data;
        newNode->left = NULL;
        newNode->right = NULL;
        return(newNode);
  }

  /* insertion in binary search tree */
  void insertion(struct treeNode **node, int data) {
        if (*node == NULL) {
                *node = createNode(data);
        } else if (data < (*node)->data) {
                insertion(&(*node)->left, data);
        } else if (data > (*node)->data) {
                insertion(&(*node)->right, data);
        }
  }


  /* deletion in binary search tree */
  void deletion(struct treeNode **node, struct treeNode **parent, int data) {
        struct treeNode *tmpNode, *tmpParent;
        if (*node == NULL)
                return;
        if ((*node)->data == data) {
                /* deleting the leaf node */
                if (!(*node)->left && !(*node)->right) {
                        if (parent) {
                                /* delete leaf node */
                                if ((*parent)->left == *node)
                                        (*parent)->left = NULL;
                                else
                                        (*parent)->right = NULL;
                                free(*node);
                        } else {
                                /* delete root node with no children */
                                free(*node);
                        }
                /* deleting node with one child */
                } else if (!(*node)->right && (*node)->left) {
                        /* deleting node with left child alone */
                        tmpNode = *node;
                        (*parent)->right = (*node)->left;
                        free(tmpNode);
                        *node = (*parent)->right;
                } else if ((*node)->right && !(*node)->left) {
                        /* deleting node with right child alone */
                        tmpNode = *node;
                        (*parent)->left = (*node)->right;
                        free(tmpNode);
                        (*node) = (*parent)->left;
                } else if (!(*node)->right->left) {
                        /*
                         * deleting a node whose right child
                         * is the smallest node in the right
                         * subtree for the node to be deleted.
                         */

                        tmpNode = *node;
                        (*node)->right->left = (*node)->left;
                        (*parent)->left = (*node)->right;
                        free(tmpNode);
                        *node = (*parent)->left;
                } else {
                        /*
                         * Deleting a node with two children.
                         * First, find the smallest node in
                         * the right subtree.  Replace the
                         * smallest node with the node to be
                         * deleted. Then, do proper connections
                         * for the children of replaced node.
                         */
                        tmpNode = (*node)->right;
                        while (tmpNode->left) {
                                tmpParent = tmpNode;
                                tmpNode = tmpNode->left;
                        }
                        tmpParent->left = tmpNode->right;
                        tmpNode->left = (*node)->left;
                        tmpNode->right =(*node)->right;
                        free(*node);
                        *node = tmpNode;
                }
        } else if (data < (*node)->data) {
                /* traverse towards left subtree */
                deletion(&(*node)->left, node, data);
        } else if (data > (*node)->data) {
                /* traversing towards right subtree */
                deletion(&(*node)->right, node, data);
        }
  }

  /* search the given element in binary search tree */
  void findElement(struct treeNode *node, int data) {
        if (!node)
                return;
        else if (data < node->data) {
                findElement(node->left, data);
        } else if (data > node->data) {
                findElement(node->right, data);
        } else
                printf("data found: %d\n", node->data);
        return;

  }

  void traverse(struct treeNode *node) {
        if (node != NULL) {
                traverse(node->left);
                printf("%3d", node->data);
                traverse(node->right);
        }
        return;
  }

  int main() {
        int data, ch;
        while (1) {
                printf("1. Insertion in Binary Search Tree\n");
                printf("2. Deletion in Binary Search Tree\n");
                printf("3. Search Element in Binary Search Tree\n");
                printf("4. Inorder traversal\n5. Exit\n");
                printf("Enter your choice:");
                scanf("%d", &ch);
                switch (ch) {
                        case 1:
                                while (1) {
                                printf("Enter your data:");
                                scanf("%d", &data);
                                insertion(&root, data);
                                printf("Continue Insertion(0/1):");
                                scanf("%d", &ch);
                                if (!ch)
                                        break;
                                }
                                break;
                        case 2:
                                printf("Enter your data:");
                                scanf("%d", &data);
                                deletion(&root, NULL, data);
                                break;
                        case 3:
                                printf("Enter value for data:");
                                scanf("%d", &data);
                                findElement(root, data);
                                break;
                        case 4:
                                printf("Inorder Traversal:\n");
                                traverse(root);
                                printf("\n");
                                break;
                        case 5:
                                exit(0);
                        default:
                                printf("u've entered wrong option\n");
                                break;
                }
        }
        return 0;

  }

Program of traversing a binary tree in inorder, preorder and postorder in C++ Programming

#include
#include
#include
struct btree
{
    struct btree *left;
    struct btree *right;
    int no;
};
void postorder(struct btree *trav);
void inorder(struct btree *trav);
void preorder(struct btree *trav);
struct btree * create(struct btree *trav);
main()
{
    struct btree *root=NULL;
    char c;
    clrscr();
    while(1)
    {
        root=create(root);
        cout<<"Do you want to continue : ";
        cin>>c;
        if(c=='n' ||c=='N')
            break;
    }
    cout<"Inoder is    : "

;inorder(root); cout<"Preorder is : ";preorder(root); cout<"Postorder is : ";postorder(root); getch(); } struct btree * create(struct btree *trav) { if(trav==NULL) { trav=new btree; trav->right=NULL; trav->left=NULL; cout<<"Enter the no : "; cin>>trav->no; return(trav); } char choice; cout<<"Enter the left or right child : "; cin>>choice; if(choice == 'r' || choice == 'R') { trav->right=create(trav->right); } if(choice=='l' || choice=='L') { trav->left=create(trav->left); } return(trav); } void inorder(struct btree *trav) { if(trav==NULL) return ; inorder(trav->left); cout<<" "<no; inorder(trav->right); } void preorder(struct btree *trav) { if(trav==NULL) return; cout<<" "<no; preorder(trav->left); preorder(trav->right); } void postorder(struct btree *trav) { if(trav==NULL) return; postorder(trav->left); postorder(trav->right); cout<<" "<no; }

Implementation of Dijkstra's algorithm(Finding shortest path) using C language

C Program to implement Dijkstra's algorithm. Dijkstra's Algorithm finds the shortest path with the lower cost in a Graph. Dijkstra's Algorithm solves the Single Source Shortest Path problem for a Graph. It is a Greedy algorithm and similar to Prim's algorithm. Read more about C Programming Language .

/***********************************************************

* You can use all the programs on  www.engineercse.blogspot.com

* for personal and learning purposes. For permissions to use the

* programs for commercial purposes,

* contact sm.rumi18@gmail.com

* To find more C programs, do visit www.engineercse.blogspot.com

* and browse!

*

*                       Coding is Poetry !!!

***********************************************************/

#include "stdio.h"

#include "conio.h"

#define infinity 999

void dij(int n,int v,int cost[10][10],int dist[])

{

 int i,u,count,w,flag[10],min;

 for(i=1;i<=n;i++)

  flag[i]=0,dist[i]=cost[v][i];

 count=2;

 while(count<=n)

 {

  min=99;

  for(w=1;w<=n;w++)

   if(dist[w]

    min=dist[w],u=w;

  flag[u]=1;

  count++;

  for(w=1;w<=n;w++)

   if((dist[u]+cost[u][w]

    dist[w]=dist[u]+cost[u][w];

 }

}

void main()

{

 int n,v,i,j,cost[10][10],dist[10];

 clrscr();

 printf("\n Enter the number of nodes:");

 scanf("%d",&n);

 printf("\n Enter the cost matrix:\n");

 for(i=1;i<=n;i++)

  for(j=1;j<=n;j++)

  {

   scanf("%d",&cost[i][j]);

   if(cost[i][j]==0)

    cost[i][j]=infinity;

  }

 printf("\n Enter the source matrix:");

 scanf("%d",&v);

 dij(n,v,cost,dist);

 printf("\n Shortest path:\n");

 for(i=1;i<=n;i++)

  if(i!=v)

   printf("%d->%d,cost=%d\n",v,i,dist[i]);

 getch();

}

Read more Similar C Programs

Data Structures

Learn C Programming

To get regular updates on new C programs, Algorithm problem solution,

Implementation of Kruskal's Algorithm using C language

C Program to implement Dijkstra's algorithm. Dijkstra's Algorithm finds the shortest path with the lower cost in a Graph. Dijkstra's Algorithm solves the Single Source Shortest Path problem for a Graph. It is a Greedy algorithm and similar to Prim's algorithm. Read more about C Programming Language .

/***********************************************************

* You can use all the programs on  www.engineercse.blogspot.com

* for personal and learning purposes. For permissions to use the

* programs for commercial purposes,

* contact sm.rumi18@gmail.com

* To find more C programs, do visit www.engineercse.blogspot.com

* and browse!

*

*                       Coding fun

***********************************************************/

#include "stdio.h"

#include "conio.h"

#define infinity 999

void dij(int n,int v,int cost[10][10],int dist[])

{

 int i,u,count,w,flag[10],min;

 for(i=1;i<=n;i++)

  flag[i]=0,dist[i]=cost[v][i];

 count=2;

 while(count<=n)

 {

  min=99;

  for(w=1;w<=n;w++)

   if(dist[w]

    min=dist[w],u=w;

  flag[u]=1;

  count++;

  for(w=1;w<=n;w++)

   if((dist[u]+cost[u][w]

    dist[w]=dist[u]+cost[u][w];

 }

}

void main()

{

 int n,v,i,j,cost[10][10],dist[10];

 clrscr();

 printf("\n Enter the number of nodes:");

 scanf("%d",&n);

 printf("\n Enter the cost matrix:\n");

 for(i=1;i<=n;i++)

  for(j=1;j<=n;j++)

  {

   scanf("%d",&cost[i][j]);

   if(cost[i][j]==0)

    cost[i][j]=infinity;

  }

 printf("\n Enter the source matrix:");

 scanf("%d",&v);

 dij(n,v,cost,dist);

 printf("\n Shortest path:\n");

 for(i=1;i<=n;i++)

  if(i!=v)

   printf("%d->%d,cost=%d\n",v,i,dist[i]);

 getch();

}

Read more Similar C Programs

Data Structures

Prims Algorithm

Learn C Programming