算法---排序拾遗

LXTTTTTTTT

已于 2023-03-30 10:00:22 修改

阅读量140

点赞数 5

分类专栏：数据结构与算法文章标签：算法排序算法数据结构

于 2022-05-23 20:25:07 首次发布

本文链接：https://blog.csdn.net/Aa102365478/article/details/124302921

版权

数据结构与算法专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1.选择排序

基础思想：暴力循环

实现方法：传入一个数组，从0到end遍历，找到这个数组之中最大的元素，将其与这个数组最后一个元素交换，实现将最大的元素放在数组最后。然后遍历从0到end - 1，并执行上述操作，直至end等于1。

void SelectionSort(int*,int);
void SelectionSort(int *a,int end)
{
    if(end == 0){return;}
    int temp, j;
    int max = end;
    for(j = end; j >= 0; --j)
    {
        max = a[max]>a[j]?max:j;
    }
    temp = a[max];
    a[max] = a[end];
    a[end] = temp;

    SelectionSort(a,end-1);
    return;
}

2.冒泡排序

基础思想：双循环

实现方法：传入一个数组，首先以数组第一个数为基准点，循环之后的每一个数，若所循环到的数大于基准点，则交换这两个数，循环结束之后基准点向后移1，再次进行上述循环，直至基准点到达数组尾部。

void BubbleSort(int*,int);
void BubbleSort(int *a,int end)
{
    
    if(end == 0)
    {
        return;
    }
    int j = end - 1;
    int temp;
    for(; j >= 0; --j)
    {
        if(a[j] > a[end])
        {
            temp = a[j];
            a[j] = a[end];
            a[end] = temp;
        }
    }
    BubbleSort(a,end-1);
}

3.插入排序

基础思想：整理扑克牌

实现方法：传入一个数组，从第一个数开始遍历，若后一个数大于前一个数，则将后一个数前移，直到这个数小于前一个数，实现插入，直到遍历结束。

void InsertSort(int*,int);
void InsertSort(int *a,int end)
{
	int i, j;
    int temp;
    for(i = 1; i < end; ++i)
	{
		if(a[i] > a[i - 1])
		{
			temp = a[i];
			for(j = i - 1; j >= 0 && temp > a[j]; --j)
			{
				a[j + 1] = a[j];
			}
			a[j + 1] = temp;
		}
	}
}

4.希尔排序

基础思想：插入排序

实现方法：将数列 $a_{n}$ 划分为间距为 gap 的子数列 $a_{gap\ *\ n}$ （我这里将 gap 初始化为数组长度的一半）。在每一个子数列中进行插入排序。然后得到有序子数列，之后将 gap 除以2，重复进行上述操作直至 gap 等于1（相当于插入排序）后停止。

void ShellSort(int*,int);
void ShellSort(int *a,int length)
{
    int gap;
	int i, j, temp;
    for(gap = length / 2; gap >= 1; gap /= 2)
    {
        //printf("%d ",gap);
        for(i = gap; i < length; i += gap)
	    {
	    	if(a[i] > a[i - gap])
	    	{
	    		temp = a[i];
	    		for(j = i - gap; j >= 0 && temp > a[j]; j -= gap)
	    		{
	    			a[j + gap] = a[j];
	    		}
	    		a[j + gap] = temp;
	    	}
	    }
    }

    return;
}

5.快速排序

基础思想：分治

实现方法：用index将待排序数组分为两个部分(我这里index = start)。从start开始遍历，每一个遍历到的数都与index作比较，将小于index的数放在index左边同时将右侧数向右移1，将大于index的数放在index右边同时将左侧数向左移1(注意这一过程之中index的位置可能会发生变化，但是index所指向的数据不变)。一次遍历结束之后，分别再次将（从start到index - 1）和（index + 1到end）进行上述操作，实现递归。

void QuickSort(int *, int, int);
void QuickSort(int *a, int start, int end)
{
    if(start >= end){return;}
    //printf("quick %d %d\n",start,end);
    int i, j, k;
    int index, temp;
    index = start;
    for(i = start; i < index; ++i)
    {
        if(a[i] > a[index])
        {
            --index;
            for(j = i + 1; j <= end; ++j)
            {
                a[j - 1] = a[j];
            }
            a[end] = a[i];
        }
    }
    for(i = index + 1; i < end; ++i)
    {
        if(a[i] < a[index])
        {
            ++index;
            temp = a[i];
            for(j = i - 1; j >= start; --j)
            {
                a[j + 1] = a[j];
            }
            a[start] = temp;
        }
    }
    QuickSort(a,index + 1,end);
    QuickSort(a,start,index - 1);
    return;
}

6.归并排序

基础思想：分治

实现方法：将一个大数组分成两个部分，再将小部分分成两个小部分，直至小部分只有两个元素。将小部分排序，之后将两个小部分合并，直至合并成原来的长度。

合并时按照以下思路按顺序合并。

合并思路：创建一个长度等于两个小部分长度之和的数组，创建三个指针，分别指向合数组和两个小数组的头部，合数组指针指向数组第一个位置时，填入小数组指针指向的较小数，之后合数组指针向后移，被填入的小数组的指针向后移，直至合数组填完。这样就合并成了一个有序的合数组。

代码段仅展示合并代码。

int out[1024];
void Merge(int *, int, int *, int);
void Merge(int *c, int lenc, int *b, int lenb)
{
    int i, j, k;
    for(i = 0, j = 0, k = 0; i < lenc + lenb; ++i)
    {
        if(j == lenc)
        {
            for( ;k < lenb; ++k, ++i)
            {
                out[i] = b[k];
            }
            return;
        }
        else if(k == lenb)
        {
            for( ;j < lenc; ++j, ++i)
            {
                out[i] = c[j];
            }
            return;
        }
        else
        {
            if(c[j] < b[k]){out[i] = c[j];++j;}
            else{out[i] = b[k];++k;}
            printf("%d %d ", j, c[j + 1]);
        }
    }
    return;
}