JRSETI Wiki

User Tools

Site Tools

Trace:
study_2

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
study_2 [2020/06/15 00:27] – jrsetistudy_2 [2020/11/03 21:32] (current) – jrseti
Line 1: Line 1:
-==Binary Heaps==+=====One hour interview Video==== 
 + 
 +https://www.youtube.com/watch?v=3yQ4Jaumw3g 
 + 
 +====Binary Heaps====
  
 [[https://bradfieldcs.com/algos/trees/priority-queues-with-binary-heaps/|Good Binary Heap Tutorial]] [[https://bradfieldcs.com/algos/trees/priority-queues-with-binary-heaps/|Good Binary Heap Tutorial]]
Line 5: Line 9:
 enqueue or dequeue items in O(logn) enqueue or dequeue items in O(logn)
  
-Priority Queues use a min heap or max heap+**Priority Queues** use a min heap or max heap. In Java use the Comparator:
  
-==Reverse Singly Linked List==+<code> 
 +import java.util.*;  
 + 
 +... 
 +PriorityQueue<Student> pq = new PriorityQueue<Student>(5, new StudentComparator()); 
 +... 
 +              
 + 
 +Class StudentComparator implements Comparator<Student>{  
 +               
 +            // Overriding compare()method of Comparator   
 +                        // for descending order of cgpa  
 +            public int compare(Student s1, Student s2) {  
 +                if (s1.cgpa < s2.cgpa)  
 +                    return 1;  
 +                else if (s1.cgpa > s2.cgpa)  
 +                    return -1;  
 +                                return 0;  
 +                }  
 +        }  
 +</code> 
 + 
 +====Reverse Singly Linked List====
  
   prev = None   prev = None
   cur = head   cur = head
   while cur:   while cur:
-    next_node = cur.nect+    next_node = cur.next
     cur.next = prev     cur.next = prev
     prev = cur     prev = cur
Line 21: Line 47:
  
  
-==Reverse Double Linked List==+====Reverse Double Linked List==== 
 +<code> 
 +void reverse() {  
 +        Node temp = null;  
 +        Node current = head;  
 +   
 +        /* swap next and prev for all nodes of   
 +         doubly linked list */ 
 +        while (current != null) {  
 +            temp = current.prev;  
 +            current.prev = current.next;  
 +            current.next = temp;  
 +            current = current.prev;  
 +        }  
 +   
 +        /* Before changing head, check for the cases like empty   
 +         list and list with only one node */ 
 +        if (temp != null) {  
 +            head = temp.prev;  
 +        }  
 +    }  
 +</code> 
 + 
 +====Power Sets==== 
 + 
 +All combinations of letters in a string. 
 + 
 +Trick = use an integer counter. 
 + 
 +<code> 
 +        /*set_size of power set of a set  
 +        with set_size n is (2**n -1)*/ 
 +        long pow_set_size =   
 +            (long)Math.pow(2, set_size);  
 +        int counter, j;  
 +       
 +        /*Run from counter 000..0 to  
 +        111..1*/ 
 +        for(counter = 0; counter <   
 +                pow_set_size; counter++)  
 +        {  
 +            for(j = 0; j < set_size; j++)  
 +            {  
 +                /* Check if jth bit in the   
 +                counter is set If set then   
 +                print jth element from set */ 
 +                if((counter & (1 << j)) > 0)  
 +                    System.out.print(set[j]);  
 +            }  
 +               
 +            System.out.println();  
 +        }  
 +</code> 
 + 
 +====Tries==== 
 + 
 +====N Choose K==== 
 + 
 +n!/((n-k)!k!) 
 + 
 +====Knapsack==== 
 + 
 +====Coins==== 
 + 
 +====Quick Sort==== 
 + 
 +====Heaps==== 
 + 
 +====Spiral====
  
-==Power Sets==+====Quick Sort====
  
 +====Priority Queues====
  
  
  
study_2.1592180844.txt.gz · Last modified: 2020/06/15 00:27 by jrseti