<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[Topics tagged with cs301]]></title><description><![CDATA[A list of topics that have been tagged with cs301]]></description><link>https://community.secnto.com//tags/cs301</link><generator>RSS for Node</generator><lastBuildDate>Mon, 08 Jun 2026 20:47:31 GMT</lastBuildDate><atom:link href="https://community.secnto.com//tags/cs301.rss" rel="self" type="application/rss+xml"/><pubDate>Invalid Date</pubDate><ttl>60</ttl><item><title><![CDATA[CS301 Assignment 1 Solution and Discussion]]></title><description><![CDATA[Sample Output
A1 Sample Output.mp4
]]></description><link>https://community.secnto.com//topic/2231/cs301-assignment-1-solution-and-discussion</link><guid isPermaLink="true">https://community.secnto.com//topic/2231/cs301-assignment-1-solution-and-discussion</guid><dc:creator><![CDATA[zareen]]></dc:creator><pubDate>Invalid Date</pubDate></item><item><title><![CDATA[CS301 GDB 1 Solution and Discussion]]></title><description><![CDATA[@zaasmi said in CS301 GDB 1 Solution and Discussion:

From Stack and Queue data structures which data structure you will suggest using for entry to exit path finding module? Select a data structure and give comments in favour to justify your selection. Also mention why you are not selecting the other data structure?

I Would suggest Stack data structure over Queue. This is because in solving a maze problem, we need to explore all possible paths. Along with that, we also need to track the paths visited.
If we were to use Queue, then after finding an unsuccessful path, we’ll have to start again from the entry point as queue only supports deletion from the front (FIFO property). This would not be useful in our case, as we need to trace back the unsuccessful path until we find another way.
Using Stack, what we can do is, while moving into the maze, we can push the index of the last visited cell and when reached the end of the maze(not exit-point), just keep popping elements from the stack until the cell at stack Top has another way to move.
Using this approach (particularly stack), you can find the correct path in the shortest possible time.
]]></description><link>https://community.secnto.com//topic/2175/cs301-gdb-1-solution-and-discussion</link><guid isPermaLink="true">https://community.secnto.com//topic/2175/cs301-gdb-1-solution-and-discussion</guid><dc:creator><![CDATA[zaasmi]]></dc:creator><pubDate>Invalid Date</pubDate></item><item><title><![CDATA[The objective of this assignment is]]></title><description><![CDATA[@zareen said in The objective of this assignment is:

o	Binary Search trees

Binary Search Tree (BST) –
BST is a special type of binary tree in which left child of a node has value less than the parent and right child has value greater than parent. Consider the left skewed BST shown in Figure 2.
[image: SF9VGHV.png]
Searching: For searching element 1, we have to traverse all elements (in order 3, 2, 1). Therefore, searching in binary search tree has worst case complexity of O(n). In general, time complexity is O(h) where h is height of BST.
Insertion: For inserting element 0, it must be inserted as left child of 1. Therefore, we need to traverse all elements (in order 3, 2, 1) to insert 0 which has worst case complexity of O(n). In general, time complexity is O(h).
Deletion: For deletion of element 1, we have to traverse all elements to find 1 (in order 3, 2, 1). Therefore, deletion in binary tree has worst case complexity of O(n). In general, time complexity is O(h).
]]></description><link>https://community.secnto.com//topic/2156/the-objective-of-this-assignment-is</link><guid isPermaLink="true">https://community.secnto.com//topic/2156/the-objective-of-this-assignment-is</guid><dc:creator><![CDATA[zareen]]></dc:creator><pubDate>Invalid Date</pubDate></item><item><title><![CDATA[CS301 Assignment 3 Solution and Discussion]]></title><description><![CDATA[CS301-assignment-no3-Solution.docx
]]></description><link>https://community.secnto.com//topic/2155/cs301-assignment-3-solution-and-discussion</link><guid isPermaLink="true">https://community.secnto.com//topic/2155/cs301-assignment-3-solution-and-discussion</guid><dc:creator><![CDATA[zareen]]></dc:creator><pubDate>Invalid Date</pubDate></item><item><title><![CDATA[CS301 Assignment 2 Solution and Discussion Spring 2020]]></title><description><![CDATA[#include&lt;iostream&gt;

using namespace std;
	
		class TNode{
			
			private:
					node* root;
			public:				
					TNode();
					int isEmpty();
					void buildTree(int item);
					void insert(int item,node *,node *);						
					void minNode(node*);
					void maxNode(node*); 
					int countNodes(node*);
					int treeHeight(node*);
					void displayBinTree();
		};
		
		TNode::TNode(){
			
				root = NULL;
			}
			
		int TNode::isEmpty() {
					
				return (root == NULL);
			}
		
		void TNode::buildTree(int item){
		
			node *p = new node;
			node *parent;
			
			cout &lt;&lt;"Insert node in BST :" &lt;&lt; item &lt;&lt;endl;
			insert(item,p,parent);
		}	
	
		void TNode::insert(int item,node * p,node * parent){
	
				p-&gt;data=item;
				p-&gt;left=NULL;
				p-&gt;right=NULL;
				parent=NULL;
				
				if(isEmpty()){
					root = p;
				}					
				else{
					
					node *ptr;
					ptr = root;
					
					while(ptr != NULL){
						parent = ptr;
						if(item &gt; ptr-&gt;data){
							ptr = ptr-&gt;right;	
						}							
						else{
							ptr = ptr-&gt;left;
						}
							
					}	
					if(item &lt; parent-&gt;data){
						parent-&gt;left = p;
					}						
					else{
						parent-&gt;right = p;	
					}
						
				}
	}		
		
	void TNode::minNode(node* p){   

	    while (p-&gt;left != NULL){
	
	        p = p-&gt;left;
	    }
		cout &lt;&lt; "Minimum value : " &lt;&lt; p-&gt;data &lt;&lt;endl;
	}
	
	void TNode::maxNode(node* p){   

	    while (p-&gt;right != NULL){
	
	        p = p-&gt;right;
	    }
		cout &lt;&lt; "Maximum value : " &lt;&lt; p-&gt;data &lt;&lt;endl;
	}
	
	int TNode::countNodes(node* p){
		
		int node =  1;             //Node itself should be counted
	    if (p == NULL){
	    	
	    	return 0;
		}        
	    else{
	    	
	        node += countNodes(p-&gt;left);
	        node += countNodes(p-&gt;right);
	        return node;
	    }
	}
	
	int TNode::treeHeight(node* p){		
		
	    if (p == NULL) 
		{
			return 0;	
		} 	          
	    else
	    {  
	        
	        int left_side = treeHeight(p-&gt;left);  
	        int right_side = treeHeight(p-&gt;right);  
	      
	        
	        if (left_side &gt; right_side)
			{
				return(left_side + 1);	
			} 	              
	        else 
			{
				return(right_side + 1); 	
			} 
	    }  
	    
	}
	
	void TNode::displayBinTree(){
		cout &lt;&lt;endl&lt;&lt;endl;		
		minNode(root);
		maxNode(root);
		cout &lt;&lt;"Height of BST : "&lt;&lt;treeHeight(root);
		cout &lt;&lt;"\nTotal nodes : "&lt;&lt;countNodes(root);
		
	}

	int main(){
		
		TNode b;
	
		int data[] = {7,2,9,1,5,14};
		
		cout &lt;&lt;"Constructing Binary Search Tree by Inserting Nodes One by One "&lt;&lt;endl;
		cout &lt;&lt;"------------------------------------------------------------- "&lt;&lt;endl;
		int arrSize = sizeof(data)/sizeof(data[0]);
		
		for(int i = 0; i &lt; arrSize; i++)
		{
			b.buildTree(data[i]);
		}
	}



]]></description><link>https://community.secnto.com//topic/1919/cs301-assignment-2-solution-and-discussion-spring-2020</link><guid isPermaLink="true">https://community.secnto.com//topic/1919/cs301-assignment-2-solution-and-discussion-spring-2020</guid><dc:creator><![CDATA[zareen]]></dc:creator><pubDate>Invalid Date</pubDate></item><item><title><![CDATA[CS301 Assignment 1 Solution and Discussion]]></title><description><![CDATA[@zareen
100% Solution Code
#include &lt;iostream&gt;
using namespace std;

/* The Student class */
class Student {
	private:
		string firstname, lastname, VUID;
		int marks;
		Student *nextStudent;
		
	public:
		// constructor of Student class to initialize data members of class   
        Student(){
        	VUID = "";
            marks = 0;
			firstname = "";
            lastname = "";            			
            nextStudent = NULL;
        }        
        
        // Student class method to set VU  ID of Student
        void setVUID(string val){
            VUID = val;
        };
        
        //Student class method to get VU ID of Student
        string getVUID(){
            return VUID;
        }; 
            
        // Student class method to set first name of Student
        void setFirstName(string val){
            firstname = val;
        };
        
        //Student class method to get first name of Student
        string getFirstName(){
            return firstname;
        }; 
        
        // Student class method to set last name of Student
        void setLastName(string val){
            lastname = val;
        };
        
        //Student class method to get last name of Student
        string getLastName(){
            return lastname;
        };
        
        //Student class method to set the Marks of Student
        void setMarks(int val) { 
            marks = val; 
        };
		// Student class method to get the Marks of Student
        int getMarks() { 
            return   marks; 
        }
        
        //Student class method to point current Student to next Student
        void setNext(Student *nextStudent) {
        	this-&gt;nextStudent   =   nextStudent; 
        }
        
        // Student class method to get memory address where pointer is pointing
        Student *getNext() { 
            return   nextStudent; 
        }       
};

/* The List class */
class List {
	
	private:
		Student *   head;
        Student *   current;
    
    public:
        // constructor of list class to initialize data members of class
        List() {            
            head   =   new Student();
            head-&gt;setNext(NULL);
            current   =   NULL;          
        }                
        
        // list class method to add Students into list
        void   add() {
            Student *newStudent = new Student();
            int loc_marks = 0;
            string loc_vuid = "", loc_fname = "", loc_lname = "";
            
            cout&lt;&lt;"\nEnter VU ID: ";
            cin&gt;&gt;loc_vuid;
            newStudent-&gt;setVUID(loc_vuid);
            
            cout&lt;&lt;"Enter Marks: ";
            cin&gt;&gt;loc_marks;
            newStudent-&gt;setMarks(loc_marks); 
            
            cout&lt;&lt;"Enter First Name: ";
            cin&gt;&gt;loc_fname;
            newStudent-&gt;setFirstName(loc_fname);
            
            cout&lt;&lt;"Enter Last Name: ";
            cin&gt;&gt;loc_lname;
            newStudent-&gt;setLastName(loc_lname);
           
            if(head-&gt;getNext() == NULL){
           		newStudent-&gt;setNext(NULL);
               	head-&gt;setNext(newStudent);               	
               	current   =   newStudent;
		    }
		    else{
		    	Student *temp = head;
		    	while(temp-&gt;getNext() != NULL &amp;&amp; temp-&gt;getNext()-&gt;getMarks() &gt;= loc_marks){
		    		temp = temp-&gt;getNext();
				}
				current = temp;
				newStudent-&gt;setNext(current-&gt;getNext());
               	current-&gt;setNext( newStudent );               	
               	current   =   newStudent;
		   }         
        };        

        // list class method to get the information of Student
        void getInfo() { 
            if (current  !=  NULL){
				cout&lt;&lt;"VU ID: "&lt;&lt;current-&gt;getVUID()&lt;&lt;endl;
	            cout&lt;&lt;"Marks: "&lt;&lt;current-&gt;getMarks()&lt;&lt;endl;				 
				cout&lt;&lt;"First Name: "&lt;&lt;current-&gt;getFirstName()&lt;&lt;endl;
				cout&lt;&lt;"Last Name: "&lt;&lt;current-&gt;getLastName()&lt;&lt;endl&lt;&lt;endl;				
			}
        };				          
               
        // list class method to move current to next Student
        bool next() {
            if (current  ==  NULL){
                return  false;
            }  
            current  =  current-&gt;getNext();            
        };
        
        // frient function to list class to show all students in the list
        friend void showStudents(List list){
            Student* savedCurrent  =  list.current;
            list.current  =  list.head;
            
            for(int i = 1; list.next(); i++){			
				list.getInfo();          
			}
            list.current  =  savedCurrent;
        };
};
    
main() {
	int input = 0;
    List lst;      
    
    while(input != -1) {
        
        cout&lt;&lt;"1. To Add New Student in Ranking"&lt;&lt;endl;
        cout&lt;&lt;"2. To Display Ranking"&lt;&lt;endl;
        cout&lt;&lt;"3. To Close"&lt;&lt;endl&lt;&lt;endl;
        cout&lt;&lt;"Enter Your Choice: (1, 2 or 3) ";
        cin&gt;&gt; input;
        
        if(input == 1) {
        	lst.add();
			cout&lt;&lt;"Student's information saved successfully.\n"; 
        }
        else if(input == 2) {
        	cout&lt;&lt;"\nRanking Chart"&lt;&lt;endl;
            showStudents(lst);
            return 0;
        }
        else {
        	return 0;
        }		
	}
}


]]></description><link>https://community.secnto.com//topic/1849/cs301-assignment-1-solution-and-discussion</link><guid isPermaLink="true">https://community.secnto.com//topic/1849/cs301-assignment-1-solution-and-discussion</guid><dc:creator><![CDATA[zareen]]></dc:creator><pubDate>Invalid Date</pubDate></item><item><title><![CDATA[CS301 GDB 1 Solution and Discussion]]></title><description><![CDATA[<p dir="auto">CS301 GDB 1 Solution and Discussion</p>
]]></description><link>https://community.secnto.com//topic/1439/cs301-gdb-1-solution-and-discussion</link><guid isPermaLink="true">https://community.secnto.com//topic/1439/cs301-gdb-1-solution-and-discussion</guid><dc:creator><![CDATA[zareen]]></dc:creator><pubDate>Invalid Date</pubDate></item><item><title><![CDATA[CS301 Assignment 2 Solution and Discussion]]></title><description><![CDATA[100% Solved:
#include &lt;iostream&gt;
#include &lt;string.h&gt; 
using namespace std;

const int arrLength = 10;

struct Student{
	string userVUID;
	string userDetails;
	
}std1={"NULL","NULL"};

class ArrQueue{
private:
	//Data Members
	Student arr[arrLength];
	int front;
	int rear;
	
public:
	//Constructor
	ArrQueue(){
		for(int i=0; i&lt;arrLength; i++)
			arr[i] = std1;
		
		front = -1;
		rear = -1;
	}
	
	//Member Functions
	void enQue(Student std){
		
		if(isEmpty()){
			arr[0] = std;
			front++;
			rear++;
		}
		else if(isFull()){
			cout &lt;&lt; " Queue is full.";
		}
		else{
			arr[rear+1] = std;
			rear++;
		}
	}
	
	void deQue(){
		
		if(isEmpty()){
			cout&lt;&lt; " No Student In the Queue.\n";
		}
		else if(rear == 0){
			arr[front] = std1;
			front = -1;
			rear = -1; 
		}
		else{
			
			int tempfront = front;
			arr[front] = std1;
			
			for(int i=1; i&lt;=rear; i++ ){
				arr[front] = arr[i];
				front++;
			}

			rear--;
			front = tempfront;
		}
	}
	
	int queLength(){
		return rear+1;
	}
	
	bool isEmpty(){
		if(front==-1 || rear==-1)
			return true;
		else
			return false;
	}
	
	bool isFull(){
		if(rear == arrLength-1)
			return true;
		else
			return false;
	}
	
	void showQue(){
		cout &lt;&lt; "\n |Sr. VU ID            Details     |";
		cout &lt;&lt; "\n --- -------------------------------\n";
		for(int i=front; i&lt;=rear; i++){
			cout&lt;&lt;"  "&lt;&lt; i+1&lt;&lt; ".  "&lt;&lt; arr[i].userVUID &lt;&lt; "       " &lt;&lt; arr[i].userDetails &lt;&lt;"\n";
		}
	}
	
};

int main(){
	/*Code For Even Id's 
	Student std[] = {{"BC12345684","Bilal (BSCS)"},
					 {"BC12345685","Bilal (BSCS)"},{"BC12345686","Bilal (BSCS)"},{"BC12345687","Bilal (BSCS)"},
					 {"BC12345688","Bilal (BSCS)"}};*/
	
	/*Code For Odd Id's */
	Student std[] = {{"BC12345683","Bilal (BSCS)"},
					 {"BC12345684","Bilal (BSCS)"},{"BC12345685","Bilal (BSCS)"},{"BC12345686","Bilal (BSCS)"},
					 {"BC12345687","Bilal (BSCS)"}};
	ArrQueue arrQue;
	
	cout &lt;&lt; "\n -----------------------------------";
	cout &lt;&lt; "\n |  Queue (After Adding Students)  |";
	cout &lt;&lt; "\n -----------------------------------";
	for(int i=0; i&lt;=4; i++){
		arrQue.enQue(std[i]);
	}
	arrQue.showQue();
	
	cout &lt;&lt; "\n -----------------------------------";
	cout &lt;&lt; "\n | Queue (After Removing Students) |";
	cout &lt;&lt; "\n -----------------------------------";
	
	/* Code For Even Id's
	for(int i=0; i&lt;=1; i++){
		arrQue.deQue();
	}*/
	
	/*Code For Odd Id's*/
	for(int i=0; i&lt;1; i++){
		arrQue.deQue();
	}
	
	arrQue.showQue();
}


]]></description><link>https://community.secnto.com//topic/1118/cs301-assignment-2-solution-and-discussion</link><guid isPermaLink="true">https://community.secnto.com//topic/1118/cs301-assignment-2-solution-and-discussion</guid><dc:creator><![CDATA[zareen]]></dc:creator><pubDate>Invalid Date</pubDate></item><item><title><![CDATA[CS301 Assignment 3 Solution and Discussion]]></title><description><![CDATA[Solution Idea!
#include &lt;bits/stdc++.h&gt; 
using namespace std; 


class HeapNode_Min { // Tree node of Huffman 

public:
//Add data members here. 
char d;
unsigned f;
HeapNode_Min *l, *r;


HeapNode_Min(char d, unsigned f = -1) 
{ 
//Complete the body of HeapNode_Min function
this-&gt;d = d;
this-&gt;f = f ;
this-&gt;l = NULL;
this-&gt;r = NULL;
} 
}; 

class Analyze { // two heap nodes comparison

public:
bool operator()(HeapNode_Min* l, HeapNode_Min* r) 
{ 
//add return before statement and statement is completed. 
return (l-&gt;f &gt; r-&gt;f); //Complete this statement
} 
}; 

void display_Codes(HeapNode_Min* root, string s) // To print codes of huffman tree from the root. 
{ 
if (!root) 
return; 

if (root-&gt;d != '$') 
cout  root-&gt;d  "\t: "  s  "\n";

display_Codes(root-&gt;l, s + "0"); 
display_Codes(root-&gt;r, s + "1"); //Complete this statement by passing arguments

} 


void HCodes(char data[], int freq[], int s) // builds a Huffman Tree
{ 
HeapNode_Min *t,*r, *l ; // top, right, left


priority_queue&lt;HeapNode_Min*, vector&lt;HeapNode_Min*&gt;, Analyze&gt; H_min; 

int a=0;
while (a&lt;s){H_min.push(new HeapNode_Min(data[a], freq[a])); ++a;}


while (H_min.size() != 1) { 

l = H_min.top(); H_min.pop(); 
r = H_min.top(); H_min.pop(); 

t = new HeapNode_Min('$', r-&gt;f + l-&gt;f); 

t-&gt;r = r; t-&gt;l = l; 


H_min.push(t); 
} 

display_Codes(H_min.top(), ""); 
} 

int main() 
{ 
int frequency[] = { 3, 6, 11, 14, 18, 25 }; char alphabet[] = { 'A', 'L', 'O', 'R', 'T', 'Y' }; 
//Complete this statement by passing data type to both sizeof operators 
int size_of = sizeof(alphabet) / sizeof(*alphabet);

cout"Alphabet"":""Huffman Code\n";
cout"--------------------------------\n";

//Call Huffman_Codes function. 
HCodes(alphabet, frequency, size_of);
return 0; 
}

]]></description><link>https://community.secnto.com//topic/1117/cs301-assignment-3-solution-and-discussion</link><guid isPermaLink="true">https://community.secnto.com//topic/1117/cs301-assignment-3-solution-and-discussion</guid><dc:creator><![CDATA[zareen]]></dc:creator><pubDate>Invalid Date</pubDate></item><item><title><![CDATA[CS301 Quiz 1 Solution and Discussion]]></title><description><![CDATA[https://youtu.be/ssSfZhu9sBM
]]></description><link>https://community.secnto.com//topic/815/cs301-quiz-1-solution-and-discussion</link><guid isPermaLink="true">https://community.secnto.com//topic/815/cs301-quiz-1-solution-and-discussion</guid><dc:creator><![CDATA[mehwish]]></dc:creator><pubDate>Invalid Date</pubDate></item><item><title><![CDATA[CS301 Assignment 1 Solution and Discussion]]></title><description><![CDATA[.CPP File Code
using namespace std;
 
#include &lt;stdlib.h&gt;
#include &lt;iostream&gt;
 
struct StudentDetail{
     
    string name;
    string vuid;
     
     
};
 
//class Node* head;
 
 
class Node{
     
    struct StudentDetail newStd;
    class Node* next;
    class Node* prev;
     
    void Set(string name,string vuid)
    {
        newStd.name=name;
        newStd.vuid=vuid;
         
         
    }
     
    Node Get()
    {
             
    }
     
    void setNext(string name,string vuid){
         
        if(next==NULL)
        {
             
        }
        else
        {
            class Node* newNode= new Node();
             
                newStd.name=name;
                newStd.vuid=vuid;
                newNode-&gt;next= newNode;
         
             
             
    }   }
     
    string getNext()
    {
        next;
         
    }
     
        void setPrev(string name,string vuid){
         
        if(next==NULL)
        {
             
        }
        else
        {
            class Node* newNode= new Node();
             
                newStd.name=name;
                newStd.vuid=vuid;
                newNode-&gt;next= newNode;
         
             
             
    }   }
     
        string getPrev()
    {
        prev;
         
    }
     
     
};
 
 
 
class DoublyLinkedList{
    public:
    struct StudentDetail newStd;
class DoublyLinkedList* headPtr;
class DoublyLinkedList* curPtr;
class DoublyLinkedList* nextPtr;
int size;
//dfdf
 
class DoublyLinkedList* headDlinkList=NULL;
 
void addAtBegining(string vuid, string name)
{
class DoublyLinkedList* dNode= new DoublyLinkedList();
 
    dNode-&gt;newStd.vuid=vuid;
    dNode-&gt;newStd.name=name;
    dNode-&gt;nextPtr=headDlinkList;
    headDlinkList= dNode;
    dNode-&gt;curPtr=dNode;
     
     
     
    }
     
void addAtEnd(string vuid, string name)
{
 
    class DoublyLinkedList* dNode= new DoublyLinkedList();
 
    dNode-&gt;newStd.vuid=vuid;
    dNode-&gt;newStd.name=name;
    dNode-&gt;nextPtr=headDlinkList;
    headDlinkList= dNode;
        dNode-&gt;curPtr=dNode;
     
    }   
     
     
 void delNode()
 {
    class DoublyLinkedList* temp1=curPtr;
    class DoublyLinkedList* temp2= temp1;
    temp1-&gt;nextPtr= temp2-&gt;nextPtr;
     
    free(temp2);
     
     
     
     
     
 }
     
     
     
     
    void print()
    {
     
   class DoublyLinkedList* temp= headDlinkList;
    
   while(temp!=NULL)
   {
 cout&lt;&lt;temp-&gt;newStd.vuid&lt;&lt;"      "&lt;&lt;temp-&gt;newStd.name&lt;&lt;endl;  
    temp= temp-&gt;nextPtr;
         
}
         
    }
 
 
 
 
     
};
 
 
 
 
int main()
{
    string vuid,name;
     
cout&lt;&lt;"Add your vuID and Name at First Position "&lt;&lt;endl;
cout&lt;&lt;"_ _ _ _ _ _ _ _ __ _ _ _ _ _ _ _ __ _ _ _ _ _ _ _ __ _ _"&lt;&lt;endl;
 
    DoublyLinkedList dlist1;
 
     
    cin&gt;&gt;vuid;
    cin&gt;&gt;name;
     
    dlist1.addAtBegining(vuid,name);
    dlist1.print();
     
    cout&lt;&lt;"Insertion At Beginning in doubly Link List "&lt;&lt;endl;
    cout&lt;&lt;"_ _ _ _ _ _ _ _ __ _ _ _ _ _ _ _ __ _ _ _ _ _ _ _ __ _ _"&lt;&lt;endl;
        cin&gt;&gt;vuid;
    cin&gt;&gt;name;
    dlist1.addAtBegining(vuid,name);
dlist1.print(); 
 
        cout&lt;&lt;"Insertion At End in doubly Link List "&lt;&lt;endl;
    cout&lt;&lt;"_ _ _ _ _ _ _ _ __ _ _ _ _ _ _ _ __ _ _ _ _ _ _ _ __ _ _"&lt;&lt;endl;
    cin&gt;&gt;vuid;
    cin&gt;&gt;name;
        dlist1.addAtEnd(vuid,name);
dlist1.print(); 
        cout&lt;&lt;"Deletion of Current Node (Last Node) "&lt;&lt;endl;
    cout&lt;&lt;"_ _ _ _ _ _ _ _ __ _ _ _ _ _ _ _ __ _ _ _ _ _ _ _ __ _ _"&lt;&lt;endl;
    dlist1.delNode();
    dlist1.print();
     
}

Download .cpp File
https://youtu.be/lG5dpgvNi1s
]]></description><link>https://community.secnto.com//topic/618/cs301-assignment-1-solution-and-discussion</link><guid isPermaLink="true">https://community.secnto.com//topic/618/cs301-assignment-1-solution-and-discussion</guid><dc:creator><![CDATA[zareen]]></dc:creator><pubDate>Invalid Date</pubDate></item></channel></rss>