Experiment Title:10

Student Name: Jatin Sharma UID: 19BCS3768

Branch: CSE big data and analytics Lab Group: GRP A
Semester: 5th Date of Performance: 10/11/21
Subject Name: AP lab Subject Code:

1. Aim/Overview of the practical: Array operations

2. Task to be done: A left rotation operation on a vector of size N shifts each of the array's
elements 1 unit to the left. For example, if 2 left rotations are performed on array
[1,2,3,4,5], then the array would become [3,4,5,1,3]. Given a vector of n integers and a
number, d, perform d left rotations on the array. Then print the updated array as a single
line of space-separated integers. Print a single line of n space-separated integers denoting
the final state of the array after performing d left rotations

3. Algorithm/Flowchart (For programming based labs):

Steps1: Create a new node
Step2: Perform stranded BTS insert
Step3: Perform Left Right Rotation as per requirement
Step4: Perform BTS delete
Steps5: Arrange the user input no. as per priority
Steps6: Stop
4. Steps for experiment/practical:

#include <bits/stdc++.h>
using namespace std;
struct TreapNode
{
int key, priority;
TreapNode *left, *right;
};
TreapNode *rightRotate(TreapNode *y)
{
TreapNode *x = y->left, *T2 = x->right;
x->right = y;
y->left = T2;
return x;
}
TreapNode *leftRotate(TreapNode *x)
{
TreapNode *y = x->right, *T2 = y->left;
y->left = x;
x->right = T2;
return y;
}
TreapNode* newNode(int key)
{
TreapNode* temp = new TreapNode;
temp->key = key;
temp->priority = rand()%100;
temp->left = temp->right = NULL;
return temp;
}
TreapNode* search(TreapNode* root, int key)
{
if (root == NULL || root->key == key)
return root;
if (root->key < key)
return search(root->right, key);
return search(root->left, key);
}
TreapNode* insert(TreapNode* root, int key)
{
if (!root)
return newNode(key);
if (key <= root->key)
{
root->left = insert(root->left, key);
if (root->left->priority > root->priority)
root = rightRotate(root);
}
else
{
root->right = insert(root->right, key);
if (root->right->priority > root->priority)
root = leftRotate(root);
}
return root;
}
TreapNode* deleteNode(TreapNode* root, int key)
{
if (root == NULL)
return root;

if (key < root->key)

root->left = deleteNode(root->left, key);
else if (key > root->key)
root->right = deleteNode(root->right, key);
else if (root->left == NULL)
{
TreapNode *temp = root->right;
delete(root);
 root = temp;
}
else if (root->right == NULL)
{
TreapNode *temp = root->left;
delete(root);
root = temp;
}
else if (root->left->priority < root->right->priority)
{
root = leftRotate(root);
root->left = deleteNode(root->left, key);
}
else
{
root = rightRotate(root);
root->right = deleteNode(root->right, key);
}

return root;
}
void inorder(TreapNode* root)
{
if (root)
{
inorder(root->left);
cout << "key: "<< root->key << " | priority: %d "
<< root->priority;
if (root->left)
cout << " | left child: " << root->left->key;
if (root->right)
cout << " | right child: " << root->right->key;
cout << endl;
inorder(root->right);
}
}
int main()
{
srand(time(NULL));
 struct TreapNode *root = NULL;
root = insert(root, 1);
root = insert(root, 2);
root = insert(root, 3);
root = insert(root, 4);
root = insert(root, 5);

cout << "Inorder traversal \n";

inorder(root);

cout << "\nDelete 20\n";

root = deleteNode(root, 2);
cout << "modified tree \n";
inorder(root);

cout << "\nDelete 30\n";

root = deleteNode(root, 3);
cout << " modified tree \n";
inorder(root);

cout << "\nDelete 50\n";

root = deleteNode(root, 5);
cout << "modified tree \n";
inorder(root);

TreapNode *res = search(root, 5);

(res == NULL)? cout << "\n50 Not Found ":
cout << "\n50 found";

return 0;
}

6. Theorems /Formulas used etc :

7. Result/Output/Writing Summary:
Conclusion/ Remarks:

1. Learn About Insert in Trep

2. Learn about Delete in Trep

3. Learn about BTS