排序算法集合

排序算是最常用的算法也是笔试面试中常考的知识点。以下是我总结的六种最常考的排序算法。

先写下包含的子函数。

1.交换函数

//交换函数 
void Swap(int* r,int i,int j)
{
	int temp;
	temp = r[i];
	r[i] = r[j];
	r[j] = temp;
}

2.打印函数

//打印函数 
void printfln(int *r)
{
	int i;
	for(i=0;i<length;i++) 
	{
		printf("%d ",r[i]);
	}
	
	printf("\n");	
}

1、冒泡排序

实现思想

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

代码实现

#include <stdio.h>

int length;
//交换函数 
void Swap(int* r,int i,int j)
{
	int temp;
	temp = r[i];
	r[i] = r[j];
	r[j] = temp;
}
//冒泡排序算法 
void BubbleSort0(int* r)
{
	int i,j;
	int exchange=1;
	
	for(i=0;i<length&&exchange;i++)
	{
		exchange = 0;	
		for(j=length-1;j>i;j--)	
		{
			if(r[j-1]<r[j])
			{
				Swap(r,j-1,j);
				exchange = 1;	
			}
		}
	}
}
//打印函数 
void printfln(int *r)
{
	int i;
	for(i=0;i<length;i++) 
	{
		printf("%d ",r[i]);
	}
	
	printf("\n");	
}

int main()
{
	int r[5] = {9,7,5,8,6};
	//测量数组长度 
	length = sizeof(r)/sizeof(*r);
	
	printfln(r);
	BubbleSort0(r);
	printfln(r);

	
	return 0;
}

2.选择排序

实现思想

选择排序（Selection sort）是一种简单直观的 排序算法 。它的工作原理是每一次从待排序的 数据元素 中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

代码实现

#include <stdio.h>

void println(int array[], int len)
{
    int i = 0;
    
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }
    
    printf("\n");
}

void swap(int array[], int i, int j)
{
    int temp = array[i];
    
    array[i] = array[j];
    
    array[j] = temp;
}

void SelectionSort(int array[], int len) // O(n*n)
{
    int i = 0;
    int j = 0;
    int k = -1;
    
    for(i=0; i<len; i++)
    {
        k = i;
        
        for(j=i; j<len; j++)
        {
            if( array[j] < array[k] )
            {
                k = j;
            }
        }
        
        swap(array, i, k);
    }
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 
    
    println(array, len);
    
    SelectionSort(array, len);
    
    println(array, len);
    
    return 0;
}

3.插入排序

实现思想

每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

代码实现

#include <stdio.h>

void println(int array[], int len)
{
    int i = 0;
    
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }
    
    printf("\n");
}

void swap(int array[], int i, int j)
{
    int temp = array[i];
    
    array[i] = array[j];
    
    array[j] = temp;
}

void InertionSort(int array[], int len) // O(n*n)
{
    int i = 0;
    int j = 0;
    int k = -1;
    int temp = -1;
    
    for(i=1; i<len; i++)
    {
        k = i;
        temp = array[k];
        
        for(j=i-1; (j>=0) && (array[j]>temp); j--)
        {
            array[j+1] = array[j];
            k = j;
        }
        
        array[k] = temp;
    }
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 
    
    println(array, len);
    
    InertionSort(array, len);
    
    println(array, len);
    
    return 0;
}

4.希尔排序

实现思想

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。
代码实现

#include <stdio.h>

void println(int array[], int len)
{
    int i = 0;
    
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }
    
    printf("\n");
}

void swap(int array[], int i, int j)
{
    int temp = array[i];
    
    array[i] = array[j];
    
    array[j] = temp;
}

void ShellSort(int array[], int len) // O(n*n)
{
    int i = 0;
    int j = 0;
    int k = -1;
    int temp = -1;
    int gap = len;
    
    do
    {
        gap = gap / 3 + 1; 
    
        for(i=gap; i<len; i+=gap)
        {
            k = i;
            temp = array[k];
            
            for(j=i-gap; (j>=0) && (array[j]>temp); j-=gap)
            {
                array[j+gap] = array[j];
                k = j;
            }
        
            array[k] = temp;
        }
        
    }while( gap > 1 );
    
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 
    
    println(array, len);
    
    ShellSort(array, len);
    
    println(array, len);
    
    return 0;
}

5.快速排序

实现思想
快速排序（Quicksort）是对冒泡排序的一种改进。
代码实现
#include <stdio.h>

void println(int array[], int len)
{
    int i = 0;
    
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }
    
    printf("\n");
}

void swap(int array[], int i, int j)
{
    int temp = array[i];
    
    array[i] = array[j];
    
    array[j] = temp;
}

int partition(int array[], int low, int high)
{
    int pv = array[low];
    
    while( low < high )
    {
        while( (low < high) && (array[high] >= pv) )
        {
            high--;
        }
        
        swap(array, low, high);
        
        while( (low < high) && (array[low] <= pv) )
        {
            low++;
        }
        
        swap(array, low, high);
    }
    
    return low;
}

void QSort(int array[], int low, int high)
{
    if( low < high )
    {
        int pivot = partition(array, low, high);
        
        QSort(array, low, pivot-1);
        QSort(array, pivot+1, high);
    }
}

void QuickSort(int array[], int len) // O(n*logn)
{
    QSort(array, 0, len-1);
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 
    
    println(array, len);
    
    QuickSort(array, len);
    
    println(array, len);
    
    return 0;
}

6.归并排序

实现思想

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路 归并 。

代码实现

#include <stdio.h>
#include <malloc.h>

void println(int array[], int len)
{
    int i = 0;
    
    for(i=0; i<len; i++)
    {
        printf("%d ", array[i]);
    }
    
    printf("\n");
}

void swap(int array[], int i, int j)
{
    int temp = array[i];
    
    array[i] = array[j];
    
    array[j] = temp;
}

void Merge(int src[], int des[], int low, int mid, int high)
{
    int i = low;
    int j = mid + 1;
    int k = low;
    
    while( (i <= mid) && (j <= high) )
    {
        if( src[i] < src[j] )
        {
            des[k++] = src[i++];
        }
        else
        {
            des[k++] = src[j++];
        }
    }
    
    while( i <= mid )
    {
        des[k++] = src[i++];
    }
    
    while( j <= high )
    {
        des[k++] = src[j++];
    }
}

void MSort(int src[], int des[], int low, int high, int max)
{
    if( low == high )
    {
        des[low] = src[low];
    }
    else
    {
        int mid = (low + high) / 2;
        int* space = (int*)malloc(sizeof(int) * max);
        
        if( space != NULL )
        {
            MSort(src, space, low, mid, max);
            MSort(src, space, mid+1, high, max);
            Merge(space, des, low, mid, high);
        }
        
        free(space);
    }
}

void MergeSort(int array[], int len) // O(n*logn)
{
    MSort(array, array, 0, len-1, len);
}

int main()
{
    int array[] = {21, 25, 49, 25, 16, 8};
    int len = sizeof(array) / sizeof(*array); 
    
    println(array, len);
    
    MergeSort(array, len);
    
    println(array, len);
    
    return 0;
}