Java 排序总结

<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;
	}
}