Admin: 1 версия

2010-06-01T05:04:29Z

1 версия

в 17:44, 31 мая 2010

2010-05-31T17:44:27Z

Новая страница

== Bubble Sort ==

<p>Here are the rules:</p>
<OL><LI>Compare two players.</LI><LI>If the one on the left is taller, swap them.</LI><LI>Move one position right.</LI></OL>



<source lang="java">
public class MainClass {
public static void main(String[] args) {
int[] intArray = new int[] { 2, 6, 3, 8, 4, 9, 1 };
for (int i : intArray) {
System.out.print(i);
}
System.out.println();
bubbleSort(intArray);
for (int i : intArray) {
System.out.print(i);
}
}
public static void bubbleSort(int[] intArray) {
int out, in;
for (out = intArray.length - 1; out > 0; out--) {
for (in = 0; in < out; in++) {
if (intArray[in] > intArray[in + 1]) {
swap(intArray, in, in + 1);
}
}
}
}
private static void swap(int[] intArray, int one, int two) {
int temp = intArray[one];
intArray[one] = intArray[two];
intArray[two] = temp;
}
}</source>



<pre class=codeResult>2638491
1234689</pre>

== Generic Merge Sorter with generic Comparator ==



<source lang="java">
import java.util.ruparator;

public class AnimationTester {
public static void main(String[] args) {
Integer[] values = new Integer[]{1,2,7,3,5};
Comparator<Integer> comp = new Comparator<Integer>() {
public int compare(Integer d1, Integer d2) {
return d1.rupareTo(d2);
}
};
MergeSorter.sort(values, comp);
for (int i = 0; i < values.length; i++){
System.out.print(values[i]+" ");
}

}
}
class MergeSorter {
public static <E> void sort(E[] a, Comparator<? super E> comp) {
mergeSort(a, 0, a.length - 1, comp);
}

private static <E> void mergeSort(E[] a, int from, int to, Comparator<? super E> comp) {
if (from == to)
return;
int mid = (from + to) / 2;
// Sort the first and the second half
mergeSort(a, from, mid, comp);
mergeSort(a, mid + 1, to, comp);
merge(a, from, mid, to, comp);
}
private static <E> void merge(E[] a, int from, int mid, int to, Comparator<? super E> comp) {
int n = to - from + 1;
Object[] values = new Object[n];
int fromValue = from;
int middleValue = mid + 1;
int index = 0;
while (fromValue <= mid && middleValue <= to) {
if (comp.rupare(a[fromValue], a[middleValue]) < 0) {
values[index] = a[fromValue];
fromValue++;
} else {
values[index] = a[middleValue];
middleValue++;
}
index++;
}
while (fromValue <= mid) {
values[index] = a[fromValue];
fromValue++;
index++;
}
while (middleValue <= to) {
values[index] = a[middleValue];
middleValue++;
index++;
}
for (index = 0; index < n; index++)
a[from + index] = (E) values[index];
}
}</source>



== Insertion Sort ==



<source lang="java">
public class MainClass {
public static void main(String[] args) {
int[] intArray = new int[] { 2, 6, 3, 8, 4, 9, 1 };
for (int i : intArray) {
System.out.print(i);
}
System.out.println();
insertionSort(intArray);
for (int i : intArray) {
System.out.print(i);
}
}
public static void insertionSort(int[] intArray) {
int in, out;
for (out = 1; out < intArray.length; out++) {
int temp = intArray[out];
in = out;
while (in > 0 && intArray[in - 1] >= temp) {
intArray[in] = intArray[in - 1];
--in;
}
intArray[in] = temp;
}
}
private static void swap(int[] intArray, int one, int two) {
int temp = intArray[one];
intArray[one] = intArray[two];
intArray[two] = temp;
}
}</source>



<pre class=codeResult>2638491
1234689</pre>

== Mergesort: merging two arrays into a third ==



<source lang="java">
public class MainClass {
public static void main(String[] args) {
int[] arrayA = { 23, 47, 81, 95 };
int[] arrayB = { 7, 14, 39, 55, 62, 74 };
int[] arrayC = new int[10];
merge(arrayA, arrayA.length, arrayB, arrayB.length, arrayC);
for (int i : arrayC) {
System.out.println(i);
}
}
public static void merge(int[] arrayA, int sizeA, int[] arrayB, int sizeB, int[] arrayC) {
int arrayAIndex = 0, arrayBIndex = 0, arrayCIndex = 0;
while (arrayAIndex < sizeA && arrayBIndex < sizeB)
if (arrayA[arrayAIndex] < arrayB[arrayBIndex])
arrayC[arrayCIndex++] = arrayA[arrayAIndex++];
else
arrayC[arrayCIndex++] = arrayB[arrayBIndex++];
while (arrayAIndex < sizeA)
arrayC[arrayCIndex++] = arrayA[arrayAIndex++];
while (arrayBIndex < sizeB)
arrayC[arrayCIndex++] = arrayB[arrayBIndex++];
}
}</source>



<pre class=codeResult>7
14
23
39
47
55
62
74
81
95</pre>

== Quicksort: simple version of quick sort ==



<source lang="java">
public class MainClass {
public static void main(String[] args) {
int[] intArray = { 1, 9, 2, 8, 3, 7, 4, 6, 5 };
for (int i : intArray) {
System.out.println(i);
}
quickSort(intArray);
for (int i : intArray) {
System.out.println(i);
}
}
public static void quickSort(int[] intArray) {
recQuickSort(intArray, 0, intArray.length - 1);
}
private static void recQuickSort(int[] intArray, int left, int right) {
if (right - left <= 0)
return;
else {
int pivot = intArray[right];
int partition = partitionIt(intArray, left, right, pivot);
recQuickSort(intArray, left, partition - 1);
recQuickSort(intArray, partition + 1, right);
}
}
private static int partitionIt(int[] intArray, int left, int right, int pivot) {
int leftPtr = left - 1;
int rightPtr = right;
while (true) {
while (intArray[++leftPtr] < pivot)
;
while (rightPtr > 0 && intArray[--rightPtr] > pivot)
;
if (leftPtr >= rightPtr)
break;
else
swap(intArray, leftPtr, rightPtr);
}
swap(intArray, leftPtr, right);
return leftPtr;
}
private static void swap(int[] intArray, int dex1, int dex2) {
int temp = intArray[dex1];
intArray[dex1] = intArray[dex2];
intArray[dex2] = temp;
}
}</source>



<pre class=codeResult>1
9
2
8
3
7
4
6
5
1
2
3
4
5
6
7
8
9</pre>

== Quick sort: uses an insertion sort to handle subarrays of fewer than 10 cells ==



<source lang="java">
public class MainClass {
public static void main(String[] args) {
int[] intArray = { 1, 9, 2, 8, 3, 7, 4, 6, 5 };
for (int i : intArray) {
System.out.println(i);
}
quickSort(intArray);
for (int i : intArray) {
System.out.println(i);
}
}
public static void quickSort(int[] intArray) {
recQuickSort(intArray, 0, intArray.length - 1);
insertionSort(intArray, 0, intArray.length - 1);
}
public static void recQuickSort(int[] intArray, int left, int right) {
int size = right - left + 1;
if (size < 10)
insertionSort(intArray, left, right);
else {
double median = medianOf3(intArray, left, right);
int partition = partitionIt(intArray, left, right, median);
recQuickSort(intArray, left, partition - 1);
recQuickSort(intArray, partition + 1, right);
}
}
public static double medianOf3(int[] intArray, int left, int right) {
int center = (left + right) / 2;
if (intArray[left] > intArray[center])
swap(intArray, left, center);
if (intArray[left] > intArray[right])
swap(intArray, left, right);
if (intArray[center] > intArray[right])
swap(intArray, center, right);
swap(intArray, center, right - 1);
return intArray[right - 1];
}
public static void swap(int[] intArray, int dex1, int dex2) {
int temp = intArray[dex1];
intArray[dex1] = intArray[dex2];
intArray[dex2] = temp;
}
public static int partitionIt(int[] intArray, int left, int right, double pivot) {
int leftPtr = left;
int rightPtr = right - 1;
while (true) {
while (intArray[++leftPtr] < pivot)
;
while (intArray[--rightPtr] > pivot)
;
if (leftPtr >= rightPtr)
break;
else
swap(intArray, leftPtr, rightPtr);
}
swap(intArray, leftPtr, right - 1);
return leftPtr;
}
public static void insertionSort(int[] intArray, int left, int right) {
int in, out;
for (out = left + 1; out <= right; out++) {
int temp = intArray[out];
in = out;
while (in > left && intArray[in - 1] >= temp) {
intArray[in] = intArray[in - 1];
--in;
}
intArray[in] = temp;
}
}
}</source>



<pre class=codeResult>1
9
2
8
3
7
4
6
5
1
2
3
4
5
6
7
8
9</pre>

== Quick sort with median-of-three partitioning ==



<source lang="java">
public class MainClass {
public static void main(String[] args) {
int[] intArray = { 1, 9, 2, 8, 3, 7, 4, 6, 5 };
for (int i : intArray) {
System.out.println(i);
}
quickSort(intArray);
for (int i : intArray) {
System.out.println(i);
}
}
public static void quickSort(int[] intArray) {
recQuickSort(intArray, 0, intArray.length - 1);
}
public static void recQuickSort(int[] intArray, int left, int right) {
int size = right - left + 1;
if (size <= 3)
manualSort(intArray, left, right);
else {
double median = medianOf3(intArray, left, right);
int partition = partitionIt(intArray, left, right, median);
recQuickSort(intArray, left, partition - 1);
recQuickSort(intArray, partition + 1, right);
}
}
public static int medianOf3(int[] intArray, int left, int right) {
int center = (left + right) / 2;
if (intArray[left] > intArray[center])
swap(intArray, left, center);
if (intArray[left] > intArray[right])
swap(intArray, left, right);
if (intArray[center] > intArray[right])
swap(intArray, center, right);
swap(intArray, center, right - 1);
return intArray[right - 1];
}
public static void swap(int[] intArray, int dex1, int dex2) {
int temp = intArray[dex1];
intArray[dex1] = intArray[dex2];
intArray[dex2] = temp;
}
public static int partitionIt(int[] intArray, int left, int right, double pivot) {
int leftPtr = left;
int rightPtr = right - 1;
while (true) {
while (intArray[++leftPtr] < pivot)
;
while (intArray[--rightPtr] > pivot)
;
if (leftPtr >= rightPtr)
break;
else
swap(intArray, leftPtr, rightPtr);
}
swap(intArray, leftPtr, right - 1);
return leftPtr;
}
public static void manualSort(int[] intArray, int left, int right) {
int size = right - left + 1;
if (size <= 1)
return;
if (size == 2) {
if (intArray[left] > intArray[right])
swap(intArray, left, right);
return;
} else {
if (intArray[left] > intArray[right - 1])
swap(intArray, left, right - 1);
if (intArray[left] > intArray[right])
swap(intArray, left, right);
if (intArray[right - 1] > intArray[right])
swap(intArray, right - 1, right);
}
}
}</source>



<pre class=codeResult>1
9
2
8
3
7
4
6
5
1
2
3
4
5
6
7
8
9</pre>

== Selection Sort ==



<source lang="java">
public class MainClass {
public static void main(String[] args) {
int[] intArray = new int[] { 2, 6, 3, 8, 4, 9, 1 };
for (int i : intArray) {
System.out.print(i);
}
System.out.println();
selectionSort(intArray);
for (int i : intArray) {
System.out.print(i);
}
}
public static void selectionSort(int[] intArray) {
for (int out = 0; out < intArray.length - 1; out++) {
int min = out;
for (int in = out + 1; in < intArray.length; in++)
if (intArray[in] < intArray[min])
min = in;
swap(intArray, out, min);
}
}
private static void swap(int[] intArray, int one, int two) {
int temp = intArray[one];
intArray[one] = intArray[two];
intArray[two] = temp;
}
}</source>



<pre class=codeResult>2638491
1234689</pre>

== Shellsort ==



<source lang="java">
public class MainClass {
public static void main(String[] args) {
int[] intArray = { 1, 9, 2, 8, 3, 7, 4, 6, 5 };
for (int i : intArray) {
System.out.println(i);
}
shellSort(intArray);
System.out.println("after: ");
for (int i : intArray) {
System.out.println(i);
}
}
public static void shellSort(int[] intArray) {
int inner, outer;
int temp;
int h = 1;
while (h <= intArray.length / 3){
h = h * 3 + 1;
}
while (h > 0) {
for (outer = h; outer < intArray.length; outer++) {
temp = intArray[outer];
inner = outer;
while (inner > h - 1 && intArray[inner - h] >= temp) {
intArray[inner] = intArray[inner - h];
inner -= h;
}
intArray[inner] = temp;
}
h = (h - 1) / 3;
}
}
}</source>



<pre class=codeResult>1
9
2
8
3
7
4
6
5
after:
1
2
3
4
5
6
7
8
9</pre>

== Sorting Objects using insertion sort ==



<source lang="java">
class Person {
private String lastName;
private String firstName;
private int age;
public Person(String last, String first, int a) {
lastName = last;
firstName = first;
age = a;
}
public String toString() {
return "Last name: " + lastName + " First name: " + firstName + " Age: " + age;
}
public String getLast() {
return lastName;
}
}
public class MainClass {
public static void main(String[] args) {
Person[] persons = new Person[] {
new Person("a", "b", 23),
new Person("i", "a", 25),
new Person("y", "h", 26),
new Person("d", "e", 27) };
System.out.println("Before sorting:");
for (Person p : persons) {
System.out.println(p);
}
insertionSort(persons);
System.out.println("After sorting:");
for (Person p : persons) {
System.out.println(p);
}
}
public static void insertionSort(Person[] persons) {
int in, out;
for (out = 1; out < persons.length; out++) {
Person temp = persons[out];
in = out;
while (in > 0 && persons[in - 1].getLast().rupareTo(temp.getLast()) > 0) {
persons[in] = persons[in - 1];
--in;
}
persons[in] = temp;
}
}
}</source>



<pre class=codeResult>Last name: y First name: h Age: 26
Last name: d First name: e Age: 27
After sorting:
Last name: a First name: b Age: 23
Last name: d First name: e Age: 27
Last name: i First name: a Age: 25
Last name: y First name: h Age: 26</pre>

← Предыдущая	Версия 05:04, 1 июня 2010
(нет различий)

Java Tutorial/Collections/Sort - История изменений

Admin: 1 версия

в 17:44, 31 мая 2010