七大排序

1.冒泡排序
思想：两两比较，大的放后面，每一回都能得出最大值放在最后，然后开始新一轮。
解决：两个for循环，第一个用于控制长度，第二个用于比较
时复：O（n*n）
代码：

class BubbleSort {
public:
    int* bubbleSort(int* A, int n) {
        // write code here
        for(int i=n-1;i>0;i--) //用于存每一次的max
        {
            for(int j=0;j<i;j++)  //两两比较
            {
                if(A[j]>A[j+1])
                {
                    int temp = A[j];
                    A[j] = A[j+1];
                    A[j+1] = temp;
                }
            }
        }
        return A;
    }
};

好久没写博客，因为新接了项目，导致一直没写算法，忏悔。

2.选择排序
思想：每次选出最小值
解决：两个for循环，第一个用于控制长度，第二个用于比较，需要一个min和key来记录每次的最小值和位置。
时复：O（n*n）
代码：

class SelectionSort {
public:
    int* selectionSort(int* A, int n) {
        // write code here
        for(int i=0;i<n;i++) //用于控制每一轮的循环和存放每次找出得min
        {
            int min=A[i];
            int key=i;;
            for(int j=i;j<n;j++)
            {
                if(A[j]<min)
                {
                    min=A[j];
                    key=j;
                }
            }
            int temp=A[i];
            A[i]=A[key];
            A[key]=temp;
        }
        return A;
    }
};

3.插入排序
思想：就是不断地把一个数组中的元素，未排序的元素不断插入到已成功排序的队列之中。
解决：用两个循环，外层控制当前需要排序的元素，内层用于对前几个有序数字进行比较。
时复：O（n*n）
代码：

class InsertionSort {
public:
    int* insertionSort(int* A, int n) {
        // write code here
        for(int i=1;i<n;i++)
        {
            for(int j=i;j>0;j--)
            {
                if(A[j]<A[j-1])
                {
                    int temp = A[j];
                    A[j]=A[j-1];
                    A[j-1]=temp;
                }
            }
        }
        return A;
    }
};

4.归并排序
思想：将一列数组不断对半分成一个个小组，直到每小组的元素个数为1的时候停止，然后相邻小组开始排序，自底向上排序。
解决：需要一个分组函数和一个排序函数，分组函数用递归的方式来划分数组，排序函数中需要加一个辅助数组，暂时将每次排序好的数组放入辅助数组，排序方式就是最简单的原理，即两个有序数组合并排序。
时复：O（n*logn）
代码：

// test1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include "pch.h"
#include <iostream>
#include <vector>
using namespace std;

void merge(int* A, int left, int mid, int right)
{
	vector<int> B(right - left+1);
	int j = mid + 1;
	int k = 0;
	int i = left;
	while (i <= mid&&j <= right)
	{
		if (A[i] > A[j])
		{
			B[k++] = A[j];
			j++;
		}
		else
		{
			B[k++] = A[i++];
		}
	}
	while(j <= right)  //前面部分元素排列完毕，后面的就不用动了
	{
		B[k++] = A[j++];
	}
	while (i <= mid)  //后面的排完了，把前面的放到最后
	{
		B[k++] = A[i++];
	}
	/*for (int i = 0; i < right - left + 1; i++)
	{
		cout << B[i] << " ";
	}
	cout << endl;*/
	//这里之所以一直报错是因为left是动态的，那么for的判断条件也是动态了，所以就出错了
	//解决方法有二，一是用一个m来接受left然后做A的下标，二就是left+i
	/*int m = left;
	for (int i = 0; i < right-left+1; i++)
	{
		A[left++] = B[i];
	}*/
	for (int i = 0; i < right - left + 1; i++)
	{
		A[left+i] = B[i];
	}
}

void sort(int *A, int left, int right)  //这个函数是用来把一个数组层层扒开，然后变成一个一个的
{
	if(left < right)
	{
		int mid = (left+right)/2;
		sort(A, left, mid);
		sort(A, mid + 1, right);
		merge(A, left, mid, right);
	}
}

void mergeSort(int* A, int n)
{
	// write code here
	sort(A, 0, n - 1);
}

int main()
{
	int *arr = new int[13];
	arr[0] = 54;
	arr[1] = 35;
	arr[2] = 48;
	arr[3] = 36;
	arr[4] = 27;
	arr[5] = 12;
	arr[6] = 44;
	arr[7] = 44;
	arr[8] = 8;
	arr[9] = 14;
	arr[10] = 26;
	arr[11] = 17;
	arr[12] = 28;
	mergeSort(arr,13);
	for (int i = 0; i < 13; i++)
		cout << arr[i]<<" ";
	delete[]arr;
	return 0;
}

5.快速排序
思想：一个数组，每次找中间下标的值，然后挨个比较，比mid小的值放前面，大的放后面，然后将mid左右各分组，然后继续找各自的mid，然后重复，直到每个组只剩一个。
解决：一个函数来不断分组一个用于排序，与归并不同的是，快排是先找枢纽值，然后排序然后分组，是不断交替进行的，所以是排序，分组分组这样一个递归关系。
时复：O（n*logn）
代码：

// test1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include "pch.h"
#include <iostream>
#include <vector>
using namespace std;

int quicksort(int *A,int left, int right)
{
	if (left < right)
	{
		int mid = (left + right) / 2;
		int key = A[mid];//存放中间值
		vector<int> B(right-left+1);
		int j = 0; int k = right - left;
		for (int i = left; i <= right; i++)  //根据key值进行左右分组
		{
			if (A[i] < key)
			{
				B[j++] = A[i];
			}
			else if (A[i] >= key)
			{
				if (i != mid)
				{
					B[k--] = A[i];
				}
				else
				{
					continue;
				}
			}
		}
		B[j] = key;
		for (int i = left; i <= right; i++)
		{
			A[i] = B[i - left];
			cout << A[i] << " ";
		}
		cout << endl;
		//j每次都是从零开始的，不是枢纽值
		return j+left;
	}
	//这里因为有个if判断，若不满足if那么就会跳过这个代码没有返回值，所以需要一个return
	return 0;
}
void merge(int *A,int left, int right)
{
	if (left < right)
	{	
		int center = quicksort(A,left, right);
		merge(A, left, center-1);
		merge(A, center + 1, right);
	}	
}

void mergeSort(int* A, int n)
{
	// write code here
	merge(A, 0, n-1);
}

int main()
{
	int *arr = new int[13];
	arr[0] = 54;
	arr[1] = 35;
	arr[2] = 48;
	arr[3] = 36;
	arr[4] = 27;
	arr[5] = 12;
	arr[6] = 44;
	arr[7] = 44;
	arr[8] = 8;
	arr[9] = 14;
	arr[10] = 26;
	arr[11] = 17;
	arr[12] = 28;
	mergeSort(arr,13);
	cout << endl;
	for (int i = 0; i < 13; i++)
		cout << arr[i]<<" ";
	delete[]arr;
	return 0;
}

6…希尔排序
思想：给定一个数组，给定一个间隔值m，相隔m距离的两个数比较，然后不断缩小m，我是每次取前一次的一半，直到m等于1的时候进行简单的插入排序
解决：一个函数用来做递归，根据m的不同；一个用于排序，m>1之前就是简单比较加交换，m=1时就插入排序，刚好能复习一下插入排序
时复：O（n*logn）
代码：

// test1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include "pch.h"
#include <iostream>
#include <vector>
using namespace std;

void sort(int *A, int n, int m)
{
	if (m > 1)
	{
		for (int i = 0; m + i < n; i++)
		{
			if (A[i] > A[i + m])
			{
				int temp = A[i];
				A[i] = A[i + m];
				A[i + m] = temp;
			}
		}
		for (int i = 0; i < n; i++)
		{
			cout << A[i] << " ";
		}
		cout << endl;
	}
	else
	{
		for (int i = 1; i < n; i++)
		{
			for (int j = 0; j < i; j++)
			{
				if (A[i] < A[j])
				{
					int temp = A[j];
					A[j] = A[i];
					A[i] = temp;
				}
			}
		}
	}
}
void shell(int *A, int n, int m)
{
	if (m>1 && m % 2 != 0)
		m = m / 2 + 1;
	else if(m>1 && m % 2==0)
		m = m / 2;
	if (m > 1)
	{
		sort(A, n, m);
		shell(A, n, m);
	}
	else if (m == 1)
	{
		sort(A, n, m);
	}
}
int* shellSort(int* A, int n) {
	// write code here
	int m = n;
	shell(A, n, m);
	return A;
}

int main()
{
	int *arr = new int[13];
	arr[0] = 54;
	arr[1] = 35;
	arr[2] = 48;
	arr[3] = 36;
	arr[4] = 27;
	arr[5] = 12;
	arr[6] = 44;
	arr[7] = 44;
	arr[8] = 8;
	arr[9] = 14;
	arr[10] = 26;
	arr[11] = 17;
	arr[12] = 28;
	shellSort(arr,13);
	cout << endl;
	for (int i = 0; i < 13; i++)
		cout << arr[i]<<" ";
	delete[]arr;
	return 0;
}

7.堆排序
等学完数据结构在写。

写了六个排序，让我把很不能理解的递归又加深理解了一点，唉，还是觉得自己好菜。
感谢我的朋友的耐心指导。
一起学算法的同学都不剩几个了，感谢自己没放弃，虽然我常常觉得自己不适合学计算机。
go on the road.