TheAlgorithms · arrnavvv · Sep 18, 2020 · Sep 24, 2020 · Mar 3, 2021 · Mar 4, 2021
@@ -0,0 +1,76 @@
+class Node{
+    int data;
+    Node left;
+    Node right;
+
+    public Node(int data) {
+        this.data = data;
+        this.left = null;
+        this.right = null;
+    }
+
+    void enterLeft(int data){
+        this.left = new Node(data);
+    }
+    void enterRight(int data){
+        this.right = new Node(data);
+    }
+}
+
+class BinaryTree{
+    Node root;
+
+    BinaryTree(int data){
+        this.root = new Node(data);
+    }
+
+    void preOrder(Node root){
+        if(root==null)
+            return;
+
+        System.out.print(root.data+" ");
+        preOrder(root.left);
+        preOrder((root.right));
+    }
+
+    void inOrder(Node root){
+        if(root==null)
+            return;
+
+        inOrder(root.left);
+        System.out.print(root.data+" ");
+        inOrder(root.right);
+    }
+
+    void postOrder(Node root){
+        if(root==null)
+            return;
+
+        postOrder(root.left);
+        postOrder(root.right);
+        System.out.print(root.data+" ");
+    }
+
+}
+
+public class PreInPostOrderTraversalOfBinaryTree  {
+    public static void main(String[] args) {
+        BinaryTree tree = new BinaryTree(2);
+        tree.root.enterLeft(7);
+        tree.root.enterRight(5);
+        tree.root.left.enterLeft(2);
+        tree.root.left.enterRight(6);
+        tree.root.left.right.enterLeft(5);
+        tree.root.left.right.enterRight(11);
+        tree.root.right.enterRight(9);
+        tree.root.right.right.enterLeft(4);
+
+        System.out.println("PreOrder");tree.preOrder(tree.root);
+        System.out.println();
+        System.out.println("InOrder");tree.inOrder(tree.root);
+        System.out.println();
+        System.out.println("PostOrder");tree.postOrder(tree.root);
+
+    }
+}
+
@@ -0,0 +1,88 @@
+import java.util.*;
+import java.io.*;
+
+class Node {
+    Node left;
+    Node right;
+    int data;
+
+    Node(int data) {
+        this.data = data;
+        left = null;
+        right = null;
+    }
+}
+
+class Solution {
+
+	/* 
+
+    class Node 
+    	int data;
+    	Node left;
+    	Node right;
+	*/
+	public static void topView(Node root) {
+
+      class MyNode{
+          Node node;
+          int hd;
+
+          MyNode(Node node,int hd){
+              this.node=node;
+              this.hd=hd;
+          }
+      }
+
+       TreeMap<Integer,Integer> tmp = new TreeMap<>();
+       Queue<MyNode> que = new LinkedList<>();
+
+       que.add(new MyNode(root, 0));
+
+       while(!que.isEmpty()){
+           MyNode cur = que.poll();
+
+           if(!tmp.containsKey(cur.hd)){
+               tmp.put(cur.hd,cur.node.data);
+           }
+
+           if(cur.node.left!=null){
+               que.add(new MyNode(cur.node.left,cur.hd-1));
+           }
+           if(cur.node.right!=null){
+               que.add(new MyNode(cur.node.right,cur.hd+1));
+           }
+       }
+       for(Integer val:tmp.values()){
+           System.out.print(val+" ");
+       }
+    }
+
+	public static Node insert(Node root, int data) {
+        if(root == null) {
+            return new Node(data);
+        } else {
+            Node cur;
+            if(data <= root.data) {
+                cur = insert(root.left, data);
+                root.left = cur;
+            } else {
+                cur = insert(root.right, data);
+                root.right = cur;
+            }
+            return root;
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int t = scan.nextInt();
+        Node root = null;
+        while(t-- > 0) {
+            int data = scan.nextInt();
+            root = insert(root, data);
+        }
+        scan.close();
+        topView(root);
+    }	
+}
@@ -10,38 +10,49 @@
  * Creates a random password from ASCII letters
  * Given password length bounds
  *
- * @author AKS1996
- * @date 2017.10.25
+ * @author arrnavvv
+ * @date 18-09-2020
  */
-class PasswordGen {
-    public static void main(String args[]) {
-        String password = generatePassword(8, 16);
-        System.out.print("Password: " + password);
-    }
-
-    static String generatePassword(int min_length, int max_length) {
-        Random random = new Random();
-
-        String upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-        String lower = "abcdefghijklmnopqrstuvwxyz";
-        String numbers = "0123456789";
-        String specialChars = "!@#$%^&*(){}?";
+public class PasswordGenerator {
 
-        String allChars = upper + lower + numbers + specialChars;
+    static String generatePassword(int min_length, int max_length){
+        String smallAlphabet="abcdefghijklmnopqrstuvwxyz";
+        String largeAlphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        String digits="1234567890";
+        String specialCharacters="!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
 
-        List<Character> letters = new ArrayList<Character>();
-        for (char c : allChars.toCharArray())
-            letters.add(c);
+        String all = smallAlphabet+largeAlphabet+digits+specialCharacters;
+        Random random = new Random();
+        int length = random.nextInt(max_length - min_length) + min_length;
+
+        StringBuilder password = new StringBuilder();
+        password.append((smallAlphabet.charAt(random.nextInt(26)))).
+                append(largeAlphabet.charAt(random.nextInt(26))).
+                append(digits.charAt(random.nextInt(10))).
+                append(specialCharacters.charAt(random.nextInt(31)));
+
+        int left = length-4;
+        StringBuilder remainingPassword = new StringBuilder();
+        while(left-->0){
+            remainingPassword.append(all.charAt(random.nextInt(93)));
+        }
+        password.append(remainingPassword);
 
-        // Inbuilt method to randomly shuffle a elements of a list
-        Collections.shuffle(letters);
-       StringBuilder password = new StringBuilder();
+        ArrayList<Character> list = new ArrayList<>();
+        for (char c : password.toString().toCharArray())
+            list.add(c);
+        Collections.shuffle(list);
 
-        // Note that size of the password is also random
-        for (int i = random.nextInt(max_length - min_length) + min_length; i > 0; --i) {
-            password .append( letters.get(random.nextInt(letters.size())));
+        StringBuilder finalPassword = new StringBuilder();
+        for(int i=0;i<list.size();i++){
+            finalPassword.append(list.get(i));
         }
+        return finalPassword.toString();
+    }
+    public static void main(String[] args) {
 
-        return password.toString();
+        String password = generatePassword(8,16);
+        System.out.println("Your password is: "+password);
     }
 }
+