Write A Java Program To Implement Quick Sort of Given Elements

11.Aim: Write a java program to implement Quick Sort of given elements.
Program:
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Random;
public class QuickSort {
static int partition(int[] array, int low, int high) {
int j, temp, i = low + 1;
Random random = new Random();
int x = random.nextInt(high - low) + low;
temp = array[low];
array[low] = array[x];
array[x] = temp;
for (j = low + 1; j <= high; j++) {
if (array[j] <= array[low] && j != i) {
temp = array[j];
array[j] = array[i];
array[i++] = temp;
} else if (array[j] <= array[low]) {
i++;
}
temp = array[i - 1];
array[i - 1] = array[low];
array[low] = temp;
return i - 1;
// Function to implement quick sort
static void quickSort(int[] array,int low,int high){
if(low<high){
int mid = partition(array,low,high);
quickSort(array,low,mid-1);
quickSort(array,mid+1,high);
// Function to read user input
public static void main(String[] args) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int size;
System.out.println("Enter the size of the array");
try {
size = Integer.parseInt(br.readLine());
} catch (Exception e) {
System.out.println("Invalid Input");
return;
int[] array = new int[size];

System.out.println("Enter array elements");
int i;
for (i = 0; i < array.length; i++) {
try {
array[i] = Integer.parseInt(br.readLine());
// System.out.println("entered elements" +array[i] );
} catch (Exception e) {
System.out.println("An error Occurred");
System.out.println("The initial array is");
System.out.println(Arrays.toString(array));
quickSort(array,0,array.length-1);
System.out.println("The sorted array is");
System.out.println(Arrays.toString(array));
Output: Enter the size of the array

4
Enter array elements
2
45
85
1
The initial array is
[2, 45, 85, 1]
The sorted array is
[1, 2, 45, 85]
12.Aim: Write a java program to implement various operations on AVL trees
Program: package inter;

import java.util.Scanner;
class AVLNode
{
AVLNode left, right;
int data;
int height;
public AVLNode()
{
left = null;
right = null;
data = 0;
height = 0;
}
public AVLNode(int n)
{
left = null;
right = null;
data = n;
height = 0;
}
}
class AVLTree
{
private AVLNode root;
/* Constructor */
public AVLTree()
{
root = null;
}
/* Function to check if tree is empty */
public boolean isEmpty()
{
return root == null;
}
/* Make the tree logically empty */
public void makeEmpty()
{
root = null;
}
/* Function to insert data */
public void insert(int data)
{
root = insert(data, root);
}
/* Function to get height of node */
private int height(AVLNode t )
{
return t == null ? -1 : t.height;
}
/* Function to max of left/right node */
private int max(int lhs, int rhs)
{
return lhs > rhs ? lhs : rhs;
}
/* Function to insert data recursively */
private AVLNode insert(int x, AVLNode t)
{
if (t == null)
t = new AVLNode(x);
else if (x < t.data)
{
t.left = insert( x, t.left );
if( height( t.left ) - height( t.right ) == 2 )
if( x < t.left.data )
t = rotateWithLeftChild( t );
else
t = doubleWithLeftChild( t );
}
else if( x > t.data )
{
t.right = insert( x, t.right );
if( height( t.right ) - height( t.left ) == 2 )
if( x > t.right.data)
t = rotateWithRightChild( t );
else
t = doubleWithRightChild( t );
}
else
; // Duplicate; do nothing
t.height = max( height( t.left ), height( t.right ) ) + 1;
return t;
}
/* Rotate binary tree node with left child */
private AVLNode rotateWithLeftChild(AVLNode k2)
{
AVLNode k1 = k2.left;
k2.left = k1.right;
k1.right = k2;
k2.height = max( height( k2.left ), height( k2.right ) ) + 1;
k1.height = max( height( k1.left ), k2.height ) + 1;
return k1;
}
/* Rotate binary tree node with right child */

private AVLNode rotateWithRightChild(AVLNode k1)
{
AVLNode k2 = k1.right;
k1.right = k2.left;
k2.left = k1;
k1.height = max( height( k1.left ), height( k1.right ) ) + 1;
k2.height = max( height( k2.right ), k1.height ) + 1;
return k2;
}
/**
* Double rotate binary tree node: first left child
* with its right child; then node k3 with new left child */
private AVLNode doubleWithLeftChild(AVLNode k3)
{
k3.left = rotateWithRightChild( k3.left );
return rotateWithLeftChild( k3 );
}
/**
* Double rotate binary tree node: first right child
* with its left child; then node k1 with new right child */
private AVLNode doubleWithRightChild(AVLNode k1)
{
k1.right = rotateWithLeftChild( k1.right );
return rotateWithRightChild( k1 );
}
/* Functions to count number of nodes */
public int countNodes()
{
return countNodes(root);
}
private int countNodes(AVLNode r)
{
if (r == null)
return 0;
else
{
int l = 1;
l += countNodes(r.left);
l += countNodes(r.right);
return l;
}
}
/* Functions to search for an element */
public boolean search(int val)
{
return search(root, val);
}
private boolean search(AVLNode r, int val)
{
boolean found = false;
while ((r != null) && !found)
{
int rval = r.data;
if (val < rval)
r = r.left;
else if (val > rval)
r = r.right;
else
{
found = true;
break;
}
found = search(r, val);
}
return found;
}
/* Function for inorder traversal */
public void inorder()
{
inorder(root);
}
private void inorder(AVLNode r)
{
if (r != null)
{
inorder(r.left);
System.out.print(r.data +" ");
inorder(r.right);
}
}
/* Function for preorder traversal */
public void preorder()
{
preorder(root);
}
private void preorder(AVLNode r)
{
if (r != null)
{
preorder(r.left);
preorder(r.right);
}
}
/* Function for postorder traversal */
public void postorder()
{
postorder(root);
}
private void postorder(AVLNode r)
{
if (r != null)
{
postorder(r.left);
postorder(r.right);
}
}
}
/* Class AVL Tree Test */

public class AVLTreeTest
{
public static void main(String[] args)
{
Scanner scan = new Scanner(System.in);
/* Creating object of AVLTree */
AVLTree avlt = new AVLTree();
System.out.println("AVLTree Tree Test\n");
char ch;
/* Perform tree operations */
do
{
System.out.println("\nAVLTree Operations\n");
System.out.println("1. insert ");
System.out.println("2. search");
System.out.println("3. count nodes");
System.out.println("4. check empty");
System.out.println("5. clear tree");
int choice = scan.nextInt();

switch (choice)
{
case 1 :
System.out.println("Enter integer element to insert");
avlt.insert( scan.nextInt() );
break;
case 2 :
System.out.println("Enter integer element to search");
System.out.println("Search result : "+ avlt.search( scan.nextInt()
));
break;
case 3 :
System.out.println("Nodes = "+ avlt.countNodes());
break;
case 4 :
System.out.println("Empty status = "+ avlt.isEmpty());
break;
case 5 :
System.out.println("\nTree Cleared");
avlt.makeEmpty();
break;
default :
System.out.println("Wrong Entry \n ");
break;
}
/* Display tree */
System.out.print("\nPost order : ");
avlt.postorder();
System.out.print("\nPre order : ");
avlt.preorder();
System.out.print("\nIn order : ");
avlt.inorder();
System.out.println("\nDo you want to continue (Type y or n) \n");

ch = scan.next().charAt(0);
} while (ch == 'Y'|| ch == 'y');
}
}
Output:
AVLTree Tree Test
AVLTree Operations
1. insert
2. search
3. count nodes
4. check empty
5. clear tree
4
Empty status = true
Post order :
Pre order :
In order :
Do you want to continue (Type y or n)
AVLTree Operations
1. insert
2. search
3. count nodes
4. check empty
5. clear tree
1
Enter integer element to insert
10
Post order : 10
Pre order : 10
In order : 10

Write A Java Program To Implement Quick Sort of Given Elements

Uploaded by

Document Informationclick to expand document information

Copyright:

Available Formats

Write A Java Program To Implement Quick Sort of Given Elements

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Write A Java Program To Implement Quick Sort of Given Elements

Uploaded by

Copyright:

Available Formats

11.Aim: Write a java program to implement Quick Sort of given elements.

public class QuickSort {

static int partition(int[] array, int low, int high) {

int j, temp, i = low + 1;

Random random = new Random();

int x = random.nextInt(high - low) + low;

for (j = low + 1; j <= high; j++) {

if (array[j] <= array[low] && j != i) {

} else if (array[j] <= array[low]) {

// Function to implement quick sort

static void quickSort(int[] array,int low,int high){

int mid = partition(array,low,high);

// Function to read user input

public static void main(String[] args) {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

System.out.println("Enter the size of the array");

int[] array = new int[size];

for (i = 0; i < array.length; i++) {

// System.out.println("entered elements" +array[i] );

System.out.println("An error Occurred");

System.out.println("The initial array is");

System.out.println("The sorted array is");

Output: Enter the size of the array

Program: package inter;

/* Rotate binary tree node with right child */

/* Class AVL Tree Test */

int choice = scan.nextInt();

System.out.println("\nDo you want to continue (Type y or n) \n");

You might also like