排序算法_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))