preOrder (t)
     {
       if (t is not empty)
        {
              access the root element of t;
              preOrder (leftTree (t));
              preOrder (rightTree (t));
       } // if
    } // preOrder traversal

/ Count number of bits to be 
// flipped to convert A into B 
using System; 

public class Count { 
	
	// Function that count set bits 
	public static int countSetBits(int n) 
	{ 
		int count = 0; 
		while (n != 0) { 
			count += n & 1; 
			n >>= 1; 
		} 
		return count; 
	} 

	// Function that return 
	// count of flipped number 
	public static int FlippedCount(int a, int b) 
	{ 
	// Return count of set 
	// bits in a XOR b 
		return countSetBits(a ^ b); 
	} 
	
	// Driver code 
	public static void Main() 
	{ 
		int a = 17; 
		int b = 55; 
		Console.WriteLine(FlippedCount(a, b)); 
	} 
} 

// This code is contributed by vt_m. 

#include<iostream>
#include<cmath>
#define ROW 3
#define COL 3
using namespace std;

int tokens[ROW][COL] = {
   {-2,-3,3},
   {-5,-10,1},
   {10,30,-5}
};

int max(int a, int b) {
   return (a>b)?a:b;
}

int minInitPoints() {
   int minToken[ROW][COL];
   int m = ROW, n = COL;
   
   minToken[m-1][n-1] = tokens[m-1][n-1] > 0? 1: abs(tokens[m-1][n-1]) + 1;
   
   for (int i = m-2; i >= 0; i--)    //from last row to first row, fill points
      minToken[i][n-1] = max(minToken[i+1][n-1] - tokens[i][n-1], 1);
   
   for (int j = n-2; j >= 0; j--)    //fill last column to first column, fill points
      minToken[m-1][j] = max(minToken[m-1][j+1] - tokens[m-1][j], 1);

   for (int i=m-2; i>=0; i--) {
      for (int j=n-2; j>=0; j--) {
         int remPoint = min(minToken[i+1][j], minToken[i][j+1]);    //calculate remaining points
         minToken[i][j] = max(remPoint - tokens[i][j], 1);
      }
   }
   return minToken[0][0];
}

int main() {
   cout << "Least Points Required: " << minInitPoints();
}

#include <stdio.h> 
#include <stdlib.h> 

/* A binary tree tNode has data, pointer to left child 
and a pointer to right child */
struct traversalNode { 
	int data; 
	struct traversalNode* left; 
	struct traversalNode* right; 
}; 

/* Function to traverse binary tree without recursion and 
without stack */
void MorrisTraversal(struct traversalNode* root) 
{ 
	struct traversalNode *current, *pre; 

	if (root == NULL) 
		return; 

	current = root; 
	while (current != NULL) { 

		if (current->left == NULL) { 
			printf("%d ", current->data); 
			current = current->right; 
		} 
		else { 

			/* Find the inorder predecessor of current */
			pre = current->left; 
			while (pre->right != NULL && pre->right != current) 
				pre = pre->right; 

			/* Make current as right child of its inorder 
			predecessor */
			if (pre->right == NULL) { 
				pre->right = current; 
				current = current->left; 
			} 

			/* Revert the changes made in if part to restore 
			the original tree i.e., fix the right child 
			of predecssor */
			else { 
				pre->right = NULL; 
				printf("%d ", current->data); 
				current = current->right; 
			} /* End of if condition pre->right == NULL */
		} /* End of if condition current->left == NULL*/
	} /* End of while */
} 

/* UTILITY FUNCTIONS */
/* Helper function that allocates a new tNode with the 
given data and NULL left and right pointers. */
struct traversalNode* newtraversalNode(int data) 
{ 
	struct traversalNode* node = new traversalNode; 
	node->data = data; 
	node->left = NULL; 
	node->right = NULL; 

	return (node); 
} 

/* Driver program to test above functions*/
int main() 
{ 

	/* Constructed binary tree is 
			12 
		/ \ 
		13	 14 
	/ \ 
	15	 16 
*/
	struct traversalNode* root = newtraversalNode(12); 
	root->left = newtraversalNode(13); 
	root->right = newtraversalNode(14); 
	root->left->left = newtraversalNode(15); 
	root->left->right = newtraversalNode(16); 

	MorrisTraversal(root); 

	return 0; 
} 

import java.util.Iterator;

import java.util.LinkedList;					

public class LinkedListDemo 
{

  public static void main (String[] args) {

  LinkedList<String> linkedList=new LinkedList<String>();

  linkedList.add("java");

  linkedList.add("Is");

  linkedList.add("High");

  linkedList.add("Level");

  linkedList.add("Language");

  Iterator<String> itr=linkedList.iterator();

  while(itr.hasNext())
  {

   System.out.print(itr.next());

   System.out.print("\t");

  }

 }

}

Input:
   List1: 20->25->4->30
   lsit2:  8->4->2->20
Output:
   Intersection List: 4->20

/ C program to get intersection point of two linked list  
#include<stdio.h> 
#include<stdlib.h> 
  
/* Link list node */
struct Node 
{ 
  int data; 
  struct Node* next; 
}; 
  
/* Function to get the counts of node in a linked list */
int getCount(struct Node* head); 
  
/* function to get the intersection point of two linked 
   lists head1 and head2 where head1 has d more nodes than 
   head2 */
int _getIntesectionNode(int d, struct Node* head1, struct Node* head2); 
  
/* function to get the intersection point of two linked 
   lists head1 and head2 */
int getIntesectionNode(struct Node* head1, struct Node* head2) 
{ 
  int c1 = getCount(head1); 
  int c2 = getCount(head2); 
  int d; 
  
  if(c1 > c2) 
  { 
    d = c1 - c2; 
    return _getIntesectionNode(d, head1, head2); 
  } 
  else
  { 
    d = c2 - c1; 
    return _getIntesectionNode(d, head2, head1); 
  } 
} 
  
/* function to get the intersection point of two linked 
   lists head1 and head2 where head1 has d more nodes than 
   head2 */
int _getIntesectionNode(int d, struct Node* head1, struct Node* head2) 
{ 
  int i; 
  struct Node* current1 = head1; 
  struct Node* current2 = head2; 
  
  for(i = 0; i < d; i++) 
  { 
    if(current1 == NULL) 
    {  return -1; } 
    current1 = current1->next; 
  } 
  
  while(current1 !=  NULL && current2 != NULL) 
  { 
    if(current1 == current2) 
      return current1->data; 
    current1= current1->next; 
    current2= current2->next; 
  } 
  
  return -1; 
} 
  
/* Takes head pointer of the linked list and 
   returns the count of nodes in the list */
int getCount(struct Node* head) 
{ 
  struct Node* current = head; 
  int count = 0; 
  
  while (current != NULL) 
  { 
    count++; 
    current = current->next; 
  } 
  
  return count; 
} 
  
/* IGNORE THE BELOW LINES OF CODE. THESE LINES 
   ARE JUST TO QUICKLY TEST THE ABOVE FUNCTION */
int main() 
{ 
  /* 
    Create two linked lists 
  
    1st 3->6->9->15->30 
    2nd 10->15->30 
  
    15 is the intersection point 
  */
  
  struct Node* newNode; 
  struct Node* head1 = 
            (struct Node*) malloc(sizeof(struct Node)); 
  head1->data  = 10; 
  
  struct Node* head2 = 
            (struct Node*) malloc(sizeof(struct Node)); 
  head2->data  = 3; 
  
  newNode = (struct Node*) malloc (sizeof(struct Node)); 
  newNode->data = 6; 
  head2->next = newNode; 
  
  newNode = (struct Node*) malloc (sizeof(struct Node)); 
  newNode->data = 9; 
  head2->next->next = newNode; 
  
  newNode = (struct Node*) malloc (sizeof(struct Node)); 
  newNode->data = 15; 
  head1->next = newNode; 
  head2->next->next->next  = newNode; 
  
  newNode = (struct Node*) malloc (sizeof(struct Node)); 
  newNode->data = 30; 
  head1->next->next= newNode; 
  
  head1->next->next->next = NULL; 
  
  printf("\n The node of intersection is %d \n", 
          getIntesectionNode(head1, head2)); 
  
  getchar(); 
} 

Input: position = 1, Linked List = 9->2->3->7->6
Output: Linked List =  9->3->7->6

Input: position = 0, Linked List = 9->2->3->7->6
Output: Linked List = 2->3->7->6

#include <stdio.h> 
#include <stdlib.h> 

// A linked list node 
struct Node 
{ 
	int data; 
	struct Node *next; 
}; 

/* Given a reference (pointer to pointer) to the head of a list 
and an int, inserts a new node on the front of the list. */
void push(struct Node** head_ref, int new_data) 
{ 
	struct Node* new_node = (struct Node*) malloc(sizeof(struct Node)); 
	new_node->data = new_data; 
	new_node->next = (*head_ref); 
	(*head_ref) = new_node; 
} 

/* Given a reference (pointer to pointer) to the head of a list 
and a position, deletes the node at the given position */
void deleteNode(struct Node **head_ref, int position) 
{ 
// If linked list is empty 
if (*head_ref == NULL) 
	return; 

// Store head node 
struct Node* temp = *head_ref; 

	// If head needs to be removed 
	if (position == 0) 
	{ 
		*head_ref = temp->next; // Change head 
		free(temp);			 // free old head 
		return; 
	} 

	// Find previous node of the node to be deleted 
	for (int i=0; temp!=NULL && i<position-1; i++) 
		temp = temp->next; 

	// If position is more than number of ndoes 
	if (temp == NULL || temp->next == NULL) 
		return; 

	// Node temp->next is the node to be deleted 
	// Store pointer to the next of node to be deleted 
	struct Node *next = temp->next->next; 

	// Unlink the node from linked list 
	free(temp->next); // Free memory 

	temp->next = next; // Unlink the deleted node from list 
} 

// This function prints contents of linked list starting from 
// the given node 
void printList(struct Node *node) 
{ 
	while (node != NULL) 
	{ 
		printf(" %d ", node->data); 
		node = node->next; 
	} 
} 

/* Drier program to test above functions*/
int main() 
{ 
	/* Start with the empty list */
	struct Node* head = NULL; 

	push(&head, 6); 
	push(&head, 7); 
	push(&head, 3); 
	push(&head, 2); 
	push(&head, 9); 

	puts("Created Linked List: "); 
	printList(head); 
	deleteNode(&head, 4); 
	puts("\nLinked List after Deletion at position 4: "); 
	printList(head); 
	return 0; 
}

Created Linked List: 
 9  2  3  7  6 
Linked List after Deletion at position 4: 
 9  2  3  7

#include <iostream>
#include <unordered_set>
using namespace std;

// Data Structure to store a linked list node
struct Node
{
    int dt;
    Node* next;
};

// Helper function to create a new node with the given data and
// pushes it onto the front of the list
void push(Node*& headRef, int dt)
{
    // create a new linked list node from heap
    Node* newNode = new Node;

    newNode->dt = dt;
    newNode->next = headRef;
    headRef = newNode;
}

// Function to detect Cycle in a linked list using Hashing
bool detectcyc(Node *head)
{
    Node *current = head;
    unordered_set<Node*> set;

    // traverse the list
    while (current)
    {
        // return false if we already have seen this node before
        if (set.find(current) != set.end())
            return true;

        // insert current node into the set
        set.insert(current);

        // move to the next node
        current = current->next;
    }

    // we reach here if list does not contain any cycle
    return false;
}

// Detect Cycle in a linked list
int main()
{
    // input keys
    int k[] = { 1, 2, 3, 4, 5 };
    int n = sizeof(k) / sizeof(k[0]);

    Node* head = nullptr;
    for (int i = n - 1; i >= 0; i--)
        push(head, k[i]);

    // insert cycle
    head->next->next->next->next->next = head->next->next;

    if (detectcyc(head))
        cout << "Cycle Found";
    else
        cout << "No Cycle Found";

    return 0;
}

// JAVA implementation of tree using array 
// numbering starting from 0 to n-1. 
import java.util.*;
import java.lang.*;
import java.io.*;

class bTree {
    public static void main(String[] args) {
        btree_Array obj = new btree_Array();
        obj.Root("P");
        // obj.set_Left("Q", 0); 
        obj.set_Right("R", 0);
        obj.set_Left("S", 1);
        obj.set_Right("T", 1);
        obj.set_Left("U", 2);
        obj.print_Tree();
    }
}

class btree_Array {
    static int root = 0;
    static String[] s = new String[10];

    /*create root*/
    public void Root(String key) {
        s[0] = key;
    }

    /*create left son of root*/
    public void set_Left(String key, int root) {
        int t = (root * 2) + 1;

        if (s[root] == null) {
            System.out.printf("Can't set child at %d, no parent found\n", t);
        } else {
            s[t] = key;
        }
    }

    /*create right son of root*/
    public void set_Right(String key, int root) {
        int t = (root * 2) + 2;

        if (s[root] == null) {
            System.out.printf("Can't set child at %d, no parent found\n", t);
        } else {
            s[t] = key;
        }
    }

    public void print_Tree() {
        for (int i = 0; i < 10; i++) {
            if (s[i] != null)
                System.out.print(s[i]);
            else
                System.out.print("-");

        }
    }
}

Can't set child at 3, no parent found
Can't set child at 4, no parent found
P-R--U----