Arrays lab work

package arrays;
public class arrays {
public static void main(String []args){
int[][] matrix1=new int[3][3];
for(int i=0;i<[Link];i++)
{
for(int j=0;j<[Link];j++)
{
matrix1[i][j]=(int)([Link]()*100);
[Link]("the index is: "+i+j+" and value is:
"+matrix1[i][j]);
}
}
//array addition
[Link]("Array Addition");
int b[][]={{1,2,3},{4,5,6},{7,8,9}};
int c[][]={{1,1,1},{2,2,2},{3,3,3}};
int d[][]= new int[3][3];
for (int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
d[i][j]=b[i][j]+c[i][j];
[Link](d[i][j]+" ");
}
[Link](" ");
}
//array multiplication
[Link]("Array Multiplication");
int e[][]={{1,2,3},{4,5,6},{7,8,9}};
int f[][]={{1,1,1},{2,2,2},{3,3,3}};
int g[][]= new int[3][3];
for (int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
g[i][j]=0;
for(int k=0;k<3;k++)
{
g[i][j]+=e[i][k]*f[k][j];
}
[Link](g[i][j]+" ");
}
[Link](" ");
}
}
}
===================================================================================
===============================================
Occurrence example 1
package occurrance;
import [Link];
public class Occurrance {

public static void main(String[] args) {

int x,count=0,i=0,max = 0;
Scanner s=new Scanner([Link]);
 int a[]=new int[6];

[Link]("Enter all the Elements: ");

for(i=0;i<[Link];i++)
{
a[i]=[Link]();

}
max=0;
for(int j=0;j<[Link];j++)
{
if(max<a[j])
{
max=a[j];
}
}
x=max;
for(int k=0;k<[Link];k++)
{
if(a[k]==x)
{
count++;
}
}
[Link]("Largest number is: "+max);
[Link]("Number of occurrances of element: "+count);
}

===================================================================================
===================================================================================
===================================================================================
========

Score grading example 2

package [Link];
import [Link];
public class GradingOnScore {

public static void main(String[] args) {

int marks[]=new int[6];
float total=0,average;
Scanner scanner=new Scanner([Link]);
for(int i=0;i<6;i++)
{
[Link]("Enter Marks of Subjects"+(i+1)+": ");
marks[i]=[Link]();
total=total+marks[i];
}
[Link]();
[Link]("Average");
average=total/6;
[Link]("The Students Grade is: ");
if(average>=90)
{
 [Link]("A ");
}
else if(average>=80&&average<90)
{
[Link]("B ");
}
else if(average>=70&&average<80)
{
[Link]("C ");
}
else if(average>=60&&average<70)
{
[Link]("D ");
}
else if(average>=50&&average<60)
{
[Link]("E ");
}
else
{
[Link]("F ");
}
}

===================================================================================
===================================================================================
===================================================================================
========

Standard deviation example 3

package [Link];

public class StandardDeviation {

public static void main(String[] args) {

int[] numbers=new int[]{12,11,14,14,16,18,19};
int sum=0;
int max=0;
int min=numbers[0];
double sd=0;
for(int i=0;i<[Link];i++)
{
int avg=0;
sd+=((numbers[i]-avg)*(numbers[i]-avg))/([Link]-1);
}
double StandardDeviation=[Link](sd);
[Link]("the standard deviation is: "+StandardDeviation);
}

===================================================================================
===================================================================================
===================================================================================
========
Counting occurrence of each letter example 4
package alphabets;
import [Link];
public class Alphabets {

public static void main(String[] args) {

char[] chars=createArray();
[Link]("The lower case letters are: ");
displayArray(chars);
int[] counts=countLetters(chars);
[Link]();
[Link]("The occurrences of each letters are");
displayCounts(counts);
}

private static char[] createArray() {

char[] chars=new char[100];
Random generator=new Random();
String S="abcdefghijklmnopqrstuvwxyz";
for(int i=0;i<[Link];i++)

chars[i]=(char)
[Link]([Link](26));
return chars;
}

private static void displayArray(char[] chars) {

for (int i=0;i<[Link];i++)
{
if((i+1)%20==0)
{
[Link](chars[i]+" ");
}
else
{
[Link](chars[i]+" ");
}
}
}

private static int[] countLetters(char[] chars) {

int[] counts=new int[26];
for (int i=0;i<[Link];i++)
counts[chars[i]-'a']++;
return counts;
}

private static void displayCounts(int[] counts) {

for(int i=0;i<[Link];i++)
{
if((i+1)%10==0)
{
[Link](counts[i]+" "+(char)(i+'a'));
}
else
{
[Link](counts[i]+" "+(char)(i+'a')+" ");
}
 }

[Link]("STANDARD DAVIATION");
int sum=0;
int max=0;
int min=counts[0];
double sd=0;
for(int i=0;i<[Link];i++)
{
int average=0;
sd+=((counts[i]-average)*(counts[i]-average))/([Link]-1);
double standardDeviation=[Link](sd);
[Link]("The standard deviation is: "+standardDeviation);
}

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
--------------------------------------
package stack;

public class Stack {

private int maxsize;

private long stackarray[];
private int top;

public Stack(int s)
{
maxsize =s;
stackarray=new long[maxsize];
top=-1;
}
public void push(long j)
{
stackarray[++top]=j;
}
public long pop()
{
return stackarray[top--];
}
public boolean isEmpty()
{
return(top==-1);
}
public static void main(String[] args)
{
Stack s= new Stack(5);
[Link](1);
[Link](2);
[Link](21);
[Link](31);
[Link](34);
[Link]("VALUES IS");
while(![Link]())
 {
long value =[Link]();
[Link](value);

}
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-----------

ackage queue1;

public class Queue1 {

private int arr[];

private int front;
private int rear;
private int count;
private int capacity;

Queue1(int size) {
arr = new int[size];
capacity = size;
front = 0;
rear = -1;
count = 0;

public void dequeue() {

if (isEmpty()) {
[Link]("UNDERFLOW \n PROGRAM TERMINATED");
[Link](1);
}
[Link]("REMOVING " + arr[front]);
front = (front + 1) % capacity;
count--;
}

public void enqueue(int item) {

if (isFull()) {
[Link]("OVRFLOW \n PROGRAM TERMINATED");
[Link](1);
}
[Link]("INSERTING " + item);
rear = (rear + 1) % capacity;
arr[rear] = item;
count++;
}

public int peek() {

if (isEmpty()) {
[Link]("UNDERFLOW \n PROGRAM TERMINATED");
[Link](1);
}
 return arr[front];
}

public int size() {

return count;
}

public Boolean isEmpty() {

return (size() == 0);
}

public Boolean isFull() {

return (size() == capacity);
}

public static void main(String[] args) {

Queue1 q = new Queue1(5);
[Link](7);
[Link](70);
[Link](71);
[Link]("FIRST ELEMENT " + [Link]());
[Link]();
[Link]("FIRST ELEMENT " + [Link]());
[Link]("SIZE IS " + [Link]());
[Link]();
[Link]();
if ([Link]()) {
[Link]("QUEUE IS EMPTY");
} else {
[Link]("QUEUE IS NOT EMPTY");
}

-----------------------------------------------------------------------------------
------------------------------------------------

package [Link];

public class BUBBLESORT {

public void sort(int mainarr[])

{
int n;
n = [Link];
boolean f;
f=false;
for(int a = 0;a<n-1;a++)
{
for (int b = 0;b<n-a-1;b++)
{
if (mainarr[b]>mainarr[b+1])
{
int temp;
temp = mainarr[b];
 mainarr[b] = mainarr[b+1];
mainarr[b+1] = temp;
[Link]("worst case");
f=true;
}

}
if(f== false)
{[Link]("best case executed");
break;
}
}
// for(int i= 0;i<[Link];i++)
//{
// [Link]("array:"+mainarr[i]);
//
//}

public static void main(String[] args) {

// TODO code application logic here
int arr[]={10,1,2,50,3,4};

BUBBLESORT obj = new BUBBLESORT();

[Link](arr);
for(int i= 0;i<[Link];i++)
{
[Link](" "+arr[i]);

}
}

-----------------------------------------------------------------------------------
------------------------------------------------------

package insertionsorting;

public class Insertionsorting {

public void sort (int mainarr [], int size)
{
boolean flag;
size= [Link];
int True = 0;
int False = 0;

[Link]("i V H C F");

for (int i=1 ; i<size;i++)

{
int value = mainarr[i];
int hole = i;
 while(hole >0 && mainarr[hole-1]>value)
{
mainarr[hole]=mainarr[hole-1];
hole = hole-1;
True++;
flag=true;
if (flag==true)
{
int z = 0;

if(hole == 0)
{
flag = false;
}
[Link](i+" "+ value+" "+ hole + " "+ hole + ">"+
z+"&&"+(hole-1)+" "+ flag);

}
False++;
flag = false;
mainarr[hole]=value;
}
[Link]("-------------------------------");
[Link]("\nTrue iterations: " + True);
[Link]("False iterations: " + False);
[Link]("Total iterations: " + (True+False) );
[Link]("\n-------------------------------");

public static void main(String[] args) {

Insertionsorting i = new Insertionsorting();
int arr[] = {66,63,4,7,67,539,70,21,2,42}; //Worst Case
int n=[Link];
[Link](arr, n);
[Link]();
[Link]("\nSorted array: ");

for ( int j = 0 ; j<n ; j ++){

[Link](arr[j]+" ");

}
-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
---------

package selectionsort;
public class Selectionsort {

void sort(int arr[]) {

int n = [Link];
for (int i = 0; i < n - 1; i++) {
int min_idx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[min_idx]) {
min_idx = j;
}
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}
}

void printarray(int arr[]) {

int n = [Link];
for (int i = 0; i < n; i++) {
[Link](arr[i]);

}
}

public static void main(String[] args) {

Selectionsort ob = new Selectionsort();
int arr[] = {30, 24, 13, 24, 80};
[Link](arr);
[Link]("SORTED ARRAY");
[Link](arr);
}

}
-----------------------------------------------------------------------------------
------------------------------------------------

package [Link];

public class QuickSort {

int partition(int arr[], int low, int high)
{
int pivot = arr[high];
int i = (low-1);
for (int j=low; j<high; j++)
{
if (arr[j] < pivot)
{
i++;

int temp = arr[i];

arr[i] = arr[j];
 arr[j] = temp;
}
}

int temp = arr[i+1];

arr[i+1] = arr[high];
arr[high] = temp;

return i+1;
}

void sort(int arr[], int low, int high)

{
if (low < high)
{

int pi = partition(arr, low, high);

sort(arr, low, pi-1);

sort(arr, pi+1, high);
}
}

static void printArray(int arr[])

{
int n = [Link];
for (int i=0; i<n; ++i)
[Link](arr[i]+" ");
[Link]();
}

public static void main(String[] args) {

int arr[] = {10, 7, 8, 9, 1, 5};
int n = [Link];

QuickSort ob = new QuickSort();

[Link](arr, 0, n-1);

[Link]("sorted array");
printArray(arr);

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
-------------------------------------------
binary treee

class Node
{
int key;
Node left, right;

public Node(int item)

 {
key = item;
left = right = null;
}
}

// A Java program to introduce Binary Tree

class BinaryTree
{
// Root of Binary Tree
Node root;

// Constructors
BinaryTree(int key)
{
root = new Node(key);
}

BinaryTree()
{
root = null;
}

public static void main(String[] args)

{
BinaryTree tree = new BinaryTree();

/*create root*/
[Link] = new Node(1);

/* following is the tree after above statement

1
/ \
null null */

[Link] = new Node(2);

[Link] = new Node(3);

/* 2 and 3 become left and right children of 1

1
/ \
2 3
/ \ / \
null null null null */

[Link] = new Node(4);

/* 4 becomes left child of 2
1
/ \
2 3
/ \ / \
4 null null null
/ \
null null
*/
}
}
===================================================================================
===================================================================================
==================================================