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
#include
#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  
#include  

/* 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 linkedList=new LinkedList();

  linkedList.add("java");

  linkedList.add("Is");

  linkedList.add("High");

  linkedList.add("Level");

  linkedList.add("Language");

  Iterator itr=linkedList.iterator();

  while(itr.hasNext())
  {

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

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

  }

 }

}