基本排序算法小结

 

各种排序归纳：
(函数调用采用了引用)
1：冒泡排序
冒泡排序的基本思想：两两比较待排序的元素的大小，若满足交换条件，则交换，若不满足，则执行下一个元素。
有两层循环，外循环和内循环：外循环控制总的趟数，若10个元素，则总趟数是9趟；一趟下来，就要产生一个最大（小）的数，把其
顶上去，这里得到的是最大的数。内循环控制，一趟之中，两两元素的比较。
#include "stdio.h"

void BubbleSort(int*& p,int len)
{
    int i,j,temp;
    for (i=0;i<len-1;i++)
    {
        for (j=0;j<len-1-i;j++)
        {
            if (p[j]>p[j+1])
            {
                temp=p[j];
                p[j]=p[j+1];
                p[j+1]=temp;
            }
        }
    }
}

int main()
{
    int a[10]={2,1,8,3,4,9,6,5,0,7};
    int*p=a;
    BubbleSort(p,10);
    for (int i=0;i<10;i++)
    {
        printf("%d ",p[i]);
    }
    printf("\n");
    return 0;
}


2：直接插入排序
直接插入排序算法思想：将一个记录插入到一个已经排好序的有序表中，得到一个新的有序，记录数加一的有序表。
1：原来的表是有序 2：记录数加一

#include "stdio.h"

void DirectInsertSort(int*& p,int len)
{
    int i,j;
    int temp;
    for (i=1;i<len;i++)
    {
        temp=p[i];
        for (j=i-1;j>=0&&temp<p[j];j--)
        {
            p[j+1]=p[j];
        }
            p[j+1]=temp;
    }
}

int main()
{
    int a[6]={3,2,5,1,8,6};
    int* q=a;
    DirectInsertSort(q,6);
    for (int i=0;i<6;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
    return 0;
}


3：快速排序算法基本思想：
对一个无序序列，从中选择一个元素作为基准元素，不妨取为待排序的第一个元素，设为tempkey，用此基准元素将无序区分为两个较小的无序区，
R[1..I-1]和R[I+1,H],其中R[1..I-1]都比K小，而R[I+1..H]都比K大，而基准元素则位于最终排序的位置上。
而当R[1..I-1]，和R[I+1..H]均非空时，分别对她们进行上述的划分过程，直至无序区域的元素都已排好序。

#include "stdio.h"

int Partition(int*&,int,int);
void QuikSort(int*& p,int low,int high)
{
    int pivotpos;
    if (low<high)
    {
        pivotpos=Partition(p,low,high);
        QuikSort(p,low,pivotpos-1);
        QuikSort(p,pivotpos+1,high);
    }
}

int Partition(int*& p,int m,int n)
{
    int tempkey=p[m];
    while (m<n)
    {
        while (m<n && p[n]>=tempkey)
        {
            n--;
        }
        if (m<n)
        {
            p[m++]=p[n];
        }
        while (m<n && p[m]<=tempkey)
        {
            m++;
        }
        if (m<n)
        {
            p[n--]=p[m];
        }
    }
    p[m]=tempkey;
    return m;
}

int main()
{
    int a[10]={3,5,1,0,2,9,6,8,7,4};
    int* ptr=a;
    QuikSort(ptr,0,9);
    for (int i=0;i<10;i++)
    {
        printf("%d ",ptr[i]);
    }
    printf("\n");
}


4：选择排序的基本思想
具体的做法：设置一个标志位min，专门用来指向当前最小值，一趟比较下来，min就指向了当前最小值；接着就是交换，
让她与无序序列的第一元素进行交换。
/*思想：每一趟从待排序序列中选出最大（小）的一个元素，顺序放在已经排好序的序列的后面，直到全部待排序
  的序列全部拍排完*/

#include "stdio.h"

void SelectSort(int*& p,int len)
{
    int i,j,temp;
    int min;
    for (i=0;i<len;i++)
    {
        min=i;
        for (j=i+1;j<len;j++)
        {
            if (p[j]<p[min])
            {
                min=j;
            }
        }
        temp=p[i];
        p[i]=p[min];
        p[min]=temp;
    }
}

int main()
{
    int a[10]={3,1,2,8,9,5,4,7,0,6};
    int *ptr=a;
    SelectSort(ptr,10);
    for (int i=0;i<10;i++)
    {
        printf("%d ",ptr[i]);
    }
    printf("\n");
    return 0;
}


5：Shell排序基本思想
Shell排序是对直接插入排序的优化，基本思想为：把待排序元素按照一定的增量分组（这个增量体现在程序
中式gap）,对每组元素进行直接插入排序，随着增量的减小，所分成的组也就越来越多，到增量减小到1时候，
排序完成，是为一个有序序列。

#include "stdio.h"

void ShellSort(int*& p,int len)
{
    int i,j,gap;
    int temp;
    gap=len/2;
    while (gap>0)
    {
        for (i=gap;i<len;i++)
        {
            j=i-gap;
            while (j>=0)
            {
                if (p[j]>p[j+gap])
                {
                    temp=p[j];
                    p[j]=p[j+gap];
                    p[j+gap]=temp;
                    j=j-gap;
                }
                else
                    j=-1;
            }
        }
        gap=gap/2;
    }
}

int main()
{
    int a[10]={4,5,1,3,2,0,9,6,8,7};
    int* ptr=a;
    ShellSort(ptr,10);
    for (int i=0;i<10;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
    return 0;
}

 

 

未完...继续，鼓励下自己...明天周六，剩下几种总结完成....