mu_tou_man

导航

 

1.选择排序

  选择排序的基本原理是:每次找出最小的元素放到前面,具体的:

  对于一组给定的记录a1,a2,a3.......an;

  第一次循环:从a2开始到an,依次和a1进行比较,找到小于a1当中最小的一个,与a1进行交换,否则不交换;

  第二次循环:从a3开始到an,依次和a2进行比较,找到小于a2当中最小的一个,与a2进行交换,否则不交换;

  ......

  一直到循环结束。

  egg{2 4 6 7 1 3 8 9}

    第一次1 2 [6 7 4 3 8 9]

    第二次1 2 3 [7 4 6 8 9]

    第三次1 2 3 4 [7 6 8 9]

    第四次1 2 3 4 6 [7 8 9]

    第五次1 2 3 4 6 7 [8 9]

    第六次1 2 3 4 6 7 8 [9]

    第七次1 2 3 4 6 7 8 9 

  代码如下:

#include <iostream>
using namespace std;

void Swap(int &a,int &b)
{
    int temp=a;
    a=b;
    b=temp;
}

//选择排序算法 时间复杂度为o(n*n)
void SelectSort(int a[], int length)
{
    int i=0;//外层循环 从0到length-2
    int j=0;//内层循环 从i+1到length-1
    int MinPos=0;//每次比较的最小元素位置
    for (i=0;i<length-1;i++)//从第一个到倒数第二个元素
    {
        MinPos=i;
        for (j=i+1;j<length;j++)
        {
            if (a[j]<a[MinPos])
            {
                MinPos=j;
            }
        }
        if(MinPos!=i)//找到了比a[i]更小的元素 交换
        {
            Swap(a[i],a[MinPos]);
        }
    }
}

 

2.插入排序

  插入排序算法原理:假设前k个元素是有序排列的,新插入元素依次和前k个元素比较,插入到合适的位置,具体地:

  给出一组记录,a1,a2,a3…….an;
  第一次循环:假定a1有序,插入a2,如果a2小于该元素,则交换a1,a2,否则不交换,此时a1 a2有序;
  第二次循环:插入a3,如果a3小于a2,交换a3,a2,再将a2与a1比较,如果小则换,此时a1 a2 a3有序;
  ......
  第n-1次循环:插入a[n],依次和前面所有元素比较,交换。

  egg:{4,2,6,7,1,3,8,9}


    第一次[2 4]6 7 1 3 8 9
    第二次[2 4 6]7 1 3 8 9
    第三次[2 4 6 7]1 3 8 9
    第四次[1 2 4 6 7]3 8 9
    第五次[1 2 3 4 6 7]8 9
    第六次[1 2 3 4 6 7 8]9
    第七次[1 2 3 4 6 7 8 9]

void InsertSort(int a[],int length)
{
    int i=0;
    int j=0;
    for (i=0;i<length-1;i++)
    {
        for (j=i+1;j>=1;j--)
        {
            if (a[j]<a[j-1])
            {
                Swap(a[j],a[j-1]);
            }
        }
    }
}

 3.冒泡排序:

   冒泡排序算法原理:从第一个记录开始依次对相邻的两个元素进行比较,如果前面的元素大于后面的元素就交换,这样,第一轮下来,最大的数已经排到了末尾,然后再对前n-1个元素进行如上交换。
  egg:{4 2 6 7 1 3 9 8}
    第一次:[2 4 6 1 3 7 8]9
    第二次:[2 4 1 3 6 7]8 9
    第三次:[2 1 3 4 6]7 8 9
    第四次:[1 2 3 4]6 7 8 9
    第五次:[1 2 3]4 6 7 8 9
    第五次:[1 2]3 4 6 7 8 9
    第六次:[1]2 3 4 6 7 8 9
    第七次: 1 2 3 4 6 7 8 9

void BubbleSort( int a[] , int length )
{
    int i,j;
    for (i = 0; i < length-1; i++)  
    {
        for (j = 1; j < length - i; j++)  
        {
            if (a[j -1]> a[j])  
            {
                Swap(a[j],a[j-1]);
            }
        }
    }
}

4.希尔排序

  算法原理:将无序记录分为若干个子列,子列是间隔抽取的,间隔个数为增量,对各个子列进行插入排序;然后选一个更小的增量,重新划分子列,再次进行插入排序......;最后选择增量为1,也就是整个序列作为一个序列,进行插入排序,是最终记录成为有序。

  增量选择,首选Incre=length/2,每次缩小一倍,直到Incre为1;
  

  egg:{4,2,6,7,1,3,8,9}

    Incre=8/2=4
    第一个子列4,1 排序后 1,4
    第二个子列2,3 排序后 2,3
    第三个子列6,8 排序后 6,8
    第四个子列7,9 排序后 7,9
  第一次排序完后
    1 2 6 7 4 3 8 9
    

    增量选为4/2=2

    第一个子列1 6 4 8 排序后 1 4 6 8
    第二个子列2 7 3 9 排序后 2 3 7 9
  第二次排序完后
    1 2 4 3 6 7 8 9
    

    增量选为1
  第三次排序完后
    1 2 3 4 6 7 8 9

 代码如下:

void ShellSort(int a[], int length)
{
    int i=0;
    int j=0;
    int temp=0;
    for (int Incre = length / 2; Incre > 0; Incre /= 2)
        for (i = Incre; i < length; ++i)
        {
            temp = a[i];
            for(j = i -Incre; j >= 0 ; j -=Incre)
            {
                if (temp<a[j])
                {
                    a[j+Incre] = a[j];
                }
                else
                    break;
            }  
            a[j+Incre] = temp;
        }
}

5.快速排序:

快速排序是一个就地排序,分而治之,大规模递归的算法。从本质上来说,它是归并排序的就地版本。快速排序可以由下面四步组成。

(1) 如果不多于1个数据,直接返回。
(2) 一般选择序列最左边的值作为支点数据。
(3) 将序列分成2部分,一部分都大于支点数据,另外一部分都小于支点数据。
(4) 对两边利用递归排序数列。

快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况下写出比快速排序快的算法,但是就通常情况而言,没有比它更快的了。快速排序是递归的,对于内存非常有限的机器来说,它不是一个好的选择。 

 初始化关键字: [49 38 65 97 76 13 27 49]

第一趟排序之后[27 38 13 ]49 [76 97 65 49]

第二趟排序之后[13] 27 [38] 49 [49 65] 76 [97]

第三趟排序之后13 27 38 49 49 [65] 76 97

最后结果:     13 27 38 49 49 65 76 97

void QuickSort(int array[],int low ,int high)//调用的时候 high的位置要填length-1
{
    int i;
    int j;
    int idex;
    if (low>=high)
    {
        return;
    }
    i=low;
    j=high;
    idex=array[i];
    while (i<j)//执行完后 一趟排序 第一个元素将所有元素分成左右两等分
    {
        while (i<j&&array[j]>=idex)//从右向左寻找第一个小于idex的数
        {
            j--;
        }
        if (i<j)//如果找到了 交换两个数 并且i右移一下
        {
            array[i]=array[j];
            i++;
        }
        while (i<j&&array[i]<idex)//从左向右寻找第一个大于idex的数
        {
            i++;
        }
        if (i<j)
        {
            array[j]=array[i];
            j--;
        }
    }
    array[i]=idex;//中间划分位置元素
    QuickSort(array,low,i-1);//左半部分递归
    QuickSort(array,i+1,high);//右半部分递归
}

 

6.归并排序:

       归并排序先分解要排序的序列,从1分成2,2分成4,依次分解,当分解到只有1个一组的时候,就可以排序这些分组,然后依次合并回原来的序列中,这样就可以排序所有数据。合并排序比堆排序稍微快一点,但是需要比堆排序多一倍的内存空间,因为它需要一个额外的数组。

初始关键字: [49]  [38]  [65]  [97]  [76]  [13]  [27]

一趟归并后:[38 49] [65 97] [13 76] [27]

两趟归并后:[38 49   65 97]  [13  27  76]

三趟归并后:[13 27   38 49    65  76  97

 

void copyArray(int source[], int dest[],int len,int first)
{
    int i;
    int j=first;
    for(i=0;i<len;i++)
    {
        dest[j] = source[i];
        j++;
    }
}


void merge(int a[],int left,int right)
{
    int begin1 = left;
    int mid = (left+right)/2 ;
    int begin2 = mid+1;
    int k=0;
    int newArrayLen = right-left+1;
    int *b = (int*)malloc(newArrayLen*sizeof(int));
    while(begin1<=mid && begin2<=right)
    {
        if(a[begin1]<=a[begin2])
            b[k++] = a[begin1++];
        else
            b[k++] = a[begin2++];
    }
    while(begin1<=mid)
        b[k++] = a[begin1++];
    while(begin2<=right)
        b[k++] = a[begin2++];
    copyArray(b,a,newArrayLen,left);
    free(b);
}




void mergeSort(int a[],int left,int right)
{
    int mid;// 保证至少有两个元素
    if(left < right)
    {
        mid = (left+right)/2;
        mergeSort(a,left,mid );
        mergeSort(a,mid +1,right);
        merge(a,left,right);
    }
}

7.堆排序http://www.cnblogs.com/dolphin0520/archive/2011/10/06/2199741.html

堆排序适合于数据量非常大的场合(百万数据)。

堆排序不需要大量的递归或者多维的暂存数组。这对于数据量非常巨大的序列是合适的。比如超过数百万条记录,因为快速排序,归并排序都使用递归来设计算法,在数据量非常大的时候,可能会发生堆栈溢出错误。

堆排序会将所有的数据建成一个堆,最大的数据在堆顶,然后将堆顶数据和序列的最后一个数据交换。接下来再次重建堆,交换数据,依次下去,就可以排序所有的数据。

 


void AdjustMaxHeap(int a[],int pos ,int len)
{
    int temp;
    int child;
    for (temp=a[pos];2*pos+1<=len;pos=child)
    {
        child=2*pos+1;//根节点的左孩子
        if (child<len&&a[child]<a[child+1])//如果左孩子小于右孩子 将右孩子的值作为交换
        {
            child++;
        }
        if (a[child]>temp)//如果值大的孩子大于根节点,把该孩子节点值赋给父节点
        {
            a[pos]=a[child];
        }
        else //如果两个孩子都不大于根节点的值 不交换
            break;
    }
    a[pos]=temp;//将父节点的值赋给子节点
}

void HeapSort(int a[],int len)
{
    int i;
    for (i=len/2-1;i>=0;i--)//建立堆
    {
        AdjustMaxHeap(a,i,len-1);
    }
    for (i=len-1;i>=0;i--)//堆排序
    {
        Swap(a[0],a[i]);
        AdjustMaxHeap(a,0,i-1);
    }
}

 

 

 

 

排序方法

最好时间

平均时间

最坏时间

辅助存储

稳定性

备注

选择排序

O(n2)

O(n2)

O(n2)

O(1)

不稳定

n小好

插入排序

O(n)

O(n2)

O(n2)

O(1)

稳定

大部分有序好

冒泡排序

O(n)

O(n2)

O(n2)

O(1)

稳定

n小好

希尔排序

O(n)

O(nlogn)

O(ns)1<s<2

O(1)

不稳定

S是所选分组

快速排序

O(nlogn)

O(nlogn)

O(n2)

O(logn) 

不稳定

n大好

堆排序

O(nlogn)

O(nlogn)

O(nlogn)

O(1)

不稳定

n大好

归并排序

O(nlogn)

O(nlogn)

O(nlogn)

O(n) 

稳定

n大好

posted on 2014-08-12 09:15  mu_tou_man  阅读(237)  评论(0编辑  收藏  举报