Bubble Sort

It’s really been a very long time since I had wrote something, So many things were going which were kind of keeping me very busy, But I finally managed to get some time.. yay!!! yepeee!!, So to continue my journey towards CS algorithms,  I had tried the Bubble Sort with single loop.

Steps are like:
For any given Array:
Take the first two elements and move the largest to the right, and keep doing that unless the largest reached at the position where either its the last position of array or the the position where its right is already the largest and then again repeat and do until all the largest values moves to the right side of array.

Here is the example: Your inputs are highly appreciated 🙂

import java.util.Arrays;

import java.util.Random;

public class BubbleSortV1 {

public static void main(String[] args) {

int[] arr = fillArray();

System.out.println(“Unsorted Array :: “ + Arrays.toString(arr));

bubbleSort(arr);

System.out.println(“Sorted Array :: “ + Arrays.toString(arr));

verifyArray(arr);

}

private static void verifyArray(int[] arr) {

booleans = true;

for (int i = 0; i < 99; i++) {

if (arr[i] > arr[i + 1]) {

System.out.println(“not sorted…”);

s = false;

break;

}

}

if (s) {

System.out.println(“all sorted;”);

}

}

static int[] fillArray() {

int[] arr = new int[100];

Random r = new Random();

for (int i = 0; i < 100; i++) {

arr[i] = r.nextInt(500);

}

returnarr;

}

// read from left to right and

// move the largest item to the right

// that way all large would be on right side and small on left side

static void bubbleSort(int[] arr) {

// store the last unsorted index

int sortedPartIndex = arr.length;

// first bucket

int leftBucketIndex = 0;

// second bucket

int rightBucketIndex = 1;

// keep running until sorted index reaches 0 (right to left)

while (sortedPartIndex > 0) {

if (arr[leftBucketIndex] > arr[rightBucketIndex]) {

int tempBucket = arr[rightBucketIndex];

arr[rightBucketIndex] = arr[leftBucketIndex];

arr[leftBucketIndex] = tempBucket;

}

leftBucketIndex++;

rightBucketIndex++;

if (rightBucketIndex >= sortedPartIndex) {

// decrement the sorted part index

sortedPartIndex = sortedPartIndex – 1;

// reste the left and right bucket index to default, to start

// over

leftBucketIndex = 0;

rightBucketIndex = 1;

}

}

}

}

Random Shuffle of Array

Example of how to do a random shuffle of any Given Array. This example is based on a very famous shuffle algorithm knows as Fisher Yates Shuffle. Could be useful to implement in Poker Game to shuffle cards in Java.

Main Steps are:

1. loop from n to 1

2. generate the random index number k such that  0 <= k <= the length of array

3. swap the values between the random index and current iteration index

See below link for more details on this.

http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

private static int[] shuffle(int[] a) {

Random rand = new Random();

for (int lc = a.length – 1; lc > 0; lc–) {

    int shuffleIdx = rand.nextInt(lc + 1);

    int v = a[shuffleIdx];

   a[shuffleIdx] = a[lc];

   a[lc] = v;

}

return a;

}

Code Bubble IDE

Hi,

I have worked on many different IDE’s (Integrated Development Environment) like Eclipse, Intellij, Jboss Studio, JCreator and few others, but working on code bubbles programming environment is unbelievable. Its pretty awesome…

Here is the video link on You Tube. Check this out.. if you really love to code on Java. Really hats off to the Code Bubble team.

 

Enjoy!!!

Phases of Java Class loading

Hi All,

This post is regarding the phases of class loading in any java based application.  I came across a very good write up material, and thought of sharing with all my blog users.

The loading of a class can essentially be broken down into three phases:
1. Loading
2. Linking
3. Initializing.

Most, if not all, problems relating to class loading can be tracked down to a problem occurring in one of these phases. Therefore, a thorough understanding of each phase helps in the diagnosing of class loading problems. The phases are illustrated in Figure 2

class loading

The loading phase consists of locating the required class file (by searching though the respective classpaths) and loading in the bytecode. Within the JVM, the loading process gives a very basic memory structure to the class object. Methods, fields, and other referenced classes are not dealt with at this stage. As a result, the class is not usable.


Linking
is the most complicated of the three phases. It can be broken down into three main stages:

  • Bytecode verification. The class loader does a number of checks on the bytecodes of the class to ensure that it is well-formed and well-behaved.
  • Class preparation. This stage prepares the necessary data structures that represent fields, methods, and implemented interfaces that are defined within each class.
  • Resolving. In this stage, the class loader loads all the other classes referenced by a particular class. The classes can be referenced in a number of ways:
    • Superclasses
    • Interfaces
    • Fields
    • Method signatures
    • Local variables used in methods

During the initializing phase, any static initializers contained within a class are executed. At the end of this phase, static fields are initialized to their default values.

At the end of these three phases, a class is fully loaded and is ready for use.

Note that class loading can be performed in a lazy manner and therefore some parts of the class loading process may be done on first use of the class rather than at load time.

Hope this helps.


Thanks
R Vashi