Java Sort

<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 treechangeToMaxHeapTree();// Change max-heap tree to ordered queuereturn 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;}}