通过LeecodeAnimation学习数据结构与算法（0）上

1. 冒泡排序（Buddle Sort）
   1.1 算法步骤
   比较相邻的元素。如果第一个比第二个大，就交换他们两个。

   对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

   针对所有的元素重复以上的步骤，除了最后一个。

   持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
   1.2 动画演示
   
   1.3 使用C++自己实现代码如下：

#include <iostream>
void Buddle_sort(int A[],int n)
{

    int temp;
    for(int j=n-2;j>-1;j--)
        for(int i=j;i>-1;i--)
    {
        if(A[i]>A[i+1])
        {
            temp=A[i];
            A[i]=A[i+1];
            A[i+1]=temp;
        }
    }

}

int main() {
    int A[]={4,2,3,1,5};
    Buddle_sort(A,5);
    for(int i=0;i<5;i++)
        std::cout<<A[i];
    std::cout<<"\n";

    return 0;
}

2. 选择排序（Selection Sort）
   2.1 算法步骤
   首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

   再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

   重复第二步，直到所有元素均排序完毕。

   2.2 动画演示
   
   2.3 c++代码如下：

#include <iostream>
void Selection_Sort(int* A,int n)
{
    int min;
    int minn;
    int temp;
    for(int i=0;i<n;i++)
    {
        min=A[i];
        minn=i;
        for(int j=i;j<n;j++)
        {
            if(min>A[j])
            {
                min=A[j];
                minn=j;
            }

        }
        if(minn!=i)
        {
            temp=A[i];
            A[i]=A[minn];
            A[minn]=temp;
        }
    }
}
int main() {

    int B[]={5,2,3,4,1};
    Selection_Sort(B,5);
    for(int i=0;i<5;i++)
        std::cout<<B[i];
    std::cout<<"\n";
    return 0;
}

3. 插入排序（Insertion Sort）
   3.1 算法步骤
   将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

   从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

   3.2 动画演示
   
   3.3 C++代码如下：

#include <iostream>
void Insertion_Sort(int* A,int n)
{
    int tmp;
    for(int i=1;i<n;i++)
    {
        tmp=A[i];
        for(int j=i;j>-1;j--)
        {
            if(tmp<A[j-1])
            {
                A[j]=A[j-1];
            }
            else
            {
                A[j]=tmp;
                break;
            }
        }
    }

}
int main() {

    int B[]={5,2,3,4,1,6,0};
    int size_B=sizeof(B)/sizeof(B[0]);
    Insertion_Sort(B,size_B);
    for(int i=0;i<size_B;i++)
        std::cout<<B[i];
    std::cout<<"\n";
    return 0;
}

4. 希尔排序（Shell’s Sort）
   4.1 算法步骤
   选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

   按增量序列个数 k，对序列进行 k 趟排序；

   每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

   4.2 动画演示
   
   4.3 C++代码如下：

#include <iostream>
void Insertion_Sort(int* A,int n,int interval) //为了使奇偶分别插入排序成为可能
{
    int tmp;
    for(int i=interval;i<n;i+=interval)
    {
        tmp=A[i];
        for(int j=i;j>-1;j-=interval)
        {
            if(tmp<A[j-interval])
            {
                A[j]=A[j-interval];
            }
            else
            {
                A[j]=tmp;
                break;
            }
        }
    }

}
void Shell_Sort(int* A,int size){
    int size_half=size/2;
    int tmp;
    for(int i=0;i<size_half;i++)
    {
        if(A[i]>A[i+size_half])
        {
            tmp=A[i];
            A[i]=A[i+size_half];
            A[i+size_half]=tmp;
        }
    }
    Insertion_Sort(A,size,2);
    Insertion_Sort(A+1,size,2);
    Insertion_Sort(A,size,1);
}
int main() {

    int B[]={5,2,3,4,1,6,0,7};
    int size_B=sizeof(B)/sizeof(B[0]);
    Shell_Sort(B,size_B);
    for(int i=0;i<size_B;i++)
        std::cout<<B[i];
    std::cout<<"\n";

    return 0;
}

5. 归并排序（Merge Sort）
   5.1 算法步骤
   申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

   设定两个指针，最初位置分别为两个已经排序序列的起始位置；

   比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

   重复步骤 3 直到某一指针达到序列尾；

   将另一序列剩下的所有元素直接复制到合并序列尾。

   5.2 动画演示
   
   5.3 c++代码，没有用递归，但是调试了好久（作为一个编程捉急的人来说这哪是五分钟学算法，就这个算法从原理到实现搞了一天。。。）

#include <iostream>
#include<cmath>
void merge(int* A, int* B, int interval, int n)
{
	int* left;
	int* right;
	int lcount;
	int rcount;
	int k = 0;
	for (int i = 0; i < n; i += 2 * interval)
	{
		//分配右指针
		if (i + interval < n)
		{
			right = A + i + interval;
			if (i + 2 * interval > n) rcount = 2*interval+i-n;
			else rcount = 0;
		}
		else
		{
			right = A + n - 1;
			rcount = interval;
		}
		//分配左指针
		if (i < n)
		{
			lcount = 0;
			left = A + i;
		}

		else {
			lcount = interval;
			left = A + n - 1;
		}
		while ((k < i + 2 * interval) && (k < n))
		{
			if (*left < *right)
			{
				B[k] = *left;
				k++;
				if (lcount < interval-1)
				{
					left++;
					lcount++;
				}
				else
				{
					while ((rcount < interval) && (k < n))
					{
						B[k] = *right;
						rcount++;
						k++;
						right++;
					}
				}
			}
			else
			{
				B[k] = *right;
				k++;
				if (rcount < interval-1)
				{
					right++;
					rcount++;
				}
				else
				{
					
					while ((lcount < interval) && (k < n))
					{
						B[k] = *left;
						k++;
						lcount++;
						left++;
					}
				}
			}
		}
	}

}
void Merge_Sort(int* A, int n) 
{
	int* B;
	int* C;
	B = (int*)malloc(n * sizeof(int));
	C = (int*)malloc(n * sizeof(int));
	int interval = 1;
	merge(A, B, interval, n);
	int i = 0;
	while (interval < n)
	{

		
		if (i % 2 != 1) {
			merge(B, C, interval, n);
		}
		else merge(C, B, interval, n);
		i++;
		interval = pow(2, i);
	}
	if (i % 2 != 1)
	{
		for (int j = 0; j < n; j++)
			A[j] = B[j];
	}
	else
	{
		for (int j = 0; j < n; j++)
			A[j] = C[j];
	}
	free(B);
	free(C);
}



int main() {

	int B[] = { 5,2,4,3,6,1,0 };
	int size_B = sizeof(B) / sizeof(B[0]);
	Merge_Sort(B, size_B);
	for (int i = 0; i < size_B; i++)
		std::cout << B[i];
	std::cout << "\n";

	return 0;
}

引用： https://mp.weixin.qq.com/s/vn3KiV-ez79FmbZ36SX9lg