#include <iostream>
#include <queue>
using namespace std;
struct Node{
int data;
struct Node* left, *right;
};
// Function to count the full Nodes in a binary tree
int fullcount(struct Node* node){
// Check if tree is empty
if (!node){
return 0;
}
queue<Node *> myqueue;
// traverse using level order traversing
int result = 0;
myqueue.push(node);
while (!myqueue.empty()){
struct Node *temp = myqueue.front();
myqueue.pop();
if (temp->left && temp->right){
result++;
}
if (temp->left != NULL){
myqueue.push(temp->left);
}
if (temp->right != NULL){
myqueue.push(temp->right);
}
}
return result;
}
struct Node* newNode(int data){
struct Node* node = new Node;
node->data = data;
node->left = node->right = NULL;
return (node);
}
int main(void){
struct Node *root = newNode(10);
root->left = newNode(20);
root->right = newNode(30);
root->left->left = newNode(40);
root->left->right = newNode(50);
root->left->left->right = newNode(60);
root->left->right->right = newNode(70);
cout <<"count is: "<<fullcount(root);
return 0;
}
// C++ program to generate n-bit Gray codes
#include <iostream>
#include <string>
#include <vector>
using namespace std;
// This function generates all n bit Gray codes and prints the
// generated codes
void generateGrayarr(int n)
{
// base case
if (n <= 0)
return;
// 'arr' will store all generated codes
vector<string> arr;
// start with one-bit pattern
arr.push_back("0");
arr.push_back("1");
// Every iteration of this loop generates 2*i codes from previously
// generated i codes.
int i, j;
for (i = 2; i < (1<<n); i = i<<1)
{
// Enter the previously generated codes again in arr[] in reverse
// order. Nor arr[] has double number of codes.
for (j = i-1 ; j >= 0 ; j--)
arr.push_back(arr[j]);
// append 0 to the first half
for (j = 0 ; j < i ; j++)
arr[j] = "0" + arr[j];
// append 1 to the second half
for (j = i ; j < 2*i ; j++)
arr[j] = "1" + arr[j];
}
// print contents of arr[]
for (i = 0 ; i < arr.size() ; i++ )
cout << arr[i] << endl;
}
// Driver program to test above function
int main()
{
generateGrayarr(3);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
//Represent a node of singly linked list
struct node{
int data;
struct node *next;
};
//Represent the head and tail of the singly linked list
struct node *head, *tail = NULL;
//addNode() will add a new node to the list
void addNode(int data) {
//Create a new node
struct node *newNode = (struct node*)malloc(sizeof(struct node));
newNode->data = data;
newNode->next = NULL;
//Checks if the list is empty
if(head == NULL) {
//If list is empty, both head and tail will point to new node
head = newNode;
tail = newNode;
}
else {
//newNode will be added after tail such that tail's next will point to newNode
tail->next = newNode;
//newNode will become new tail of the list
tail = newNode;
}
}
//display() will display all the nodes present in the list
void display() {
//Node current will point to head
struct node *current = head;
if(head == NULL) {
printf("List is empty
");
return;
}
printf("Nodes of singly linked list:
");
while(current != NULL) {
//Prints each node by incrementing pointer
printf("%d ", current->data);
current = current->next;
}
printf("
");
}
int main()
{
//Add nodes to the list
addNode(1);
addNode(2);
addNode(3);
addNode(4);
//Displays the nodes present in the list
display();
return 0;
}
#include <stdio.h>
int main()
{
int num, max, min;
printf ("Enter four numbers: ");
scanf ("%d", &num);
max = min = num;
for (int i = 0; i < 3; i++)
{
scanf ("%d", &num);
if (max < num)
max = num;
else if (min > num)
min = num;
}
printf ("The smallest and largest of given four numbers are %d and %d respectively.
", min, max);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct _tree
{ char v[18];
int len, index, plus_l, plus_r;
struct _tree *l, *r;
} Tree;
void Ins(Tree **t, char *val, int val_len, int indeks)
{ if(!(*t))
{ *t = (Tree*)malloc(sizeof(Tree));
strcpy((*t)->v, val);
(*t)->len = val_len;
(*t)->index = indeks;
(*t)->plus_l = (*t)->plus_r = 0;
(*t)->l = (*t)->r = NULL;
}
else if(((*t)->len > val_len) || (((*t)->len == val_len) && (strcmp((*t)->v, val) > 0)))
{ if((*t)->r) Ins(&(*t)->r, val, val_len, 1);
else
{ Ins(&(*t)->r, val, val_len, (*t)->index + 1);
(*t)->plus_r = 0;
}
}
else
{ (*t)->index += 1;
(*t)->plus_r += 1;
if((*t)->l) Ins(&(*t)->l, val, val_len, 1);
else
{ Ins(&(*t)->l, val, val_len, (*t)->index - 1);
(*t)->plus_l = 0;
}
}
}
int Find(Tree **t, char *val, int val_len)
{ if(*t)
{ if(strcmp((*t)->v, val) == 0)
{ printf("%d
", (*t)->index);
return 1;
}
else if(((*t)->len > val_len) || (((*t)->len == val_len) && (strcmp((*t)->v, val) > 0)))
{ if((*t)->plus_r)
{ if((*t)->r)
{ int t_plus_r = (*t)->plus_r;
(*t)->r->index += t_plus_r;
(*t)->r->plus_l += t_plus_r;
(*t)->r->plus_r += t_plus_r;
}
(*t)->plus_r = 0;
}
return Find(&(*t)->r, val, val_len);
}
else
{ if((*t)->plus_l)
{ if((*t)->l)
{ int t_plus_l = (*t)->plus_l;
(*t)->l->index += t_plus_l;
(*t)->l->plus_l += t_plus_l;
(*t)->l->plus_r += t_plus_l;
}
(*t)->plus_l = 0;
}
return Find(&(*t)->l, val, val_len);
}
}
else return 0;
}
int main()
{ int T, cmd, len;
scanf("%d", &T);
Tree *t = NULL;
char val[18];
while(T--)
{ scanf("%d %s", &cmd, val);
len = strlen(val);
if(cmd == 1) Ins(&t, val, len, 1);
else if(!Find(&t, val, len)) printf("Data tidak ada
");
}
return 0;
}