Question

I need the report like this (idea)

*Sorting Algorithms:

A sorting algorithm is an algorithm that puts elements of a list in a certain order. The most-used orders are numerical order and lexicographical order. Efficient sorting is important for optimizing the use of other algorithms (such as search and merge algorithms) which require input data to be in sorted lists; it is also often useful for canonical zing data and for producing human-readable output. More formally, the output must satisfy two conditions:

1. The output is in no decreasing order (each element is no smaller than the previous element according to the desired total order).

2. The output is a permutation (reordering) of the input.
Further, the data is often taken to be in an array, which allows random access, rather than a list, which only allows sequential access, though often algorithms can be applied with suitable modification to either type of data.

Some Popular Sorting Algorithms:

• Selection sort:

Selection sort is an in-place comparison sort. It has complexity, making it inefficient on large lists, and generally performs worse than the similar insertion sort. Selection sort is noted for its simplicity, and has performance advantages over more complicated algorithms in certain situations.


• Merge sort:

Merge sort takes advantage of the ease of merging already sorted lists into a new-sorted list. It starts by comparing every two elements (i.e., 1 with 2, then 3 with 4...) and swapping them if the first should come after the second. It then merges each of the resulting lists of two into lists of four, then merges those lists of four, and so on; until at last two lists are merged into the final sorted list.



• Heap sort:
Heap sort is a much more efficient version of selection sort. It also works by determining the largest (or smallest) element of the list, placing that at the end (or beginning) of the list, then continuing with the rest of the list, but accomplishes this task efficiently by using a data structure called a heap, a special type of binary tree. Once the data list has been made into a heap, the root node is guaranteed to be the largest (or smallest) element. When it is removed and placed at the endp of the array).

Instead of searching an array as a whole, the bubble sort works by comparing adjacent pairs of the objects in the array. If the objects are not in the correct order, they are swapped, so that the largest of the two moves up. This process continues until the largest of the objects, eventually “bubbles” up to the highest position in the array. After this occurs, the search for the next largest object begins. The swapping continues until the whole array is in the correct order.

* How Bubble Sort works?


The process is simple, you keep comparing pairs of adjacent elements of the sequence, if the they are in the wrong order swap them and do this till there are no swapping to do.


Ex: Sort an array {5, 3, 1, 4, 2} using Bubble Sort

• {5,3,1,4,2} Compare first two, as 5 > 3, they are swapped

• {3,5,1,4,2} Again compare next two, as 5 >1, they are swapped

• {3, 1,5,4,2} Like this it keep swapping and iterate [go through] all the elements once to get this.

• {3, 1,4,2,5} Now they start doing the second run, compare 3 & 1, as 3> 1 they are swapped.

• {1,3,4,2,5} compare 3,4 they are in correct order

Likewise, you compare until no swaps occur while examining the whole sequence and then the function says "I am done with this" and the looping stops.


Bubble Sort Flow Chart:













Bubble Sort C++ Code:

for( i=n-1, i >1, i++){ for( i=1, i <=n, i++){ for( j=n-1, j >=i, j-){ if (a[j]<a[j-1]) {int t = a[j] a[j] = a[j-1] a[j-1] = t; }

}

}

}



Mips code:

.data
msg1: .asciiz "\nEnter integer values followed by return (-1 terminates input):/n " msg2: .asciiz "," msg3: .asciiz "Bubble Sort" msg4: .asciiz "#########pass#########"
msg5: .asciiz "\n"
msg6: .asciiz "\nNumber list has been sorted\n"
.text
.globl main main:
move $s0,$gp
save array #get the intial pointer to
# $t0 = 1
# Intial value for t
addi $t0,$zero,1
add $t1,$zero,$zero
Rigesters
# Intial value t2=0
# t3=0
add $t2,$zero,$zero
add $t3,$zero,$zero
add $t6,$zero,$zero
add $t4,$zero,$zero
sub $t7,$zero,1 # terminate
li $v0,4 # system call to put the string
la $a0,msg1 # //
syscall #//

Answer 1

Here is the code for you:

class InsertionAndSelectionSort
{
    public static int[] sortSelection(int[] array)
    {
       int min, temp;
       for (int i = 0; i < array.length-1; i++)
       {
          min = i;
for (int j = i+1; j < array.length; j++)
if (array[j] < array[min])
min = j;
temp = array[min];
array[min] = array[i];
array[i] = temp;
}
return array;
    }
   
    public static int[] sortInsertion(int[] array)
    {
       for (int i = 1; i < array.length; i++)
{
int key = array[i];
int position = i;
  
// shift larger values to the right
while (position > 0 && array[position-1] > key)
{
array[position] = array[position-1];
position--;
}
  
array[position] = key;
}
return array;
    }
   
    public static void printArray(int[] array)
    {
       System.out.print("[");
       for(int i = 0; i < array.length; i++)
           System.out.print(array[i] + " ");
       System.out.println("]");  
    }
    public static void main(String[] args)
    {
       int[] array1 = {9, 13, 5, 15, 2, 10, 12, 3, 14, 7};
       int[] array2 = {9, 13, 5, 15, 2, 10, 12, 3, 14, 7};
       System.out.print("Original array: ");
       printArray(array1);
       System.out.print("Sorted Using Insertion Sort: ");
       array1 = sortInsertion(array1);
       printArray(array1);
       System.out.println();
       System.out.print("Original array: ");
       printArray(array2);
       System.out.print("Sorted Using Selection Sort: ");
       array2 = sortSelection(array2);
       printArray(array2);
      
    }
}

And the output screenshot is: