<pre name="code" class="java">package com.my.study.algorithm.sort;
import java.util.Arrays;
public class QuickSort {
private static double[] arrays = { 1.1, 0.5, 2.4, 2, 4, 10, 4.6, 2.9, -0.6,
-6, 29, 5 };
private static void quickSort(double[] datas, int p, int r) {
if (p < r) {
int q = getPartition(datas, p, r);
quickSort(datas, p, q - 1);
quickSort(datas, p + 1, r);
}
}
private static int getPartition(double[] datas, int p, int r) {
/*
* double x = datas[r]; int i = p - 1; for (int j = p; j <= r - 1; j++)
* { while() {
*
* } }
*/
return 0;
}
public static void main(String[] args) {
System.out.println("Before:" + Arrays.toString(arrays));
quickSort(arrays, 0, arrays.length - 1);
System.out.println("After: " + Arrays.toString(arrays));
}
}
package com.my.study.algorithm.sort;
import java.util.Arrays;
public class BubbleSort {
private static double[] arrays = { 1.1, 0.5, 2.4, 2, 4, 10, 4.6, 2.9, -0.6,
-6, 29, 5 };
private static void bubbleSort(double[] data) {
for (int i = 0; i < data.length - 1; i++) {
for (int j = 0; j < data.length - 1 - i; j++) {
if (data[j] > data[j + 1]) {
double tem = data[j];
data[j] = data[j + 1];
data[j + 1] = tem;
}
}
}
}
public static void main(String[] args) {
System.out.println(Arrays.toString(arrays));
bubbleSort(arrays);
System.out.println(Arrays.toString(arrays));
}
}
import java.util.Arrays;
public class HeapSort {
private static double[] arrays = { 1.1, 0.5, 2.4, 2, 4, 10, 4.6, 2.9, -0.6,
-6, 29, 5 };
public static void main(String[] args) {
double[] results = heapSort(arrays);
System.out.println("After: " + Arrays.toString(results));
}
public static double[] heapSort(double[] datas) {
BinaryTree tree = new BinaryTree(datas);
return tree.heapSort();
}
private static class BinaryTree {
private TreeNode[] treeNodes;
public BinaryTree(double[] datas) {
treeNodes = new TreeNode[datas.length];
for (int i = 0; i < datas.length; i++) {
TreeNode node = new TreeNode(i, datas[i]);
treeNodes[i] = node;
int parentNodeIndex = (i + 1) / 2 - 1;
if (parentNodeIndex >= 0) {
TreeNode parentNode = treeNodes[parentNodeIndex];
node.setParent(parentNode);
if ((i + 1) % 2 == 0) {
parentNode.setLeftNode(node);
} else {
parentNode.setRightNode(node);
}
}
}
}
public double[] heapSort() {
// Change initial tree to max-heap tree
changeToMaxHeapTree();
// Change max-heap tree to ordered queue
return chageToOrderedData();
}
private void changeToMaxHeapTree() {
int startIndex = (treeNodes.length / 2) - 1;
for (int i = startIndex; i >= 0; i--) {
maxHeapify(treeNodes[i]);
}
}
private void maxHeapify(TreeNode node) {
if (node.getLeftNode() == null && node.getRightNode() == null) {
return;
}
TreeNode maxNode = node;
if (node.getLeftNode() != null) {
if (node.getValue() < node.getLeftNode().getValue()) {
maxNode = node.getLeftNode();
}
}
if (node.getRightNode() != null) {
if (maxNode.getValue() < node.getRightNode().getValue()) {
maxNode = node.getRightNode();
}
}
if (maxNode.getId() == node.getId()) {
return;
}
double temVal = maxNode.getValue();
maxNode.setValue(node.getValue());
node.setValue(temVal);
maxHeapify(maxNode);
}
private double[] chageToOrderedData() {
double[] results = new double[treeNodes.length];
for (int i = 0; i < treeNodes.length; i++) {
results[i] = treeNodes[0].getValue();
TreeNode lastNode = treeNodes[treeNodes.length - i - 1];
treeNodes[0].setValue(lastNode.getValue());
if (lastNode.getParent() != null) {
int lastNodeIndex = lastNode.getId();
if ((lastNodeIndex + 1) % 2 == 0) {
lastNode.getParent().setLeftNode(null);
} else {
lastNode.getParent().setRightNode(null);
}
lastNode.setParent(null);
maxHeapify(treeNodes[0]);
}
}
return results;
}
}
private static class TreeNode {
private int id;
private double value;
private TreeNode parent;
private TreeNode leftNode;
private TreeNode rightNode;
public TreeNode(int id, double value) {
super();
this.id = id;
this.value = value;
}
public int getId() {
return id;
}
public double getValue() {
return value;
}
public void setValue(double value) {
this.value = value;
}
public TreeNode getParent() {
return parent;
}
public void setParent(TreeNode parent) {
this.parent = parent;
}
public TreeNode getLeftNode() {
return leftNode;
}
public void setLeftNode(TreeNode leftNode) {
this.leftNode = leftNode;
}
public TreeNode getRightNode() {
return rightNode;
}
public void setRightNode(TreeNode rightNode) {
this.rightNode = rightNode;
}
}
}
package com.my.study.algorithm.sort;
import java.util.Arrays;
public class InsertionSort {
private static double[] arrays = { 1.1, 0.5, 2.4, 2, 4, 10, 4.6, 2.9, -0.6,
-6, 29, 5 };
public static void main(String[] args) {
System.out.println("Before:" + Arrays.toString(arrays));
insertionSort(arrays);
System.out.println("After: " + Arrays.toString(arrays));
}
public static void insertionSort(double[] datas) {
for (int i = 1; i < datas.length; i++) {
int j = i - 1;
double key = datas[i];
while (j > -1 && key < datas[j]) {
datas[j + 1] = datas[j];
j--;
}
datas[j + 1] = key;
}
}
}
package com.my.study.algorithm.sort;
import java.util.Arrays;
public class MergeSort {
public static void main(String[] args) {
// double[] data1 = { 3, 4, 5, 8, 1, 2, 6, 7, 9, 15, 19 };
// double[] data2 = { 1, 2, 6, 7, 9, 15, 19 };
// merge(data1, 0, 3, data1.length - 1);
// mergeSort(arrays, 0, arrays.length - 1);
// System.out.println(Arrays.toString(arrays));
// generateNum();
int num = 1000;
double[] datas = new double[num];
for (int i = 0; i < num; i++) {
int data = generateData();
datas[i] = data;
}
// System.out.println(Arrays.toString(datas));
mergeSort(datas);
System.out.println(Arrays.toString(datas));
}
public static void mergeSort(double[] array) {
mergeSort(array, 0, array.length - 1);
}
private static void mergeSort(double[] array, int p, int r) {
if (p < r) {
int q = (p + r) / 2;
mergeSort(array, p, q);
mergeSort(array, q + 1, r);
merge(array, p, q, r);
}
}
private static void merge(double[] array, int p, int q, int r) {
double[] data1 = new double[q - p + 1];
double[] data2 = new double[r - q];
for (int i = 0; i < data1.length; i++) {
data1[i] = array[p + i];
}
for (int i = 0; i < data2.length; i++) {
data2[i] = array[q + i + 1];
}
double[] results = merge(data1, data2);
for (int i = 0; i < results.length; i++) {
array[p + i] = results[i];
}
}
private static double[] merge(double[] data1, double[] data2) {
int data1Len = data1.length;
int data2Len = data2.length;
double[] datas = new double[data1Len + data2Len];
int i = 0;
int j = 0;
for (int k = 0; k < datas.length;) {
if (data1[i] < data2[j]) {
datas[k++] = data1[i++];
} else {
datas[k++] = data2[j++];
}
if (i == data1Len) {
while (j < data2Len) {
datas[k++] = data2[j++];
}
break;
}
if (j == data2Len) {
while (i < data1Len) {
datas[k++] = data1[i++];
}
break;
}
}
return datas;
}
private static int generateData() {
int d = (int) (100000 * Math.random() + 1);
return d;
}
}
package com.my.study.algorithm.sort;
import java.util.Arrays;
public class SelectionSort {
private static double[] arrays = { 1.1, 0.5, 2.4, 2, 4, 10, 4.6, 2.9, -0.6,
-6, 29, 5 };
public static void main(String[] args) {
System.out.println("Before:" + Arrays.toString(arrays));
selectionSort(arrays);
System.out.println("After: " + Arrays.toString(arrays));
}
private static void selectionSort(double[] datas) {
for (int i = 0; i < datas.length - 1; i++) {
for (int j = i + 1; j < datas.length; j++) {
if (datas[i] > datas[j]) {
double tem = datas[i];
datas[i] = datas[j];
datas[j] = tem;
}
}
}
}
}
package com.my.study.algorithm.sort;
import java.util.Date;
public class SortCompare {
public static void main(String[] args) {
int num = 5000;
while (num < 2000000) {
System.out.println("N: " + num);
insertionSort(num);
mergeSort(num);
heapSort(num);
System.out.println();
num = num + 5000;
}
}
private static void insertionSort(int num) {
double[] datas = new double[num];
;
for (int i = 0; i < num; i++) {
int data = generateData();
datas[i] = data;
}
long begin = new Date().getTime();
InsertionSort.insertionSort(datas);
long end = new Date().getTime();
System.out.println("Insertion, " + (end - begin));
}
private static void mergeSort(int num) {
double[] datas = new double[num];
for (int i = 0; i < num; i++) {
int data = generateData();
datas[i] = data;
}
long begin = new Date().getTime();
MergeSort.mergeSort(datas);
long end = new Date().getTime();
System.out.println("Merge, " + (end - begin));
}
private static void heapSort(int num) {
double[] datas = new double[num];
for (int i = 0; i < num; i++) {
int data = generateData();
datas[i] = data;
}
long begin = new Date().getTime();
HeapSort.heapSort(datas);
long end = new Date().getTime();
System.out.println("Heap, " + (end - begin));
}
private static int generateData() {
int d = (int) (100000 * Math.random() + 1);
return d;
}
}