快速排序和归并排序的递归实现和非递归实现

快排：
递归实现：

int partion(vector<int>& v,int low, int high){
    int key = v[low];//中枢点//此时v[i]为空，待放入数据
    //三值取中的优化，比较left,mid,right三个值，把中值和left进行swap即可

    while(low < high){
        while(low < high && v[high] >= key)//找到第一个小于key的数v[j]，放入v[i]中，同时v[j]变为空，待放入数据
            --high;
        if(low < high){
            v[low] = v[high];
            ++low;
        }
        while(low < high && v[low] <= key)//找到第一个大于key的数v[i]，放入v[j]中，同时v[i]为空，待放入数据
            ++low;
        if(low < high){
            v[high] = v[low];
            --high;
        }
    }
    v[low] = key;//此时i==j,v[i]为空，放入key
    return low;
}

void quick_sort(vector<int>& v,int low,int high){
    if(low < high){
        int pivot = partion(v,low,high);
        quick_sort(v,low,pivot-1);
        quick_sort(v,pivot+1,high);
    }
}

void qsort(vector<int>& v){
    quick_sort(v,0,v.size() - 1);
}

非递归解法(栈)：

void quick_sort_norecusive(vector<int>& array,int left,int right){
	stack<int> s;
	s.push(left);
	s.push(right);//每次进栈两个值，表示需要排序的区间
	while(!s.empty())//栈不为空
	{
		//对出栈的两个值所表示的区间进行排序
		int right = s.top();
		s.pop();
		int left = s.top();
		s.pop();
		
		int index = partion(array,left,right);
		if((index - 1) > left){//若index == left或index==left+1，说明已经有序，不必再排序
			s.push(left);
			s.push(index - 1);
		}
		if((index + 1) < right)//若index == right或index==right-1,说明已有序，不必再排序
		{
			s.push(index + 1);
			s.push(right);
		}
	}
}

归并排序：
递归方式：

void merge(vector<int>& v,int left,int mid,int right){
    int len = right - left + 1;
    int* temp = new int[len];
    int i = left,j = mid + 1,k = 0;
    while(i <= mid && j <= right){
        if(v[i] < v[j])
            temp[k++] = v[i++];
        else
            temp[k++] = v[j++];
    }
    while(i <= mid)
        temp[k++] = v[i++];
    while(j <= right)
        temp[k++] = v[j++];
    for(int a = 0;a < len;++a)
        v[left+a] = temp[a];
    delete [] temp;
}

void _merge_sort(vector<int>& v,int left,int right){
    if(left < right){
        int mid = left + (right - left) / 2;
        _merge_sort(v,left,mid);
        _merge_sort(v,mid + 1,right);
        merge(v,left,mid,right);
    }
}

void merge_sort(vector<int>& v){
    _merge_sort(v,0,v.size() - 1);
}

非递归实现

void _merge_sort_norecursive(vector<int>& v){
    //分别对长度为1、2、4、8的子区间进行归并
    int len = 1;
    while(len <= v.size()){
        for(int i = 0;i + len < v.size();i += len*2){//i+len<v.size()保证右子区间大小大于0
            int left = i,mid = i + len - 1,right = i + len * 2 -1;
            if(right > v.size() - 1)
                right = v.size() - 1;
            merge(v,left,mid,right);
        }
        len *= 2;
    }
}