神はCのチュートリアルソートアルゴリズムのコードを左++

マージソート

//1.内排序，指所有数据已经读入内存，在内存中进行排序的算法。排序过程不需要对磁盘进行读写。
//外排序：内存中无法保存全部数据、需要进行磁盘访问，每次读入部分数据到内存进行排序
//a,merge sort  "分而治之"，o(nlogn) 空间o(n)

void merge(vector<int> &array, int left, int mid, int right) {
	vector<int> helper(right - left + 1);
	int i = 0;
	int helperLeft = left;
	int helperRight = mid + 1;

	while (helperLeft <= mid && helperRight <= right) {
		if (array[helperLeft] < array[helperRight]) {
			helper[i++] = array[helperLeft++];
		}
		else {
			helper[i++] = array[helperRight++];
		}
	}
	while (helperLeft <= mid) {
		helper[i++] = array[helperLeft++];
	}
	while (helperRight <= right) {
		helper[i++] = array[helperRight++];
	}
	for (i = 0; i < helper.size(); i++)
		array[left + i] = helper[i];//备份
}
void mergesort(vector<int> &array, int left, int right);
void merge_sort(vector<int> &array) {
	if (array.empty() == true || array.size() < 2) {
		return;
	}
	mergesort(array, 0, array.size() - 1);
}
void mergesort(vector<int> &array, int left, int right) {

	if (left == right) {
		return;
	}
	//分裂和组合：数组被分为左右两部分，两部分进行排序然后合并
	int mid = left + (right - left) / 2;//并不一定是完全相等的两部分.防溢出
	mergesort(array, left, mid);
	mergesort(array, mid + 1, right);
	//将两部分
	merge(array, left, mid, right);

}

バブルソート

//冒泡排序O(N^2)
vector<int> bubble_sort(vector<int>&array) {
	int len = array.size();
	int s;
	if (array.empty() == true || len < 2){
		return array;
	
	}
	for (int i = len-1; i >0; i--) {
		for (int j = 0; j < i; j++) {
			if (array[j] > array[j + 1]) {
				s = array[j];
				array[j ]=array[j+1];
				array[j + 1] = s;
			}
		}
	}
	return array;
}

挿入ソート

//插入排序 
vector<int> insertSort(vector<int> arr) {
	if (arr.empty() == true || arr.size() < 2)
		return arr;
	int s;
	for (int i = 1; i < arr.size(); i++) {
		for (int j = i - 1; j >=0; j--) {
			if (arr[j] > arr[j + 1]) {
				s = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = s;
			}
		}

	}
	return arr;

}

再帰関数は、プロジェクト内に存在することはできませんが、また、ランキング法の非再帰的なバージョンを理解するために

クイックソート最適化されたバージョン

//快速排序 长期期望复杂度 O(N*log(N)) 长期期望空间复杂度 O(logN) 因为断点需要记忆
// 每次递归属于荷兰旗问题  
vector<int> position(vector<int> &arr1,int l ,int r) {

	int less = l - 1;
	int more = r;
	int s;
	while (l < more) {
		if (arr1[l] < arr1[r]) {
			++less;
			s = arr1[less];
			arr1[less]=arr1[l];
			arr1[l] = s;
			l++;
		}
		else if (arr1[l] > arr1[r]) {
			--more;
			s = arr1[more];
		    arr1[more]= arr1[l];
			arr1[l] = s;
		}
		else {
			l++;
		}

	}
	swap(arr1[more], arr1[r]);
	vector<int> p(2);
	p[0] = less + 1;
	p[1] = more;
	
	return p;

}
void quick_Sort(vector<int> &arr1,int l,int r) 
{
	if (l < r) {
		//swap(arr[l + rand() % (r - l)], arr[r]);
		vector<int> p= position(arr1, l, r);//返回的是位置，小于值得右边和大于值得左边
		
		//cout<< p.size()<<endl;
		quick_Sort(arr1,l,p[0]-1);
		quick_Sort(arr1,p[1]+1,r);
	}

}
void quickSort(vector<int> &arr1) {
	if (arr1.empty() == true || arr1.size() < 2)
	{
		return;
	}
	quick_Sort(arr1, 0, arr1.size() - 1);

}

ヒープソート

ヒープ構造

Oの時間複雑（NxlogN）Oの余分なスペースの複雑さ（1）
完全なバイナリツリーに配列した後、配列内の子供の位置：左子供：2 1 + 1、右の子：2 1 + 2
推論の父:( I-1）/ 2;
大ルートスタック：任意の部分木の最大値は、ツリー・ヘッドです。

//建立大根堆的过程
//堆排序
//大根堆生成的时间复杂度O(logN)


void heapInsert(vector<int> &array,int index) {
	while (array[index] > array[(index - 1) / 2]) {
		swap(array[index], array[(index - 1) / 2]);
		index = (index - 1) / 2;
	}

}
//大跟堆中有值发生变化，调整成依旧是大根堆
void heapify(vector<int> &arr, int index, int heapsize) {
	int left = index * 2 + 1;//左孩子节点
	
	while (left < heapsize) {
		int largest;
		if (left + 1 < heapsize&&arr[left + 1] > arr[left])
			largest =left + 1;
		else
			largest = left;
		if (arr[largest]< arr[index]) {
			largest = index;
		}
		if (largest==index)
			break;
		swap(arr[largest],arr[index]);
		index = largest;
		left = index * 2 + 1;
	}
}
void heapsort(vector<int> &arr)
{
	if (arr.empty() == true || arr.size() < 2) {
		return;
	}
	for (int i = 0; i < arr.size(); i++) {
		heapInsert(arr, i);//变成大根堆
	}
	int heaplen = arr.size();
	swap(arr[0],arr[--heaplen]);
	while (heaplen > 0) {
		heapify(arr, 0, heaplen);
		swap(arr[0],arr[--heaplen]);

	}



}

ランダムベクトル生成器

//笔试过程中建立对数器，防止出错
vector<int> generateRandomArray(int maxSize,int maxValue) {
	

	int size = rand() % (maxSize + 1);
	vector<int> arr(size);

	for (int i = 0; i < size; i++) {
		arr[i] = int(rand() % (maxValue + 1)) - int(rand() % (maxValue + 1));
	}
	return arr;

}

同じであるが2に等しいかどうかを決定します

bool isEqual(vector<int> arr1, vector<int> arr2) {
	if ((arr1.empty() == true && arr2.empty() != true) || (arr1.empty() != true && arr2.empty() == true)) {
		return false;
	}
	if (arr1.empty() == true && arr2.empty() == true)
		return true;
	if (arr1.size() != arr2.size())
		return false;
	for (int i = 0; i < arr1.size(); i++) {
		if (arr1[i] != arr2[i]) {
			return false;
		}
	}
	return true;
}

主な機能：対数フィルタであって、

//排序和二分搜索
//#include "stdafx.h"
#include <iostream>
#include <vector>
#include  <stdlib.h>
using namespace std;
void main() {
	int testTime = 500;
	int maxSize = 10;
	int maxValue = 10;
	bool succeed = true;
	for (int i = 0; i < testTime; i++) {
		vector<int> arr1 = generateRandomArray(maxSize, maxValue);
		vector<int> arr2(arr1);
		cout << i << endl;
		//merge_sort(arr1);
		quickSort(arr1);
		arr2=bubble_sort(arr2);

		if (isEqual(arr1, arr2) != true) {
			succeed = false;
			for (int i = 0; i < arr1.size(); i++) {
				cout << arr1[i]<< "";
			}
			for (int i = 0; i < arr1.size(); i++) {
				cout << arr2[i] << "";
			}
			break;
		}
	}
	if (succeed == true){
		cout << "it's right" << endl;
	}
	else {
		cout<<"it's wrong"<<endl;
	}
	system("PAUSE");
	return;
}