JRSETI Wiki

https://www.youtube.com/watch?v=3yQ4Jaumw3g

Good Binary Heap Tutorial

enqueue or dequeue items in O(logn)

Priority Queues use a min heap or max heap. In Java use the Comparator:

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; 
                } 
        } 

prev = None
cur = head
while cur:
  next_node = cur.next
  cur.next = prev
  prev = cur
  cur = next_node
head = prev

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; 
        } 
    } 

All combinations of letters in a string.

Trick = use an integer counter.

        /*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(); 
        } 

n!/((n-k)!k!)