常用的排序算法

排序算法分为内部排序和外部排序，我们经常说的排序算法就是内部排序

内部排序：数据记录在内存中进行排序

外部排序：排序的数据很大，一次性不能容纳全部的排序记录，在排序的过程中需要访问外存

稳定排序算法：相同的元素位置没有被改变

我们将要了解的排序算法如下：

交换排序：冒泡排序（可以是稳定，可以是不稳定），快速排序（不稳定）

选择排序：简单选择排序（不稳定），堆排序

插入排序：直接插入排序，希尔排序

归并排序

现在我们先来了解一下我们交换排序中的冒泡排序算法

冒泡排序

思想：

1. 比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码如下：

#include<stdio.h>
int a[5];
void swap(int a[],int i,int j)
{
    int t=a[i];
    a[i]=a[j];
    a[j]=t;
}
void Bubblesort(int a[],int n)
{
    int i,j;
    for(i=0;i<n;i++)
    {
        for(j=i;j<n;j++)
        {
            if(a[i]>a[j])
            {
                swap(a,i,j);
            }
        }
    }
}
int main()
{
    int i;
    for(i=0;i<5;i++)
    {
        scanf("%d",&a[i]);
    }
    Bubblesort(a,5);
    for(i=0;i<5;i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}

冒泡排序是最容易了解和掌握的排序算法，但是对于多元素的数据排序是没有效率的，但是冒泡排序也是可以改进的，下面我们看看冒泡排序的改进算法——鸡尾酒排序

此算法与冒泡排序算法的不同在于从上到下又从下到上，而冒泡排序仅仅是从上到下

下面我们看看鸡尾酒排序的算法

#include<stdio.h>
int a[5];
void swap(int a[],int i,int j)
{
    int t=a[i];
    a[i]=a[j];
    a[j]=t;
}
void Bubblesort(int a[],int n)
{
    int i;
    int l=0,r=n-1;
    while(l<r)
    {
        for(i=l;i<r;i++)
        {
            if(a[i]>a[i+1])//max,down将最大值放到底部
            {
                swap(a,i,i+1);
            }
        }
        r--;//因为是放到底部所以是r--
        for(i=r;i>l;i--)
        {
            if(a[i-1]>a[i])//min up将最小值放到顶部
            {
                swap(a,i-1,i);
            }
        }
        l++;//放到底部，所以l++
    }
}
int main()
{
    int i;
    for(i=0;i<5;i++)
    {
        scanf("%d",&a[i]);
    }
    Bubblesort(a,5);
    for(i=0;i<5;i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}

下面我们看看交换排序中的快速排序

快速排序：

 思想：

快速排序主要运用的是递归的思想

快速排序采用分冶法将一个序列分为两个子序列

1.从序列中挑取一个元素作为基准元素

2.把所有比基准小的元素放基准元素的前面，把比基准元素大的放基准元素的后面，相同的可以方任意一边，这个操作叫做分区操作

3.对每个分区递归进行操作1，2，递归结束的条件是序列大小为0或者1。

代码如下：

#include<stdio.h>
#define p 10
int a[p];
void swap(int a[],int i,int j)
{
    int t=a[i];
    a[i]=a[j];
    a[j]=t;
}
int Divide(int a[],int l,int r)//划分序列
{
    int benchmark=a[r];//确定基准元素
    int tail=l-1;//初始化
    int i;
    for(i=l;i<r;i++)//遍历除了基准元素以外的全部元素
    {
        if(a[i]<=benchmark)//把小于基准元素的放左边
        {
            swap(a,++tail,i);
        }
    }
    swap(a,tail+1,r);//把基准元素放到所有比基准元素小的元素后边
    return tail+1;//返回索引
}
void Quicksort(int a[],int l,int r)
{
    if(l>=r)//存在序列大小为0或者为1
        return;
    int index=Divide(a,l,r);//第一次初始化划分序列，且确定基准元素
    Quicksort(a,l,index-1);
    Quicksort(a,index+1,r);
}
int main()
{
    int i;
    for(i=0;i<p;i++)
    {
        scanf("%d",&a[i]);
    }
    Quicksort(a,0,p-1);
    for(i=0;i<p;i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}

下面我们来看看选择排序，先看看选择排序中的简单的选择排序

简单选择排序：

思想:

简单选择排序就是遍历元素，找到当且元素最大或者最小的拿出来，放到自己数组头部，后面找到的数组放数组第1位，2位，以此类推，然后遍历范围减1，一直循环下去，直到遍历范围为1

但是我们要注意简单选择排序和冒泡排序的区别：冒泡排序是相邻的两个元素交换，而选择排序则不是

话不多说，下面我们直接看代码：

#include<stdio.h>
#define p 10
int a[p];
void swap(int a[],int i,int j)
{
    int t=a[i];
    a[i]=a[j];
    a[j]=t;
}
void selectsort(int a[],int n)
{
    int i,j,min;
    for(i=0;i<n;i++)
    {
        min=i;//假定最小元素的位置
        for(j=i+1;j<n;j++)//遍历最小元素后面的元素，找到第最小元素的位置
        {
            if(a[min]>a[j])
            {
                min=j;
            }
        }
        if(min!=i)//交换
        {
            swap(a,min,i);
        }
    }
}
int main()
{
    int i;
    for(i=0;i<p;i++)
    {
        scanf("%d",&a[i]);
    }
    selectsort(a,p);
    for(i=0;i<p;i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}

 下面我们来看看选择排序中的堆排序：

堆排序：

堆排序要借助于堆这种数据结构，主要分两步走，第一步是构造初始堆，第二个输出堆顶元素之后堆怎么调整

我们以大定堆为例：要求其中父节点的值总是大于子节点

#include<stdio.h>
#define p 10
int a[p];
void swap(int a[],int i,int j)
{
    int t=a[i];
    a[i]=a[j];
    a[j]=t;
}
int Adjustment(int a[],int i,int size)//堆的调整
{
    int left_child=2*i+1;
    int right_child=2*i+2;//确定左右孩子位置
    int max=i;//若孩子大于父亲，则交换
    if(left_child<size&&a[left_child]>a[max])
        max=left_child;
    if(right_child<size&&a[right_child]>a[max])
        max=right_child;
    if(max!=i)
    {
        swap(a,max,i);
        Adjustment(a,max,size);
    }
}
int BuildHeap(int a,int n)
{
    int size=n;
    int i;
    for(i=size/2-1;i>=0;i--)//建立最大堆
    {
        Adjustment(a,i,size);
    }
    return size;
}
void Heapsort(int a,int n)//堆排序算法
{
    int size=BuildHeap(a,n);
    while(size>1)
    {
        swap(a,0,--size);//将堆顶元素与最末尾的元素进行交换，升序排列
        Adjustment(a,0,size);
    }
}
int main()
{
    int i;
    for(i=0;i<p;i++)
    {
        scanf("%d",&a[i]);
    }
    Heapsort(a,p);
    for(i=0;i<p;i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}

TRANSLATE with x

English

Arabic	Hebrew	Polish
Bulgarian	Hindi	Portuguese
Catalan	Hmong Daw	Romanian
Chinese Simplified	Hungarian	Russian
Chinese Traditional	Indonesian	Slovak
Czech	Italian	Slovenian
Danish	Japanese	Spanish
Dutch	Klingon	Swedish
English	Korean	Thai
Estonian	Latvian	Turkish
Finnish	Lithuanian	Ukrainian
French	Malay	Urdu
German	Maltese	Vietnamese
Greek	Norwegian	Welsh
Haitian Creole	Persian

 

TRANSLATE with

COPY THE URL BELOW

Back

EMBED THE SNIPPET BELOW IN YOUR SITE

Enable collaborative features and customize widget: Bing Webmaster Portal

Back