排序算法_JavaPython_数据结构与算法

常见的排序算法有选择排序，冒泡排序，快速排序，归并排序，Hash排序等，这里面就快速排序，归并排序和堆排序进行讨论。其中堆排序是各大热门公司机试的热门题目。最近在学习python，我原来是喜欢java的，用过一段时间的perl，感觉perl实在是太晦涩了，高度利用了语言符号。Python代码可读性很强，如同一篇洋洋洒洒的散文。废话不多说，直接上代码供大家参考。

1.归并排序。

归并排序，稳定的排序算法。下面给出Java代码和Python代码(ChenxofHit@gmail.com)：

Java代码：

package chenx.sorting;

public class MergeSort implements Sort {

int[] sortSrc; // 待排序的数字
int[] sortDes; // 排序后的数字集合
private static final int sortNumber = 100;

public static void main(String[] args) {
MergeSort ms = new MergeSort();
ms.beforeSort();
System.out.println("Before Sort:");
ms.printArray(ms.sortSrc);

ms.afterSort();
System.out.println("After Sort:");
ms.printArray(ms.sortDes);
}

public MergeSort() {
sortDes = new int[sortNumber];
}

private int[] mergeSort(int[] array, int start, int end) {

int[] result = new int[end - start + 1];

if (start < end) {
int mid = (start + end) / 2;
int[] left = mergeSort(array, start, mid);
int[] right = mergeSort(array, mid + 1, end);
result = merge(left, right);
} else if (start == end) {
result[0] = array[start];
return result;
}
return result;

}

private int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];
int i = 0;
int j = 0;
int k = 0;
while (i < left.length && j < right.length) {
if (left[i] < right[j]) {
result[k++] = left[i++];
} else {
result[k++] = right[j++];

}
}
while (i < left.length) {
result[k++] = left[i++];
}
while (j < right.length) {
result[k++] = right[j++];
}
return result;

}

@Override
public int[] afterSort() {
// TODO Auto-generated method stub
System.arraycopy(mergeSort(sortSrc, 0, sortNumber - 1), 0, sortDes, 0,
sortNumber);
return sortDes;
}

@Override
public int[] beforeSort() {
// TODO Auto-generated method stub
setSortNumbers();
return sortSrc;
}

public int[] setSortNumbers() {
System.out.printf("This will genertate %d for sorted:\n", sortNumber);
sortSrc = new int[sortNumber]; // 100个数字
for (int i = 0; i < sortNumber; i++) {
sortSrc[i] = (int) (Math.random() * sortNumber + 1);
}
return sortSrc;
}

public void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
if ((i + 1) % 10 == 0)
System.out.println();
}
}

}
Python代码：

def merge_sort(data):
if (len(data)<=1):
return data
index  =  len(data)//2
lst1 = data[:index]
lst2 = data[index:]
left = merge_sort(lst1)
right = merge_sort(lst2)
return merge(left, right)

def  merge(lst1, lst2):
"""to Merge two list together"""
list = []
while(len(lst1)>0 and len(lst2)>0):
data1 = lst1[0]
data2 = lst2[0]
if (data1<=data2):
list.append(lst1.pop(0))
else:
list.append(lst2.pop(0))
if(len(lst1)>0):
list.extend(lst1)
else:
list.extend(lst2)
return list

arr = [ 2, 7, 4, 5, 6, 7, 9, 10, 12, 1, 3]
print (merge_sort(arr))

2.快速排序

Python代码（ChenxofHit@gmail.com）：

import random
def quick_sort(data):
if (len(data) <1):
return data
great=[]
less = []
# to get the privot
privot = data.pop(random.randint(0, len(data) - 1 ))

for item in data:
if (item< privot):
less.append(item)
else:
great.append(item)

return quick_sort(less)+[privot]+quick_sort(great)

arr = [ 2, 7, 4, 5, 6, 7, 9, 10]
print (quick_sort(arr))
代码相当简洁明了!

3.堆排序

#ChenxofHit@gmail.com2011年3月7日21:02:13
def  heap_sort (data):
result = []
lenData = len(data)
while(len(result)  < lenData ):
heap_adjust(data, result)
return result
def  heap_adjust(data, result):
i = len(data) -1
while (i >=1):
if( data[(i+1)//2  - 1 ]  <= data[ i ]): #the parent node is smaller than the child ,swap it
t = data[(i+1)//2  - 1 ]
data[(i+1)//2  - 1 ] =  data[ i ]
data[ i ] = t
i  = i - 1
result.append(data.pop(0))

arr = [ 2, 7, 4, 5, 6, 7, 9, 10, 12, 1, 3]
print (heap_sort(arr))