排序算法

排序算法

算法导论中对排序问题的描述

输入：n个数的序列<a₁,a₂,...,a_n>。

输出：输入序列的一个重排<a'₁,a'₂,...a'_n>，使a'₁<=a'₂<=...<=a'_n。

 

（首先声明下，下面的代码中伪代码是算法导论上抄的，c代码是自己写的。所以c语言的代码如果有问题请指教。）

 

1.插入排序

伪代码：

INSERSION-SORT(A)
for j <- 2 to length[A]
    do key <- A[j]
       i <- j-1
    while i>0 and A[i]>key
        do A[i+1] <- A[i]
           i <- i-1
    A[i+1] <- key

c实现

void InsertionSort(int A[],int n)
{
    int key;
    int i,j;
    for(i=1;i<n;i++)
    {
        key = A[i];
        j = i-1;
        while(key >= A[j] && j>=0)
        {
            A[j+1] = A[j];
            j--;
        }
        A[j+1] = key;
    }
}

• 2.冒泡排序

伪代码：

BUBBLESORT(A)
for i <- 1 to length[A]
    do for j <- length[A] downto i+1
           do if A[j]<A[j-1]
              then exchange A[j] <-> A[j-1]

c实现：

void BubbleSort(int A[],int n)
{
    int i,j;
    int tmp;
    for(i=0;i<n;i++)
    {
        for(j = n-1;j>=i+1;j--)
        {
            if(A[j]>A[j-1])
            {
                tmp = A[j];
                A[j] = A[j-1];
                A[j-1] = tmp;
            }
        }
    }
}

在冒泡排序中如果做一个判断，在一趟起泡的过程中如果没有任何一次交换就终止循环。这样可以节省一些时间的开销。

• 3.归并排序

MERGE(A,p,q,r)
n1 <- q-p+1
n2 <- r-q
creat arrays L[1...n1+1]andR[1...n2+1]
for i <- 1 to n1
    do L[i] <- A[p+i-1]
for j <- 1 to n2
    do R[j] <- A[p+j]
L[n1+1] <- ∞
R[n2+1] <- ∞
i <- 1
j <- 1
for k <- p to r
    do if L[i]<=R[j]
          then A[k] <- L[i]
               i <- i+1
          else A[k] <- R[j]
               j <- j+1
               
MERGE-SORT(A,p,r)
if p<r
   then q <- └(p+q)/2┘
        MERGE-SORT(A,p,q)
        MERGE-SORT(A,q+1,r)
        MERGE(A,p,q,r)

c实现：

void Merge(int A[],int p,int q,int r)
{
    int n1,n2;
    n1 = q-p+1;
    n2 = r-q;
    int *L = (int *)malloc(sizeof(int)*(n1+1));
    int *R = (int *)malloc(sizeof(int)*(n2+1));
    int i,j;
    for(i=0;i<n1;i++)
    {
        L[i] = A[p+i];
    }
    for(j=0;j<n2;j++)
    {
        R[j] = A[q+j+1];
    }
    L[n1] = INT_MAX;
    R[n2] = INT_MAX;
    i = 0;
    j = 0;
    int k;
    for(k=p;k<=r;k++)
    {
        if(L[i]<=R[j])
        {
            A[k] = L[i];
            i++;
        }
        else
        {
            A[k] = R[j];
            j++;
        }
    }
    free(L);
    free(R);
}
void MergeSort(int A[],int p,int r)
{
    int q;
    if(p<r)
    {
        q = p + (r-p)/2;
        MergeSort(A,p,q);
        MergeSort(A,q+1,r);
        Merge(A,p,q,r);
    }
}

• 4.堆排序

伪代码：

PARENT(i)
  return i*2
LEFT(i)
  return 2i
RIGHT(i)
  return 2*i+1
MAX-HEAPIFY(A,i)
l <- LEFT(i)
r <- RIGHT(i)
if l<=heap-size[A] and A[l]>A[i]
   then largest <- l;
   else largest <- i;
if r<=heap-size(A) and A[r]>A[largest]
   then largest <- r
if largest != i
   then exchange A[i] <-> A[largest]
        MAX-HEAPIFY(A,largest)
BUILD-MAX-HEAP(A)
heap-size[A] = length[A]
for i <- └length[A]/2┘ downto 1
    do MAX-HEAPIFY(A,i)
HEAP-SORT(A)
BUILD-MAX-HEAP(A)
for i <-length[A] downto 2
    do exchange A[1] <-> A[i]
       heap-size[A] <- heap-size[A]-1
       MAX-HEAPIFY(A,1)

c实现：

#define PARENT(i)(((i)-1)/2)
#define LEFT(i)(2*((i)+1)-1)
#define RIGHT(i)(2*((i)+1))
void MaxHeapify(int A[],int i,int size)
{
    int l = LEFT(i);
    int r = RIGHT(i);
    int largest = i;
    int tmp;
    if(l<size && A[i]<A[l])
    {
        largest = l;
    }
    if(r<size && A[r]>A[largest])
    {
        largest = r;
    }
    if(largest != i)
    {
        tmp = A[i];
        A[i] = A[largest];
        A[largest] = tmp;
        MaxHeapify(A,largest,size);
    }
}
void BuildMaxHeap(int A[],int size)
{
    int i;
    for(i=size/2;i>=0;i--)
    {
        MaxHeapify(A,i,size);
    }
}
void HeapSort(int A[],int size)
{
    BuildMaxHeap(A,size);
    int i;
    int j;
    int tmp;
    for(i=size-1;i>0;i--)
    {
        tmp = A[i];
        A[i] = A[0];
        A[0] = tmp;
        MaxHeapify(A,0,i);
    }
}

• 5.快速排序

快速排序伪代码

PARTTION(A,p,q)
x <- A[p]
j <- p
for i <- p+1 to q
    if A[i]>x
       then j <- j+1
            exchange A[j] <->A[i]
exchange A[j] <-> A[p]
QUICK-SORT(A,p,q)
if p<q
   then r = PARTTION(A,p,q)
        QUICK-SORT(A,p,r-1)
        QUICK-SORT(A,r+1,q)

c实现

 

#include<stdio.h>
void swap(int *a,int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}
int parttion(int A[],int p,int q)
{
    int x = A[p];
    int i,j;
    j = p;
    for(i=p+1;i<=q;i++)
    {
        if(A[i]<x)
        {
            j++;
            swap(&A[j],&A[i]);
        }
    }
    swap(&A[j],&A[p]);
    return j;
}
void QuickSort(int A[],int p,int q)
{
    if(p>=q)return;
    int r = parttion(A,p,q);
    QuickSort(A,p,r-1);
    QuickSort(A,r+1,q);
}

 

 

 

• 6.基数加桶排序（用了两个桶，分别装0，1）

基数排序伪代码：

RADIX-SORT(A,D)
for i <- 1 to d
    do use a stable sort to sort array A on digit i

桶排序伪代码：

BUCKET-SORT(A)
n <- length[A]
for i <- 1 to n
    do insert A[i] into list B[└nA[i]┘]
for i <- 0 to n-1
    do sort list B[i] with insertion sort
concatenate the lists B[0],B[1],...,B[n-1] together in order

 

c实现

#define GET(X,N)(((X>>(N-1))&0x1))/*获取第n bit*/
void RadixBucketSort(int A[],int n)
{
    int * Bucket = malloc(sizeof(int)*n);/*一个数组当两个桶用的*/
    int i,j,z,num,pos1,pos2;
    for(num=1;num<32;num++)
    {
        i =0;
        j=n-1;
        for(z=0;z<n;z++)
        {
            if(GET(A[z],num)==1)
            {
                Bucket[i]=A[z];
                i++;
            }
            else
            {
                Bucket[j]=A[z];
                j--;
            }
        }
        pos1 = 0;
        pos2 = n-1;
        for(z=0;z<n;z++)
        {
            if( pos1!=i )
            {
                A[z]=Bucket[pos1];
                pos1++;
            }
            else
            {
                A[z]=Bucket[pos2];
                pos2--;
            }
        }

    }
    free(Bucket);
}

上面的算法中，算是基数排序加桶排序吧。我把一个数字从低到高每一个二进制位作为基数排序中的每一趟。也就是说我把一个int类型分成31个位。而每个二进制位只有1或0两种可能。所以将数据放入两个桶中时就自然的排好了序。所以我认为自己用了桶排序，呵呵。因为以上的原因，所以算法中只能对正数进行处理。如果要对负数或其他类型的数据进行排序的话，就要重新改进算法了。所以这些算法是有适用范围的。但比起比较排序，这些排序算法确实要快些。在数量很大的时候经过测试确实上面的算法比快排要快，呵呵。