各種排序算法python和java實現(一)

先從最簡單的實現冒泡排序：

# -*- coding: UTF-8 -*-
intarray=[3,4,5,1,2,0,6,9,7]
def bubble(array):
    for i in range(1,len(array)):
	    for j in range(i):
		    if array[j] > array[i]:
			    array[j],array[i] = array[i],array[j]
#遍歷數組
def print_list(array):
    for i in intarray:
        print i,
#執行排序
bubble(intarray)
#打印
print_list(intarray);

存儲爲buble.py，命令行模式直接運行python buble.py

package sort;

public class Sort {
	public static void main(String[] args) {
		int[] array = new int[] { 3, 4, 5, 1, 2, 0, 6, 9, 7 };

		bubblesort(array);
		print(array);

	}

	private static void print(int[] array) {
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i]);
		}
	}

	private static void bubblesort(int[] array) {
		// 冒泡的趟數，爲length - 1
		for (int i = 1; i < array.length; i++) {
			// 第二層循環爲每次循環需要冒泡的次數
			for (int j = 0; j < i; j++) {
				if (array[j] > array[i]) {
					int temp = array[j];
					array[j] = array[i];
					array[i] = temp;
				}
			}
		}
	}
}

看完冒泡排序，看一個稍微有點思考的算法，直接插入排序，這種算法適合待排序的集合部分有序，先給出java的實現方式：

/**
	 * 假設當前某個子集有序，選擇下個值插入到這個有序的子集中 整個過程主要在於尋找要插入的下標。插入排序在部分子集有序 的情況下非常快。
	 * 初始假設array[0]有序
	 * @param array
	 */
	private static void insertSort(int[] array) {
		// 默認第一個爲有序
		int length = array.length;
		int temp;
		int j;
		// 將當前的值插入到有序子集
		for (int i = 1; i < length; i++) {
			// 如果當前值比有序子集的最大值小則執行交換
			if (array[i] < array[i - 1]) {
				// temp存儲當前要插入的值，也叫做哨兵
				temp = array[i];
				// 有序子集從0-j，從後向前遍歷
				for (j = i - 1; j >= 0; j--) {
					if (temp < array[j]) {
						// 如果哨兵值小於子集的當前值，則將子集的當前值後移
						array[j + 1] = array[j];
					} else {
						// 否則找到哨兵要插入的下標
						break;
					}
				}
				// 插入的下標爲j+1
				array[j + 1] = temp;
			}

		}
	}

下面是python的實現：

def insertSort(array):
	length = len(array)
	for i in range(1,length):
		if array[i] < array[i-1]:
			temp=array[i]
			for j in range(0,i)[::-1]:
				if temp < array[j]:
					array[j+1] = array[j]
				else:
					j = j+1
					break
			array[j] = temp

看完直接排序，再來看下選擇排序，顧名思義選擇排序，每次遍歷選擇出子集的最小值，看java實現：

/**
	 * 選擇排序,每趟選擇出子集的最小值，然後交換
	 * 
	 * @param array
	 */
	public static void selectionSort(int[] array) {
		int temp, minIndex;
		for (int i = 0; i < array.length; i++) {
			// 假設初始最小值爲子集的第一個元素
			minIndex = i;
			for (int j = i + 1; j < array.length; j++) {
				if (array[minIndex] > array[j]) {
					// 找出最小值的下標
					minIndex = j;
				}
			}
			if (minIndex != i) {
				// 交換
				temp = array[i];
				array[i] = array[minIndex];
				array[minIndex] = temp;
			}
		}
	}

再來看python版本：

def selectionSort(array):
	for i in xrange(0,len(array)):
		index = i
		for j in xrange(i,len(array)):
			if array[index] > array[j]:
				index = j
		temp = array[i]
		array[i] = array[index]
		array[index] = temp

以上就是集中簡單排序的java和python實現，下一篇講解幾個稍微複雜點得變形排序。