LearnToWin

learntowin

C++ was initially intended to extend the C programming language with features that make object-oriented programming easier. Finally, it added features that allowed for modular programming, basics of c++ improved data abstractions, and generic programming. C++ was eventually standardised as ISO/IEC 14882 in late 1998. (current version is 2003). C++ is not fully backward compatible with C, but it is close enough that 95 percent of C programs should compile quite easily as C++. Header File Similar to a C program, header files are included at the start. Header files contained pre-declared function libraries that users could use at their leisure. iostream is a header file that has input and output streams. It is denoted as . < #include iostream.h> Main Function main() is the function that handles the program's execution. The main function's return type is int. Cout cout<< Whatever you will write here will appear on the screen.; Comment Single line comment // is used before mentioning the comment in single-line comments. For example, cout<<"hello"; / This is a single-line comment Multiple line comment Enclose the comment between /* and */ for multiple line comments. As an example, /*this is a multi-line comment............. The comment comes to a conclusion */ C++ Data Types Data types can either be built-in or abstract. Basic Built-types 1. char 2. int 3. float 4. double Operator types 1. Assignment Operator The assignment operator '=' takes the right-hand side (called rvalue) and copies it into the left-hand side (called lvalue). The assignment operator is the only one that can be overloaded but not inherited. 2. Mathematical Operators Basic mathematical operations are performed using operators. The basic mathematical operators are addition (+), subtraction (-), diversion (/), multiplication (*), and modulus (percent). The modulus operator is incompatible with floating-point numbers. 3. Relational Operators These operators create a connection between operands. Less than (<), greater than (>), equal to (=), greater than equal to (>=), less than equal to (<=), equivalent (==), and not equivalent (!=) are the relational operators. 4. Logical Operators AND (&&) and OR (||) are the logical operators. They are used to combine two distinct expressions. 5. Bitwise Operators They're used to convert individual bits into numbers. They only work with integral data types such as char, int, and long, not with floating-point values. => & - Bitwise AND operator => | - Bitwise OR operator => ^ - XOR bitwise operator => ~ - NOT bitwise operator 6. Shift Operators Shift Operators are used to change the order of bits in any variable. There are three kinds of it. Left Shift Operator - << Right Shift Operator - >> Unsigned Right Shift Operator - >>> 7. Unary Operators These are the operators that only work on one operand. There are numerous unary operators, but the increment ++ and decrement - - operators are the most commonly used. 8. Tertiary Operator The ternary if-else?: is a three-operand operator. Example, int x = 500; x > 100 ? cout << "It is true" : cout << "It is false" 9. Comma Operator This is used to distinguish between variable names and expressions. memory set aside for data types, objects, and user-defined data types C++ PROGRAM STRUCTURE C++ programs are divided into four major sections: 1. Included header files 2. Class declarations 3. Member function definitions 4. Initialise main function purpose The sections can be placed as separate code files that can be compiled together or independently. Because class declarations and member function definitions are separated, the programmer can separate the interface's abstract specification from the implementation details. The Main function includes all of the files required for execution in all sections. The class definitions and member functions act as a server, providing services to the client, which is the main program. The class's Public Interface is used for communication between the program's client and server elements. Class declaration syntax class nameofclass { private : variable declarations; variable declarations;      //As many you want function declarations; function declarations;     //As many you want public : function declarations; function declarations;     //As many you want function declarations; function declarations;     //As many you want }; => Objects are instances of a class that hold the data variables declared in the class, and member functions operate on these class objects. => Classes contain member functions and data members, and how these data members and variables are accessed is determined by the access specifiers. => A class's member functions can be defined either within or outside the class definition. => A class has private access control by default. => During the class definition process, no storage is assigned. => The name of the class must begin with an uppercase letter. Access specifiers => Access specifiers are used to limit the availability of class members. => In c programmming, access specifiers are separated by a colon. => In the same class, one, two, or all three specifiers can be used to set different boundaries for different class members. Everyone will be able to see all of the class members who have declared themselves as public. Other classes can use the said public data members and member functions. Public: Outside of that class, no one has access to the class members who have been declared private. A compile-time error will occur if you attempt to access the private member. Class variables and member functions are by default private. Private: Class members outside the class are inaccessible, but any subclass of that class can access them. If class A inherits class B, then class B, a subclass of class A, has access. Protected: Object creation After defining a class, any number of objects belonging to that class can be created. The type class variable is objects. A class is a grouping of objects of the same type. The object declaration allocates the necessary memory space for the object. The following class, for example, has three objects: obj1, obj2, and obj3. "Hello, World!" C++ Program It is an elementary program. It is frequently used to introduce a new programming language to a beginner. // Hello world C++ Program #include <iostream> int main() { std::cout << "This is my first program = Hello World!"; return 0; } Output This is my first program = Hello World!

Re-learning the Basics of C++

Description of the Situation: We have an arbitrary binary tree, a node of that tree, and also an integer: 'K.' We need to print all such nodes which have a distance K from the given node and return the list of these nodes. You can check out this problem here as well: . Print Nodes at Distance k from Node The distance between the two nodes in a binary tree is defined as the number of connections/edges in the path between the two nodes. Let’s see an example: Let's examine the tree shown in the diagram: = pointer to node with data 8. Inputs: target = pointer to node with data 20. root k = 2. 10 14 22 Output : If the target is 14 and k is 3, then the output  should be “4 20.” In this type of node, two types of nodes are to be considered: 1. The target node is rooted in the subtree. If the value of k is 2 and the target node is 8, for example, such nodes are 10 and 14. 2. Other nodes could be a target's ancestor or a node in a different subtree. This category includes node 22 for target node 8 when k is 2. Finding the first type of node is straightforward. In a recursive call, simply visit subtrees rooted with the target node and decrement k. As soon as k becomes 0, print the node that is currently being traversed. So, we will call a new function printkdistance(). And we must go through all ancestors for the output nodes that are not in the subtree that has the target node as the root. We calculate the distance between each ancestor and the target node, d. We then travel to the ancestor's other subtree (if the target was discovered in the left subtree, we go to the right subtree, and vice versa) and find all nodes at k-d distance from the ancestor. Let’s see how can we implement this approach: int data;
	Node left, right; {
		data = item; }
} Node root; { } {
			System.out.print(node.data); } } { } {
			printkdistance(node, k); } int dl = printkdistanceNode(node.left, target, k); { {
				System.out.print(node.data); } } int dr = printkdistanceNode(node.right, target, k); { {
				System.out.print(node.data); } } } Node target = tree.root.left.right; }
} // This is a java program //to print nodes at a distance k from the given node // A Node of a Binary Tree class Node { Node ( int item ) left = right = null ; class BinaryTree { // Recursive function that will help to print all the nodes at distance k in // tree (or subtree) rooted with a given root. void printkdistance ( Node node, int k ) // Base Case will be, if (node == null || k < 0 ) { return ; // If we find a k distant node, we'll print it if (k == 0 ) System.out.println( "" ); return ; // Recursion for left and right subtrees printkdistance(node.left, k- 1 ); printkdistance(node.right, k- 1 ); // Prints nodes at a distance k from a given target node. // The nodes that are at k distance may be in an up or down direction. // This function will return the distance of the root node from the target node. // And, it will return -1 if the target node is not present in a tree rooted with the root // node. int printkdistanceNode ( Node node, Node target, int k ) // The First Base Case: If the tree is empty, then return (-1). if (node == null ) { return - 1 ; // If the target is the same as the root node. We will use the downward // function that will print all nodes at distance k in the subtree rooted with // target or root if (node == target) return 0 ; // Recursion for left subtree. // Check if the target node was in the left subtree. if (dl != - 1 ) // If the root is at k distance from the target, then print the root node. // Note that the distance of root's left child from the target is dl. if (dl + 1 == k) System.out.println( "" ); // Else go into the right subtree and print all the nodes that are at distance of k-dl-2. // Note that the right child is only 2 edges away from the left child. else printkdistance(node.right, k - dl - 2 ); // Now, add 1 to the distance and return the value for parent calls. return 1 + dl; // Now, we will MIRROR THE ABOVE CODE FOR THE RIGHT SUBTREE as well. // Note that we will reach here only when node was not found in left // subtree if (dr != - 1 ) if (dr + 1 == k) System.out.println( "" ); else printkdistance(node.left, k - dr - 2 ); return 1 + dr; // If target is neither in the left nor in the right subtree return - 1 ; // To test the above functions, a Driver Program public static void main ( String args[] ) { BinaryTree tree = new BinaryTree(); /* Let us make the tree as shown in above diagram */ tree.root = new Node( 20 ); tree.root.left = new Node( 8 ); tree.root.right = new Node( 22 ); tree.root.left.left = new Node( 4 ); tree.root.left.right = new Node( 12 ); tree.root.left.right.left = new Node( 10 ); tree.root.left.right.right = new Node( 14 ); tree.printkdistanceNode(tree.root, target, 2 ); Output: 4 20 In this approach, no node is being traversed more than twice. So, the time complexity is O(n). Time Complexity: Another Approach: First, get the Path from the Root Node and add it to a list. For every 'i' th element from Path, just iterate and print nodes that are at '(K-i)'th distance. public int val;
	public TreeNode left;
	public TreeNode right; } { discoverPath(root, target); findKDistance(
				path.get(i), K - j, answer, } } { } answer.add(node.val);
		} } { path.add(node); } } { TreeNode target = root.left.right; }
} import java.io.*; import java.util.*; class TreeNode { public TreeNode ( ) {} public TreeNode ( int val ) { this .val = val; } class CodingNinjas { List<TreeNode> path = null ; //Finding the nodes that are at a distance of K from the target node. public List<Integer> distanceK ( TreeNode root, TreeNode target, int K ) path = new ArrayList<>(); List<Integer> answer = new ArrayList<>(); for (int j= 0 ; j<path.size(); j++) { j == 0 ? null : path.get(j - 1 )); //Now return the list of all nodes at a distance K. return answer; // Blocker is used for nodes that are ancestors; if the target is at left, then we will // have to go right, or if the target is at right, then we will have to go left. public void findKDistance ( TreeNode node, int dist, List<Integer> answer, TreeNode blocker ) if (dist < 0 || node == null || (blocker != null && node == blocker)) { return ; if (dist == 0 ) { findKDistance(node.left, dist - 1 , answer, blocker); findKDistance(node.right, dist - 1 , answer, blocker); //To find the path of the target node from the root node. public boolean discoverPath ( TreeNode node, TreeNode target ) if (node == null ) return false ; if (node==target || discoverPath(node.left, target) || discoverPath(node.right, target))   { return true ; return false ; public static void main ( String [] args ) CodingNinjas codingninjas = new CodingNinjas(); /* Let us make the tree shown in above diagram */ TreeNode root = new TreeNode( 20 ); root.left = new TreeNode( 8 ); root.right = new TreeNode( 22 ); root.left.left = new TreeNode( 4 ); root.left.right = new TreeNode( 12 ); root.left.right.left = new TreeNode( 10 ); root.left.right.right = new TreeNode( 14 ); System.out.println(codingninjas.distanceK(root, target, 2 )); Output: [4, 20] Conclusion In this article, we have studied how to print Nodes at Distance k from Node. We hope that this article has provided you with the help to enhance your knowledge regarding Binary Tree.

Stories, News & Mentions about LEARNTOWIN

Learntowin’s Stories on HackerNoon