归并排序学习总结，递归法&&插入排序&&冒泡排序&&选择排序&&快速排序

void gc(int a[],int first,int b[],int end, int temp[])

{
int i, j, m;
i = j = m = 0;
while (i<=first&&j<=end)
{
if (a[i] < b[j])
temp[m++] = a[i++];
else
temp[m++] = b[j++];
}
while (i <= first)
{
temp[m++] = a[i++];
}
while (i <=end)
{
temp[m++] = b[j++];
}
}//这个是整理两个有序的数组，组合成一个有序的数组的方法

#include<iostream>  

#include<vector>  

#include<algorithm>

#include<set>

using namespace std;

void gc(int a[],int first,int mid,int end, int temp[])//a数组是存放需要排序的数组，temp是临时存放数组

{
int i, j, m,n;
i = first, j = mid+1, m = mid;
n = end;
int k = 0;
while (i<=m&&j<=n)
{
if (a[i] < a[j])
temp[k++] = a[i++];
else
temp[k++] = a[j++];
}//最小值总是被放在temp的考前下标
while (i <= m)
{
temp[k++] = a[i++];
}
while (j <=n)
{
temp[k++] = a[j++];
}//上面两个的作用是把剩下的那个下标未走完的，按顺序给存放到temp数组的最后面
for (int i = 0; i < k; i++)
{
a[first + i] = temp[i];//因为first存放了数组的下标，k统计了已经排序的数字个数
}

}

void fc(int a[],int first ,int end,int temp[])//用到了递归的思想

{
if (end > first)
{
int mid = (first + end) / 2;
fc(a, first, mid, temp);
fc(a, mid + 1, end, temp);
gc(a, first,mid, end, temp);
}

}

int main()

{
int a[] = {2,6,5,9,5,6,3,1,5,8,4},temp[11];
fc(a, 0, 10, temp);
for (int i = 0; i < 11; i++)
{
cout << a[i] << endl;
}
return 0;

}

这样输出的结果是：

1

2

3

4

5

5

5

6

6

8

9

我的参考文献：http://blog.csdn.net/yuehailin/article/details/68961304

他讲的特别好，我只是记录我的学习过程而已。

插入排序

假定第一个元素为已经排好序的，依次对下一个元素进行插入，形成2,3,4,5，6。。。排好序的数组，每个插入进去的数，会导致前面的元素依次往下移动一位。

#include<iostream>  

using namespace std;

void gc(int a[],int n)

{
for (int i = 1; i < n; i++)
{
int temp = a[i],j;//这里的temp指的是要插入的那个数
for ( j = i - 1; j >= 0 && a[j] > temp; j--)     [b]//for ( j = i - 1; j >= 0 && a[j] > a[i]; j--)这样子是错误的
{
a[j + 1] = a[j];//如果之前已经排好序的数，比要插入的那个数temp要大，那么那些排好序的数，自觉往下移动，直到遇到一个比temp小的，
} //然后跳出循环，然后多执行了依次j--，多以，下面a[j+1]，再给赋值要插入的那个数。
a[j + 1] = temp;
}

}

int main()

{
int a[10] = {2,6,8,9,5,3,6,1,5,4};
gc(a, 10);
for (int i = 0; i < 10; i++)
cout << a[i] << endl;

return 0;

}
[/b]

最后打印出来，成功的排好序了。

冒泡排序：

时间复杂度是度量算法执行的时间长短，而空间复杂度是度量算法所需存储空间的大小。

算法的时间复杂度记做：T(n)=O(f(n))

    在计算时间复杂度的时候，先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，再找出T(n)的同数量级（它的同数量级有以下：1、Log2n、n、nLog2n、n的平方、n的三次方、2的n次方、n!），找出后，f(n)=该数量级，如冒泡排序的时间复杂度为T(n)=O(n*n)。

一、冒泡（Bubble）排序

    冒泡排序（BubbleSort）的基本思想是：依次比较相邻的两个数，将小数放在前面，大数放在后面。如此重复下去，直至最终完成排序。

    时间复杂度为O(n*n)，适用于排序小列表。

void BubbleSortArray() 

{

    int i,j,temp;

    for(i=1;i<n;i++) 

    { 

        for(j=0;i<n-i;j++) 

        { 

            if(a[j]>a[j+1]) //比较交换相邻元素 

            { 

                temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; 

            } 

        } 

    } 

}

个人感觉上面的冒泡排序还不纯，是从上往下，把最大的往下推，下面这个可能会更好些，是从下往上，把小的往上冒

#include <stdio.h>  
int main()  
{  
    int    array[10] = {15, 225, 34, 42, 52, 6, 7856, 865, 954, 10};  
    int    i, j;  
    for (i = 0; i < 10; i++)  
    {  
        //每一次由底至上地上升  
        for (j = 9; j > i; j--)  
        {  
            if (array[j] < array[j-1])  
            {  
                    swap(&array[j], &array[j-1]);  
            }  
        }  
    }  
    for (i = 0; i < 10; i++)  
    {  
        printf("%d\n", array[i]);  
    }  
    return    0;  
}  
void swap(int *a, int *b)  
{  
    int    temp;  
    temp = *a;  
      *a = *b;  
      *b = temp;  
}  


b842

选择排序：



    选择排序的基本思想是：每一趟从待排序的数据元素中选出最小的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

    时间复杂度为O(n*n)，适用于排序小列表。

void SelectSortArray() 

{ 

    int i,j,min_index; 

    for(i=0;i<n-1;i++) 

    { 

        min_index=i; 

        for(j=i+1;j<n;j++) //每次扫描选择最小项 

            if(arr[j]<arr[min_index])  min_index=j; 

        if(min_index!=i) //找到最小项交换，将这一项移到列表中的正确位置 

        { 

            int temp; 

            temp=arr[i]; arr[i]=arr[min_index]; arr[min_index]=temp; 

        } 

    } 

}



//快速排序
void quick_sort(int s[], int l, int r)
{
    if (l < r)
    {
              //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
        int i = l, j = r, x = s[l];
        while (i < j)
        {
            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
                            j--; 
            if(i < j)
                            s[i++] = s[j];
                    
            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
                            i++; 
            if(i < j)
                            s[j--] = s[i];
        }
        s[i] = x;
        quick_sort(s, l, i - 1); // 递归调用
        quick_sort(s, i + 1, r);
    }
}

参考文献：https://www.cnblogs.com/morewindows/archive/2011/08/13/2137415.html