c++排序算法

#include<iostream>
using namespace std;
#define N 10
int a[N] = { 3,1,2,7,9,11,4,10,5,6 };
void inverse(int b[]);
void select(int b[]);
void insert(int b[]);
void insert_pioneer(int b[]);
void quickSort(int b[], int l, int r);
void quickSort2(int b[], int left, int right);
int shellSort(int b[]);
void print();
int main() {
	
	
	//输出原数组
	cout << "输出原数组" << endl;
	for (int i = 0; i <N; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
	cout << "-------------------" << endl;
	调用排序算法
	//inverse(a);
	//调用选择排序算法
	//select(a);
	//调用插入排序
	//insert(a);
	//调用前插排序
	//insert_pioneer(a);
	//quickSort(a, 0, N - 1);
	//quickSort2(a, 0, N - 1);
	shellSort(a);
	cout << "调用排序算法输出数组" << endl;
	print();
	cout << "-------------------" << endl;
	
	return 0;
}
//冒泡排序，相邻两个数比较将大的放到最后面，第一个与第二个比较，第二个再与第三个比较
void inverse(int b[]) {
	for (int i = 0; i < N - i; i++) {
		for (int j = 0; j < N - i - 1; j++) {
			if (b[j] > b[j + 1]) {
				int t = b[j];
				b[j] = b[j + 1];
				b[j + 1] = t;
			}
		}
	}
}
//选择排序，第一遍挑出最小的一个数与第一个数交换位置，然后剩下的中挑最小的与第二个数交换位置
void select(int b[]) {
	int min;
	for (int i = 0; i < N - 1; i++) {
		for (int j = i + 1; j < N; j++) {
			min = i;
			if (b[min] > b[j]) {
				min = j;
			}
			if (min != i) {
				int t = a[i];
				a[i] = a[min];
				a[min] = t;
			}
		}
	}
}
//直接插入排序，后插排序
//1.从第一个元素开始，该元素可以认为已被排序；
//2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
//3.如果该元素（已排序）大于新元素，将该元素移到下一个位置；
//4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
//5.将新元素插入到该位置后，重复2~5
void insert(int b[]) {
	for (int i =1; i < N; i++) {
		int t = b[i];
		int j = i - 1;
		while (j>= 0 && b[j] >t) {
			b[j + 1] = b[j];
			j--;
		}
		b[j + 1] = t;
	
	}
}
//前插排序
void insert_pioneer(int b[]) {
    for (int i = 1; i < N; i++) {
	int t = b[i];
	for (int j = 0; j < i; j++) {
		if (b[j] >= t) {
			for (int k = i; k > j; k--) {
				b[k] = b[k - 1];
			}
			b[j] = t;
			break;
		}
		
	}
}
}
//快速排序

void quickSort(int b[], int first, int end)
{
	if (first< end)
	{
		int i = first, j = end, x = b[first];
		while (i < j)
		{
			while (i < j && b[j] >= x) // 从右向左找第一个小于x的数  
				j--;
			if (i < j) {
				b[i] = b[j];
				i++;
			}
				
			while (i < j && b[i]< x) // 从左向右找第一个大于等于x的数  
				i++;
			if (i < j) {
				b[j] = b[i];
				j--;
			}
		}
		b[i] = x;
		quickSort(b, first, i - 1); // 递归调用  
		quickSort(b, i + 1, end);
	}
}
//快速排序，一次找到两个值交换位置
void quickSort2(int b[], int left, int right)
{
	int i, j, t, temp;
	if (left>right)
		return;
	temp = b[left]; //temp中存的就是基准数 
	i = left;
	j = right;
	while (i != j)
	{
		//顺序很重要，要先从右边开始找 
		while (b[j] >= temp && i<j)
			j--;
		//再找右边的 
		while (b[i] <= temp && i<j)
			i++;
		//交换两个数在数组中的位置 
		if (i<j)
		{
			t = b[i];
			b[i] = b[j];
			b[j] = t;
		}
	}
	//最终将基准数归位 
	b[left] =b[i];
	b[i] = temp;
	quickSort(b,left, i - 1);//继续处理左边的，这里是一个递归的过程 
	quickSort(b,i + 1, right);//继续处理右边的 ，这里是一个递归的过程 
}
//希尔排序，步长=元素个数/2；步长/=步长/2；向上取整，如步长为3.5则取4。
//希尔排序原理链接 http://blog.csdn.net/jianyuerensheng/article/details/51258460
int shellSort(int array[]) {
	//定义变量，记录交换次数
	int count = 0;
	//定义中间变量，做为临时交换变量
	int temp;
	//遍历数组（进行排序）
	cout << "开始对数组进行排序了..." << endl;
	//定义初始增量值
	int gap = N;
	do {
		//初始增量变化规律
		gap = gap / 3 + 1;
		for (int i = gap; i <N; i++)
		{
			for (int j = i; j >= gap; j -= gap)
			{
				if (array[j] < array[j - gap])
				{
					temp = array[j];
					array[j] = array[j - gap];
					array[j - gap] = temp;
					cout <<array[j] << "和" <<array[j - gap] << "互换了" << endl;
					//输出此时数组的顺序
					cout << "数组此时的顺序是：";
					for (int i = 0; i < N; i++) {
						cout << array[i] << " ";
					}
					cout << endl;
					//每交换一次，记录数加1
					count++;
				}
				else
				{
					break;
				}
			}
		}
	} while (gap>1);
	cout << "数组排序结束了..." << endl;
	return count;
	/*int gap;
	if (N % 2 == 0)
		gap = N / 2;
	else
		gap = N / 2 + 1;
	for (int i = 0; i < N/2; i ++) {

	}

	
	cout << gap;*/
}
void print(){
	for (int i = 0; i < N; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
	}