9种排序方法

最新推荐文章于 2024-08-18 17:38:39 发布

与日平肩以头抢地

最新推荐文章于 2024-08-18 17:38:39 发布

阅读量408

点赞数

CC 4.0 BY-SA版权

文章标签：算法

本文链接：https://blog.csdn.net/fool_best/article/details/104043163

#9种常用排序方法如下

#插入排序 Insertion Sort

对未排序数据中进行从后向前的扫描，并找到相应的位置插入

#include<stdio.h>
#include<stdio.h>
#include<string.h>

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

int main()
{
    int i,n;
    while(scanf("%d",&n)!=EOF)
    {
        int arr[100];
        for(i=0;i<n;i++)
        {
            scanf("%d",&arr[i]);
        }
        insertion_sort(arr,n);
        for(i=0;i<n-1;i++)
        {
            printf("%d ",arr[i]);
        }
        printf("%d\n",arr[n-1]);
    }
    return 0;
}

#希尔排序 Shell Sort (由插入排序改进)

把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

#include<stdio.h>
#include<stdlib.h>

void shell_sort(int arr[],int len)
{
    int i,j,k,temp;
    int n=len;
    while(1)
    {
        n/=2;
        for(i=0;i<n;i++)
        {
            for(j=i+n;j<len;j+=n)
            {
                temp=arr[j];
                k = j-n;
                while(k>=0&&arr[k]>temp)
                {
                    arr[k+n]=arr[k];
                    k-=n;
                }
                arr[k+n]=temp;
            }
        }
        if(n==1)
            break;
    }
}

int main()
{
    int i,n;
    while(scanf("%d",&n)!=EOF)
    {
        int arr[100];
        for(i=0;i<n;i++)
        {
            scanf("%d",&arr[i]);
        }
        shell_sort(arr,n);
        for(i=0;i<n-1;i++)
        {
            printf("%d ",arr[i]);
        }
        printf("%d\n",arr[n-1]);
    }
    return 0;
}

#选择排序 Selection Sort

算法不稳定，每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

#include<stdio.h>
#include<stdlib.h>

void selection_sort(int arr[],int len)
{
    int i,j,t;
    for(i=0;i<len;i++)
    {
        for(j=0;j<len;j++)
        {
            if(arr[i]<arr[j])
            {
                t=arr[i];
                arr[i]=arr[j];
                arr[j]=t;
            }
        }
    }
}

int main()
{
    int i,n;
    while(scanf("%d",&n)!=EOF)
    {
        int arr[100];
        for(i=0;i<n;i++)
        {
            scanf("%d",&arr[i]);
        }
        selection_sort(arr,n);
        for(i=0;i<n-1;i++)
        {
            printf("%d ",arr[i]);
        }
        printf("%d\n",arr[n-1]);
    }
    return 0;
}

#归并排序 Merge Sort

排序比较稳定，要求信息尽量按照原本的顺序排列

#include <stdlib.h>
#include <stdio.h>
#include<string.h>

 void Merge(int sourceArr[],int tempArr[], int startIndex, int midIndex, int endIndex)
{
    int i = startIndex, j=midIndex+1, k = startIndex;
    while(i!=midIndex+1 && j!=endIndex+1)
    {
        if(sourceArr[i] > sourceArr[j])
            tempArr[k++] = sourceArr[j++];
        else
            tempArr[k++] = sourceArr[i++];
    }
    while(i != midIndex+1)
        tempArr[k++] = sourceArr[i++];
    while(j != endIndex+1)
        tempArr[k++] = sourceArr[j++];
    for(i=startIndex; i<=endIndex; i++)
        sourceArr[i] = tempArr[i];
}
 //内部使用递归
void MergeSort(int sourceArr[], int tempArr[], int startIndex, int endIndex)
{
    int midIndex;
    if(startIndex < endIndex)
    {
        midIndex = startIndex + (endIndex-startIndex) / 2;//避免溢出int
        MergeSort(sourceArr, tempArr, startIndex, midIndex);
        MergeSort(sourceArr, tempArr, midIndex+1, endIndex);
        Merge(sourceArr, tempArr, startIndex, midIndex, endIndex);
    }
}
int main(int argc, char * argv[])
{
    int i,n;
    while(scanf("%d",&n)!=EOF)
    {
        int a[1000];
        for(i=0;i<n;i++)
            scanf("%d",&a[i]);
        int b[1000];
        MergeSort(a,b,0,n-1);
        for(i=0;i<n;i++)
            printf("%d ", a[i]);
        printf("\n");
    }
    return 0;
}

#快速排序 Quick Sort

#include<stdio.h>
#include<stdlib.h>

void selection_sort(int arr[],int left,int right)
{
    int i,j,key;
    if(left<right)
    {
        i=left;
        j=right;
        key=arr[left];
        while(i<j)
        {
            while(i<j&&key<=arr[j])
            {
                j--;
            }
            arr[i]=arr[j];
            while(i<j&&key>=arr[i])
            {
                i++;
            }
            arr[j]=arr[i];
        }
        arr[i]=key;
        selection_sort(arr,left,i-1);
        selection_sort(arr,i+1,right);
    }
}

int main()
{
    int i,n;
    while(scanf("%d",&n)!=EOF)
    {
        int arr[100];
        for(i=0;i<n;i++)
        {
            scanf("%d",&arr[i]);
        }
        selection_sort(arr,0,n);
        for(i=0;i<n-1;i++)
        {
            printf("%d ",arr[i]);
        }
        printf("%d\n",arr[n-1]);
    }
    return 0;
}

#堆排序 Heap Sort

在堆的数据结构中，堆中的最大值总是位于根节点(在优先队列中使用堆的话堆中的最小值位于根节点)。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void swap(int* a, int* b)
{
    int temp = *b; *b = *a; *a = temp;
}

void max_heapify(int arr[], int start, int end)
{
    //建立父節點指標和子節點指標
    int dad = start;
    int son = dad * 2 + 1;
    while (son <= end)
    {
        //若子節點指標在範圍內才做比較
        if (son + 1 <= end && arr[son] < arr[son + 1])
        //先比較兩個子節點大小，選擇最大的
        {son++;  if (arr[dad] > arr[son])return ;}
        //如果父節點大於子節點代表調整完畢，直接跳出函數
        else{
            //否則交換父子內容再繼續子節點和孫節點比較
            swap(&arr;[dad], &arr;[son]);
            dad = son;
            son = dad * 2 + 1;
        }
    }
}

void heap_sort(int arr[], int len)
{
    int i;
    //初始化，i從最後一個父節點開始調整
    for (i = len / 2 - 1; i >= 0; i--)
        max_heapify(arr, i, len - 1);
    //先將第一個元素和已排好元素前一位做交換，再重新調整，直到排序完畢
    for (i = len - 1; i > 0; i--)
    {
        swap(&arr;[0], &arr;[i]);
        max_heapify(arr, 0, i - 1);
    }
}

int main()
{
    int i,n;
    while(scanf("%d",&n)!=EOF)
    {
        int arr[1000];
        for(i=0;i<n;i++)
            scanf(%d,&arr[i]);
        int len = (int) sizeof(arr) / sizeof(*arr);
        heap_sort(arr, len);
        for (i = 0; i < len; i++)
            printf("%d ", arr[i]);
        printf("\n");
    }
    return 0;
}

#冒泡排序 Bubble Sort

重复地走访过要排序的元素列，依次比较两个相邻的元素并进行排序

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int main()
{
    int n,i,j,t;
    int arr[100];
    while(scanf("%d",&n)!=EOF)
    {
        memset(arr,0,sizeof(arr));
        for(i=0;i<n;i++)
        {
            scanf("%d",&arr[i]);
        }
        for(i=0;i<n;i++)
        {
            for(j=i+1;j<n;j++)
            {
                if(arr[j]<arr[i])
                {
                    t=arr[j];
                    arr[j]=arr[i];
                    arr[i]=t;
                }
            }
        }
        for(i=0;i<n-1;i++){
            printf("%d ",arr[i]);
        }
        printf("%d\n",arr[n-1]);
    }
    return 0;
}

#梳排序 Comb Sort

能将一串数据依照特定排序方式进行排列的一种算法

例如：冒泡排序、鸡尾酒排序（即双向冒泡排序）

#穷举法排序 Monkey Sort

根据条件确定答案的大致范围，并在此范围内对所有可能的情况逐一验证，直到全部情况验证完毕