排序算法

分别用java和c++实现了一下快速排序和归并排序

C++代码如下：

/*
 * SortUtil.cpp
 *
 *  Created on: 2015年4月21日
 *      Author: 
 */

#include "SortUtil.h"

#include <string.h>
#include <iostream>
using namespace std;

SortUtil::SortUtil()
{
    // TODO Auto-generated constructor stub

}

SortUtil::~SortUtil()
{
    // TODO Auto-generated destructor stub
}

void SortUtil::merge_sort( int* array, size_t start, size_t end )
{
    if(start<end){
        size_t middle = (start+end+1)/2;//注意+1
        merge_sort(array, start, middle-1);
        merge_sort(array, middle, end);
        merge(array, start, middle, end);
    }
}

void SortUtil::merge( int* array, size_t start, size_t middle, size_t end )
{
    if(!(start<middle && middle<=end)){
        return;
    }
    size_t left_size = middle-start;
    size_t right_size = end-middle+1;
    //--------将左右两半数组分别拷贝到left和right中
    int left[left_size];
    int right[right_size];
    memcpy(left, array+start, left_size*sizeof(int));
    memcpy(right, array+middle, right_size*sizeof(int));
/*    for(size_t i=0; i<left_size; ++i){
        left[i] = array[start+i];
    }
    for(size_t i=0; i<right_size; ++i){
        right[i] = array[middle+i];
    }*/
    size_t index = start;//array的index
    size_t left_index = 0;
    size_t right_index = 0;
    while(left_index<left_size && right_index<right_size){
        if(left[left_index] <= right[right_index]){
            array[index++] = left[left_index++];
        }else{
            array[index++] = right[right_index++];
        }
    }
    if(left_index >= left_size){
        while(right_index < right_size){
            array[index++] = right[right_index++];
        }
    }else{
        while(left_index < left_size){
            array[index++] = left[left_index++];
        }
    }
}

void SortUtil::quick_sort( int* array, size_t start, size_t end )
{
    if(start >= end){
        return;
    }
    size_t middle = partition(array, start, end);
    if(middle>0){//由于middle为size_t类型的，当middle为0，则减1会出问题
        quick_sort(array, start, middle-1);
    }
    quick_sort(array, middle+1, end);
}

/**
 * 调用程序必须保证start<end
 */
size_t SortUtil::partition( int* array, size_t start, size_t end )
{
    if(start == end){
        return start;
    }
    if(start > end){
        cout<<"error: start > end"<<endl;
        return end;
    }
    int partition_value = array[start];
    size_t index = start+1;//迭代用的索引
    size_t less_index = start;//始终指向小于等于partition_value的最靠右的元素
    for(; index<=end; ++index){
        if(array[index] <= partition_value){
            ++less_index;
            if(less_index != index){
                swap(array, less_index, index);
            }
        }
    }
    swap(array, less_index, start);
    return less_index;
}

void SortUtil::swap( int* array,const size_t l, const size_t r )
{
    if(l == r){
        return;
    }
    int tmp = array[l];
    array[l] = array[r];
    array[r] = tmp;
}

java代码如下：

package algorithm;

public class SortUtil {

    public static void mergeSort(int[]array, int start, int end){
        if(start >= end){
            return;
        }
        int middle = (start+end+1)/2;
        mergeSort(array, start, middle-1);
        mergeSort(array, middle, end);
        merge(array, start, middle, end);
    }
    public static void merge(int[]array, int start, int middle, int end){
        if(!(start<middle && middle<=end)){
            return;
        }
        int leftSize = middle-start;
        int rightSize = end-middle+1;
        int[] leftArray = new int[leftSize];
        int[] rightArray = new int[rightSize];
        for(int i=0; i<leftSize; ++i){
            leftArray[i] = array[start+i];
        }
        for(int i=0; i<rightSize; ++i){
            rightArray[i] = array[middle+i];
        }
        int index = start;
        int leftIndex = 0; 
        int rightIndex = 0;
        while(leftIndex<leftSize && rightIndex<rightSize){
            if(leftArray[leftIndex] <= rightArray[rightIndex]){
                array[index++] = leftArray[leftIndex++];
            }else{
                array[index++] = rightArray[rightIndex++];
            }
        }
        if(leftIndex == leftSize){
            while(rightIndex<rightSize){
                array[index++] = rightArray[rightIndex++];
            }
        }else{
            while(leftIndex<leftSize){
                array[index++] = leftArray[leftIndex++];
            }
        }
    }
    
    //----------------------------
    public static void quickSort(int[]array, int start, int end){
        if(start>=end){
            return;
        }
        int middle = partition(array, start, end);
        quickSort(array, start, middle-1);
        quickSort(array, middle+1, end);
    }
    public static int partition(int[]array, int start, int end){
        if(start == end){
            return start;
        }
        if(start > end){
            System.out.println("error!");
            return end;
        }
        int partitionValue = array[start];
        int lessIndex = start;
        for(int index = start+1; index<=end; ++index){
            if(array[index]<=partitionValue){
                lessIndex++;
                if(lessIndex != index){
                    swap(array, lessIndex, index);
                }
            }
        }
        swap(array, start, lessIndex);
        return lessIndex;
    }
    public static void swap(int[]array, int l, int r){
        if(l == r){
            return;
        }
        int tmp = array[l];
        array[l] = array[r];
        array[r] = tmp;
    }
    
    public static void main(String[] args){
        
        int[]array = {10,2,8,7,6,5,9,1,3,4};
//        mergeSort(array, 0, array.length-1);
        quickSort(array, 0, array.length-1);
        for(int i:array){
            System.out.print(i+" ");
        }
    }
}