排序算法详解-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_42200183/article/details/81635853

插入排序：

插入排序分为直接插入排序和希尔排序

#直接插入排序

/**************************************************************
  > File Name: insert.c
  > Author: chengfeiyan
  > Mail: 1493789272@qq.com 
  > Created Time: 2018年08月12日 星期日 09时50分41秒
 **************************************************************/

/*直接插入排序*/
#include <stdio.h>

void Insertsort(int b[], int size)
{
    int i, j, tmp;

    for(i = 1; i < size; i++)
    {
        tmp = b[i];

        for(j = i - 1; j >= 0; j--)
        {
            if(tmp < b[j])
            {
                b[j + 1] = b[j];
            }
            else
            {
                break;
            }
        }
        b[j + 1] = tmp;
    }
}

int main()
{
    int i, length;
    int a[10] = {9, 8, 4, 7, 0, 4, 3, 5, 2, 7};

    length = sizeof(a) / sizeof(a[0]);

    Insertsort(a, length);
    
    for(i = 0; i < length; i++)
    {
        printf("%d ", a[i]);
    }

    printf("\n");
    return 0;
}

#希尔排序

/**************************************************************
  > File Name: insert.c
  > Author: chengfeiyan
  > Mail: 1493789272@qq.com 
  > Created Time: 2018年08月12日 星期日 09时50分41秒
 **************************************************************/

/*希尔排序*/
#include <stdio.h>

void ShellSort(int b[], int size)
{
    int i, j, tmp, h;

    for(h = size / 2; h > 0; h /= 2)
    {
        for(i = 1; i < size; i++)
        {
            tmp = b[i];

            for(j = i - 1; j >= 0; j--)
            {
                if(tmp < b[j])
                {
                    b[j + 1] = b[j];
                }
                else
                {
                    break;
                }
            }
            b[j + 1] = tmp;
        }
    }
}

int main()
{
    int i, length;
    int a[10] = {9, 8, 4, 7, 0, 4, 3, 5, 2, 7};

    length = sizeof(a) / sizeof(a[0]);

    ShellSort(a, length);
    
    for(i = 0; i < length; i++)
    {
        printf("%d ", a[i]);
    }

    printf("\n");
    return 0;
}

选择排序：

选择排序分为简单选择排序和堆排序

# 简单选择排序

/**************************************************************
  > File Name: Choose.c
  > Author: chengfeiyan
  > Mail: 1493789272@qq.com 
  > Created Time: 2018年08月12日 星期日 14时28分32秒
 **************************************************************/

/*简单选择排序*/
#include <stdio.h>

void ChooseSort(int *num, int n)
{
    int i, j, tmp = 0, min = 0;

    for(i = 0; i < n ; i++)
    {
        min = i;

        for(j = i + 1; j < n; j++)
        {
            if(num[j] < num[min])
            {
                min = j;
            }
        }

        if(num[i] != num[j])
        {
            tmp = num[i];
            num[i] = num[min];
            num[min] = tmp;
        }
    }

}
int main()
{
    int i, len;
    int a[] = {1, 2, 6, 34, 22, 5, 3};

    len = sizeof(a) / sizeof(a[0]);

    ChooseSort(a, len);

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

    return 0;
}

#堆排序

/**************************************************************
  > File Name: heap.c
  > Author: chengfeiyan
  > Mail: 1493789272@qq.com 
  > Created Time: 2018年08月12日 星期日 14时40分03秒
 **************************************************************/

/*堆排序*/
#include <stdio.h>                                          //堆排序

void AdjustMinHeap(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 Swap(int *a, int *b)   //交换
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}

void PrintArray(int *a, int length)
{
	int i;

	for (i = 0; i < length; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}

void HeapSort(int *array, int len)
{
	int i;

	for (i = len / 2 - 1; i >= 0; i--)  
	{
		AdjustMinHeap(array, i, len - 1);
	}
	for (i = len -1; i >= 0; i--)
	{
		Swap(&array[0], &array[i]);
		AdjustMinHeap(array, 0, i - 1);
	}
}

int main()
{
	int array[] = {0, 13, 1, 14, 27, 18};
	int length = sizeof(array) / sizeof(array[0]);

	HeapSort(array, length);
	PrintArray(array, length);

	return 0;
}

交换排序：

交换排序分为冒泡排序和快速排序

#冒泡排序

/**************************************************************
  > File Name: sort.c
  > Author: chengfeiyan
  > Mail: 1493789272@qq.com 
  > Created Time: 2018年08月12日 星期日 16时20分32秒
 **************************************************************/

 /*冒泡排序*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int greater(int x, int y)
{
    return (x > y) ? 1 : 0;
}
int less (int x, int y)
{
    return (x < y) ? 1 : 0;
}

void Getarray(int a[], int length)
{
    int i;

    printf("Please input:\n");

    for(i = 0; i < length; i++)
    {
        scanf("%d", &a[i]);
    }
}

void sort(int a[], int length, int (*p)(int, int))
{
    int i, j, tmp;

    for(i = 0; i < length - 1 ; i++)
    {
        for(j = 0; j < length - i - 1; j++)
        {
            if(p(a[j + 1], a[j]))
            {
                tmp = a[j + 1];
                a[j + 1] = a[j];
                a[j] = tmp;
            }
        
        }
    
    }

void print(int a[], int length)
{
    int i = 0;

    for(i = 0; i < length; i++)
    {
        printf("%d", a[i]);
    }
}

int main()
{
    int i, j, temp;
    int a[5] = {0};
    int length = sizeof(a) / sizeof(a[0]);
    int (*p)();

    return 0;
}

}

#快速排序

/**************************************************************
  > File Name: Quick.c
  > Author: chengfeiyan
  > Mail: 1493789272@qq.com 
  > Created Time: 2018年08月12日 星期日 11时49分17秒
 **************************************************************/

/*快速排序*/
#include <stdio.h>

int a[101], n;

void QuickSort(int left, int right)
{
    int i = left, j = right, tmp, tmp1;
    
    if(left >= right)
    {
        return;
    }

    while(i < j)
    {
        while(a[left] <= a[j] && i < j)		//j从右往左找比基准数小的
        {
            j--;
        }
        while(a[left] >= a[i] && i < j)        //i从左往右找比基准数大的 但不能找到j的右边
        {
            i++;
        }

        if(i < j)    //如果有这样的i，j存在 就交换位置 保证基数的左边都比基数小 右边都比基数大		
        {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }

    tmp1 = a[i];	//如果i与j重合 则将它与基数交换
    a[i] = a[left];
    a[left] = tmp1;
 
    QuickSort(left, i - 1);	//对基数的左右再分别进行递归排序
    QuickSort(i + 1, right);
}

int main()
{
    int i;
    
    printf("Please input how many numbers you wanna sort:\n");
    scanf("%d", &n);

    printf("Please input the numbers you wanna sort:\n");

    for(i = 1; i <= n; i++)	    //获取键盘上的数
    {
        scanf("%d", &a[i]);
    }

    QuickSort(1, n);
    
    printf("The numbers sorted by me are:\n");

    for(i = 1; i <= n; i++)
    {
        printf("%d ", a[i]);
    }

    printf("\n");

    return 0;
}

基数排序：

/**************************************************************
  > File Name: insert.c
  > Author: chengfeiyan
  > Mail: 1493789272@qq.com 
  > Created Time: 2018年08月12日 星期日 09时50分41秒
 **************************************************************/

/*基数排序*/
#include <stdio.h>
#include <stdlib.h>

/*******************
 * 获取数组a中最大值
 *
 * 参数说明：
 *     a -- 数组
 *     n -- 数组长度
 *******************/
 int Get_max(int *a, int n)
 {
	int i, max;
	max = a[0];

	for( i = 1; i < n; i++)
	{
		if(a[i] > max)
		{
			max = a[i];
		}
	}
	return max;
 }
 
/*************************************
 * 对数组按照"某个位数"进行排序(桶排序)
 *
 * 参数说明：
 *     a -- 数组
 *     n -- 数组长度
 *     exp -- 指数。对数组a按照该指数进行排序。
 *
 * 例如，对于数组a={278, 109, 63, 930, 589, 184, 505, 269, 8, 83}；
 *    (01) 当exp=1表示按照"个位"对数组a进行排序
 *    (02) 当exp=10表示按照"十位"对数组a进行排序
 *    (03) 当exp=100表示按照"百位"对数组a进行排序
 *    ...
 **************************************/ 
 int count_sort(int *a, int n, int exp)
 {
	 int output[n];           // 存储"被排序数据"的临时数组
	 int i;
	 int buckets[10] = {0}; //桶数组
	 
	 // 将数据最后一位对应的数存储在buckets[]对应的桶中,则该桶++
	 for(i = 0; i < n; i++)
	 {
		 buckets[(a[i] / exp) % 10 ] ++; 
	 }
	 
	 //更改buckets[i]。目的是让更改后的buckets[i]的值,是该数据在output[]中的位置。
	 for(i = 1; i < 10; i++)
	 {
		 buckets[i] += buckets[i - 1];
	 }
	 
	 // 将数据存储到临时数组output[]中
	 for( i = n - 1; i >= 0; i--)
	 {
		 output[buckets[ (a[i] / exp) % 10 ] -1 ] = a[i];
		 buckets[ (a[i] / exp) % 10]--;
	 }
	 
	 // 将排序好的数据赋值给a[]
	 for(i = 0; i < n; i++)
	 {
		 a[i] = output[i];
	 }
	 
	 return 1;
 }
 
/******************
 * 基数排序
 *
 * 参数说明：
 *     a -- 数组
 *     n -- 数组长度
 ******************/
int Radix_sort(int *a, int n)
{
	int exp; //指数，对个位排序为1，对十位排序为10...
	int max = Get_max(a, n);   // 数组a中的最大值
	
	
	// 从个位开始，对数组a按"指数"进行排序
	for(exp = 1; max / exp > 0; exp *= 10)
	{
		count_sort( a, n, exp);
	}
	
	return 1;
}

int main()
{
	int i;
	int a[] = {278, 109, 63, 930, 589, 184, 505, 269, 8, 83};//按照PPT上的数据
	int len = sizeof(a) / sizeof(a[0]); //求数组的长度
	
	printf("Before sort : ");
	for(i = 0; i < len; i ++)
	{
		printf("%d ", a[i]);
	}
	printf("\n\n");
	
	Radix_sort(a, len);
	
	printf("After sort : ");
	for(i = 0; i < len; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	
	return 0;
}

归并排序：

/**************************************************************
  > File Name: insert.c
  > Author: chengfeiyan
  > Mail: 1493789272@qq.com 
  > Created Time: 2018年08月12日 星期日 09时50分41秒
 **************************************************************/

/*归并排序*/
#include<stdio.h>
#include<stdlib.h>

void Merge(int a[],int start, int middle,int end )
{
	int num1 = middle + 1 - start;
	int num2 = end - middle;
	
	int *A = (int*)malloc(sizeof(int) *num1);
	int *B = (int*)malloc(sizeof(int) *num2);
	
	int i,j,k;
	
	for(i = 0,k = start; i < num1 ;i++,k++)
	{
		A[i] = a[k];
	}
	
	for(j = 0,k = middle + 1;j < num2 ;j++,k++)
	{
		B[j] = a[k];
	}
	
	for(i = 0, j = 0,k = start ;i < num1 && j < num2; k++)
	{
		if( A[i] < B[j] )
		{
			a[k] = A[i];
			i++;
		}
		else
		{
			a[k] = B[j];
			j++;
		}
	}
	
	if( i < num1 )
	{
		for( j = i;j < num1 ;j++,k++)
		{
			a[k] = A[j];
		}
	}
	
	if( j < num2 )
	{
		for( i = j;i < num2 ;i++,k++)
		{
			a[k] = B[i];
		}
	}
}

void MergeSort(int a[], int start, int end )
{
	int i;
	int middle;
	if(start < end )
	{
		middle = ( start + end ) / 2;
		
		MergeSort(a, start, middle );
	/*	i=0;
		while( i < 4 )
	{
		printf("%d ",a[i]);
		i++;
	}
	printf("\n");*/
		MergeSort(a, middle + 1, end );
	/*	i=4;
			while( i < 8 )
	{
		printf("%d ",a[i]);
		i++;
	}
	printf("\n");*/
		Merge(a,start,middle,end);
	}
}

int main()
{
	int i = 0;
	int a[]= {8,4,5,7,1,3,6,2};
	int length = sizeof( a ) / sizeof( a[0] );

	MergeSort(a, 0, length - 1);
	
	while( i < length )
	{
		printf("%d ",a[i]);
		i++;
	}
	
	printf("\n");
	
	return 0;
}