Merge branch 'master' into master

Author: Bhrigu Kansra

Data Structures/DoubleLinkedList.py

@@ -0,0 +1,131 @@
+#Defined Node
+class ListNode:  
+    def __init__(self, data):
+        "constructor class to initiate this object"
+
+        # store data
+        self.data = data
+
+        # store reference (next item)
+        self.next = None
+
+        # store reference (previous item)
+        self.previous = None
+        return
+
+    def has_value(self, value):
+        "method to compare the value with the node data"
+        if self.data == value:
+            return True
+        else:
+            return False
+            
+ #Doubly Linked List
+ 
+ class DoubleLinkedList:  
+    def __init__(self):
+        "constructor to initiate this object"
+
+        self.head = None
+        self.tail = None
+        return
+
+    def list_length(self):
+        "returns the number of list items"
+
+        count = 0
+        current_node = self.head
+
+        while current_node is not None:
+            # increase counter by one
+            count = count + 1
+
+            # jump to the linked node
+            current_node = current_node.next
+
+        return count
+
+    def output_list(self):
+        "outputs the list (the value of the node, actually)"
+        current_node = self.head
+
+        while current_node is not None:
+            print(current_node.data)
+
+            
+            current_node = current_node.next
+
+        return
+
+    def unordered_search (self, value):
+        "search the linked list for the node that has this value"
+
+        
+        current_node = self.head
+
+        
+        node_id = 1
+
+        
+        results = []
+
+        while current_node is not None:
+            if current_node.has_value(value):
+                results.append(node_id)
+
+            
+            current_node = current_node.next
+            node_id = node_id + 1
+
+        return results
+        
+        #Adding nodes
+        
+def add_list_item(self, item):
+        "add an item at the end of the list"
+
+        if isinstance(item, ListNode):
+            if self.head is None:
+                self.head = item
+                item.previous = None
+                item.next = None
+                self.tail = item
+            else:
+                self.tail.next = item
+                item.previous = self.tail
+                self.tail = item
+
+        return
+        
+        #Removing Nodes
+       
+ def remove_list_item_by_id(self, item_id):
+        "remove the list item with the item id"
+
+        current_id = 1
+        current_node = self.head
+
+        while current_node is not None:
+            previous_node = current_node.previous
+            next_node = current_node.next
+
+            if current_id == item_id:
+                # if this is the first node (head)
+                if previous_node is not None:
+                    previous_node.next = next_node
+                    if next_node is not None:
+                        next_node.previous = previous_node
+                else:
+                    self.head = next_node
+                    if next_node is not None:
+                        next_node.previous = None
+                # we don't have to look any further
+                return
+
+            # needed for the next iteration
+            current_node = next_node
+            current_id = current_id + 1
+
+        return
+        
+        

Data Structures/StackUsingArray.h

@@ -0,0 +1,61 @@
+template <typename T>
+class Stack {
+    T *data;
+    int nextIndex;
+    int totalSize;
+
+    public :
+
+    Stack(int size) {
+        data = new T[size];
+        nextIndex = 0;
+        totalSize = size;
+    }
+
+    ~Stack() {
+        delete [] data;
+    }
+
+    int getSize() {
+        return nextIndex;
+    }
+    
+    bool isEmpty() {
+        if(nextIndex == 0) 
+            return true;
+        else
+            return false;
+    }
+
+    T top() {
+        if(isEmpty()) {
+            cout << "Stack empty ! " << endl;
+            return -1;
+        }
+        return data[nextIndex - 1];
+    }
+
+    void push(T element) {
+        if(totalSize == nextIndex) {
+            T *temp = new T[2 * totalSize];
+            for(int i = 0; i < totalSize; i++) {
+                temp[i] = data[i];
+            }
+            totalSize *= 2;
+            delete [] data;
+            data = temp;
+        }
+        data[nextIndex] = element;
+        nextIndex++;
+    }
+
+    T pop() {
+        if(isEmpty()) {
+            cout << "Stack empty ! " << endl;
+            return -1;
+        }
+        nextIndex--;
+        return data[nextIndex];
+    }
+
+};

contributors.md

@@ -8,4 +8,7 @@
 6. [Ujjval Patel](https://github.com/Ujjval-Patel)
 7. [Shaguna Awasthi](https://github.com/Shagunaawasthi)
 8. [Joy Banerjee](https://github.com/joybanerjee08)
-9. [Ananya Keshari](https://github.com/ana301)
+9. [Nikhil Arora](https://github.com/nikhilarora068)
+10. [Ambika](https://github.com/Ambika55)
+11. [Kartikey Tripathi](https://github.com/kartikeytripathi)
+12. [Ananya Keshari](https://github.com/ana301)

knight-tour.cpp

@@ -0,0 +1,59 @@
+#include<bits/stdc++.h>
+# define n 8
+using namespace std;
+bool issafe(int x,int y,int sol[n][n])
+{
+    return (x<n && x>=0 && y<n && y>=0 && sol[x][y]==-1);
+
+}
+bool solve(int x,int y, int mov, int sol[n][n], int xmov[n], int ymov[n])
+{
+    int k,xnext,ynext;
+
+    if(mov == n*n)
+        return true;
+
+    for(k=0;k<8;k++)
+    {
+        xnext=x+xmov[k];
+        ynext=y+ymov[k];
+
+        if(issafe(xnext,ynext,sol))
+            {
+                sol[xnext][ynext]=mov;
+
+                if(solve(xnext,ynext,mov+1,sol,xmov,ymov)==true)
+                    return true;
+                else
+                    sol[xnext][ynext]=-1;
+            }
+    }
+    return false;
+}
+int main()
+{
+    //initialize();
+
+    int sol[n][n];
+    int i,j;
+    for(i=0;i<n;i++)
+        for(j=0;j<n;j++)
+            sol[i][j]=-1;
+
+    int xmov[8] = {  2, 1, -1, -2, -2, -1,  1,  2 };
+    int ymov[8] = {  1, 2,  2,  1, -1, -2, -2, -1 };
+    sol[0][0]=0;
+
+    bool flag=solve(0,0,1,sol,xmov,ymov);
+    if(flag==false)
+        cout<<"solution doesnot exist \n";
+    else
+    {
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<n;j++)
+                cout<<sol[i][j]<<"  ";
+            cout<<"\n";
+        }
+    }
+}

n-queen.cpp

@@ -0,0 +1,58 @@
+#include<bits/stdc++.h>
+#define n 4
+using namespace std;
+bool issafe(int board[n][n], int row, int col)
+{
+    int i,j;
+    for(i=0;i<n;i++)
+        if(board[row][i])
+            return false;
+    for(i=row,j=col;i>=0 && j>=0;i--,j--)
+        if(board[i][j])
+            return false;
+    for(i=row,j=col;i<n && j>=0; i++,j--)
+        if(board[i][j])
+            return false;
+
+    return true;
+}
+bool solve(int board[n][n], int col)
+{
+    if(col>=n)
+        return true;
+    int i;
+    for(i=0;i<n;i++)
+    {
+        if(issafe(board, i ,col))
+            {
+                board[i][col]=1;
+
+                if(solve(board, col+1))
+                    return true;
+
+                board[i][col]=0;
+            }
+    }
+    return false;
+}
+int main()
+{
+    int board[n][n]={{0,0,0,0},
+                    {0,0,0,0},
+                    {0,0,0,0},
+                    {0,0,0,0}};
+    bool flag;
+    int i,j;
+    flag=solve(board,0);
+    if(flag==false)
+        cout<<"solution doesnot exist \n";
+    else
+    {
+        for(i=0;i<n;i++)
+        {
+            for(j=0;j<n;j++)
+                cout<<board[i][j]<<" ";
+        cout<<"\n";
+        }
+    }
+}