排序算法

一、  http://www.tyut.edu.cn/kecheng1/site01/suanfayanshi/straight_insertion_sort.asp

http://v.youku.com/v_show/id_XNjg1NTQ3NzI0.html

 （1）简单冒泡

#include<iostream>
using namespace std;
#define MAXSIZE 10
struct sqlist{
    int r[MAXSIZE-1];
    int length;
};
void swap(sqlist *L,int i,int j)
{
    int temp=L->r[i];
    L->r[i]=L->r[j];
    L->r[j]=temp;
}
///简单的冒泡
void bubbleSort0(sqlist *L)
{
    int i,j;
    for (i=0;i<L->length-1;i++)
    {
        for (j=i+1;j<L->length-1;j++)
        {
            if (L->r[i]>L->r[j])
            {
                swap(L,i,j);
            }
        }
    }

（2）正宗冒泡排序算法  --两两比较

int main()
{
    int R[10]={2,3,57,4,85,45,23,89,5,7};
    int length=10;
    for (int i =1;i<=length;i++)   ///9个位置
    {
        for (int j=length-1;j>=i;j--)
        {
            if (R[j]<R[j-1])
            {
                int temp=R[j];
                R[j]=R[j-1];
                R[j-1]=temp;
            }
        }
    }

    for (int i=0;i<10;i++)
    {
        cout<<R[i]<<' ';
    }
}

9.3.4冒泡排序复杂度分析
分析一下宫的时间复杂度。当最好的情况，也就是要排序的表本身就是有序的，
那么我们比较次数，根据最后改进的代码，可以推断出就是n一1 次的比较，没有数
据交换，时间复杂度为O(吟。当最坏的情况，即待排序表是逆序的情况，此时需要比
品 n(n-l}
较L(i-I}=1+2+3+…+(n-l)=一一一次，并作等数量级的记录移动。因此，
告 2
总的时间复杂度为O(n2)

二、简单选择排序

////简单选择排序//
/*多次比较，一次交换*/
void SelectSort(int * p,int  length)
{
    int i,j,min;
    for(i=0;i<length;i++)                                        //依次往后，确定每一个位置的，确定最小值
    {    
        min=i;
        for (j=i+1;j<length;j++)
        {                                                               // 依次往后比较选出最小的  下表min ，min中存的就是 最小值的下标，，，，int R[10]={2,3,57,4,85,45,23,89,5,7};
            if(p[min]>p[j]) 
                min=j;                                             //每次比较，min的值可能是不断变化的
        }
        if(i!=min)                             //min与i 不相等，说明是后面查到有小的 然后进行交换，最后第一i位置存最小值
        {
            int temp=p[i];
            p[i]=p[min];
            p[min]=temp;
        }
}

} 

 

三、 直接插入排序

void InsertSort(int * p,int length)
{
    int i,j,temp;
    for( i=1;i<length;i++){
        if (p[i]<p[i-1])
        {
            temp=p[i];                     /*设置哨兵*/
            for(j=i-1;p[j]>temp;j--)
                p[j+1]=p[j];             /*记录后移*/
            p[j+1]=temp;                 /*插入到正确位置*/
        }
    }
}

时间复杂度还是n 的平方

 

四、 希尔排序

void ShellSort(int *p,int n)
{
    int d,i,j,temp;
    for(d=n/2;d>=1;d=d/2) //总体的循环步骤 ，以d/2 下降 ，最终至少为1 步长
    {
        for(i=d;i<n;i++) // 根据步长进行处理 依次沿着d往后处理
        {
            temp=p[i];  /*先吧d 位置的数据取出来再说*/
            for(j=i-d;(j>=0)&&(p[j]>temp);j=j-d)   /*处理与d对应的前面的数据比较*/
            {
                p[j+d]=p[j];
            }
            p[j+d]=temp;
        }
    }
}

 

转载于:https://www.cnblogs.com/Flyzhcong/p/3637608.html