vb.net code to generate barcode SORTING in Java

Generate EAN13 in Java SORTING

a[3] 99 66

a[4] 66 99 33

a[5] 33

a[6] 22

a[7] 88

a[8] 77

99 22

99 88

99 77

88 33

88 22

88 77 77 88 88

33 33 33 22 44 22 33 55 22 44

66 22 55

d. Trace of the selection sort:

a[0] 44 22 a[1] 88 33 44 55 77 88 a[2] 55 a[3] 99 a[4] 66 a[5] 33 88 55 99 88 99 a[6] 22 44 a[7] 88 a[8] 77

e. Trace of the insertion sort:

a[0] 44 a[1] 88 55 44 33 a[2] 55 88 66 55 44 a[3] 99 88 66 55 a[4] 66 99 88 66 a[5] 33 a[6] 22 a[7] 88 a[8] 77

33 22

99 88 77

99 88 88

99 88

f. Trace of the merge sort:

a[0] 44 44 a[1] 88 55 a[2] 55 77 a[3] 99 99 a[4] 66 33 22 66 a[5] 33 66 33 77 66 88 77 77 88 88 88 99 a[6] 22 a[7] 88 a[8] 77

CHAP. 14]

public static void sort(int[] a) { for (int i = a.length-1; i > 0; i--) { for (int j = 0; j < i; j++) { if (a[j] > a[j+1]) { swap(a, j, j+1); } } } } public static void sort(int[] a) { boolean sorted=false; int i = a.length-1; while (i > 0 && !sorted) { for (int j = 0; j < i; j++) { sorted = true; if (a[j] > a[j+1]) { swap(a, j, j+1); sorted = false; } } --i; } }

The loop invariant can be used to prove that the bubble sort does indeed sort the array. After the first iteration of the main i loop, the largest element must have moved to the last position. Wherever it began, it had to be moved step by step all the way to the right, because on each comparison the larger element is moved right. For the same reason, the second largest element must have been moved to the second-from-last position in the second iteration of the main i loop. So the two largest elements are in the correct locations. This reasoning verifies that the loop invariant is true at the end of every iteration of the main i loop. But then, after the last iteration, the n-1 largest elements must be in their correct locations. That forces the nth largest (i.e., the smallest) element also to be in its correct location, so the array must be sorted. The complexity function O(n2) means that, for large values of n, the number of loop iterations tends to be proportional to n2. That means that, if one large array is twice the size of another, it should take about four times as long to sort. The inner j loop iterates n 1 times on the first iteration of the outside i loop, n 2 times on the second iteration of the i loop, n 3 times on the third iteration of the i loop, and so on. For example, when n = 7, there are six comparisons made on the first iteration of the i loop, five comparisons made on the second iteration of the i loop, four comparisons made on the third iteration of the i loop, and so forth, so the total number of comparisons is 6 + 5 + 4 + 3 + 2 + 1 = 21. In general, the total number of comparisons will be (n 1) + (n 2) + (n 3) + + 3 + 2 + 1. This sum is n(n 1)/2. (See Theorem A.7 on page 323.) For large values of n, that expression is nearly n2/2 which is proportional to n2.

public static void sort(int[] a) { boolean sorted=false; for (int i = a.length; i > 0; i -= 2) { for (int j = 1; j < i; j++) { if (a[j-1] > a[j]) { swap(a,j-1,j); } } for (int j = i-2; j > 0; j--) { if (a[j-1] > a[j]) { swap(a, j-1, j); } } } }