排序算法

最新推荐文章于 2024-10-16 23:20:52 发布

原创最新推荐文章于 2024-10-16 23:20:52 发布 · 513 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#插入排序

综合专栏收录该内容

3 篇文章

订阅专栏

本文深入探讨了三种经典排序算法：直接插入排序、希尔排序和折半插入排序。详细解释了每种算法的工作原理、实现步骤及优化策略。同时，介绍了堆排序和归并排序的基本概念、实现方式及其应用。对于每种算法，都通过代码示例进行了演示，并分析了其时间复杂度和空间复杂度。

一、插入排序

1. 直接插入排序

void InsertSort(int a[], int length)
{
	if (NULL == a || 1 >= length)
	{
		return;
	}
	int temp;
	int i, j;
	for (i = 1; i < length; i++)
	{
		if (a[i] < a[i - 1])
		{
			temp = a[i];
			for (j = i - 1; j >= 0 && a[j] > temp; j--)   //a[j] > temp(不要误认为a[i],因为a[i]被修改过)
			{
				a[j + 1] = a[j];
			}
			a[j + 1] = temp;     //同上
		}
	}
}

2. 希尔排序

a为指向待排序序列的指针，length为待排序序列的长度，delta为指向增量序列的指针，m为增量序列的长度

void ShellInsertSort(int *a, int length, int del)
{
	int temp;
	int j;
	int k;
	for (j = del; j < length; j += del)
	{
		if (a[j] < a[j - del])
		{
			temp = a[j];
			for (k = j - del; k >=0 && a[k] > temp; k -= del)
			{
				a[k + del] = a[k];
			}
			a[k + del] = temp;
		}
	}
}

void ShellSort(int *a, int length, int *delta, int m)
{
	int i;
	for (i = 0; i < m; i++)
	{
		ShellInsertSort(a, length, delta[i]);
	}
}

3. 折半插入排序

减少的知识比较的次数，记录移动的次数并没有减少，所以时间复杂度仍是0(n^2)

int BSearch(int *a, int begin, int end, int value)
{
	while (end - begin > 1)
	{
		int mid = (begin + end) / 2;
		if (value >= a[mid])
		{
			begin = mid;
		}
		else
		{
			end = mid;
		}
	}
	return end - 1;
}

void BInsertSort(int *a, int length)
{
	if (NULL == a || length < 2)
	{
		return;
	}
	int i;
	int temp;
	int location;
	for (i = 1; i < length; i++)
	{
		if (a[i] < a[i - 1])
		{
			temp = a[i];
			location = BSearch(a, 0, i - 1, temp);
			for (int j = i; j > location; j--)
			{
				a[j] = a[j - 1];
			}
			a[location + 1] = temp;
		}
	}
	if (a[0] > a[1])
	{
		temp = a[1];
		a[1] = a[0];
		a[0] = temp;
	}
}

二、堆排序

大根堆

void HeapAdjust(int SortData[], int StartIndex, int length)
{
	while (2 * StartIndex + 1 < length)
	{
		int MinChildrenIndex = 2 * StartIndex + 1;
		if (2 * StartIndex + 2 < length)
		{
			 if(SortData[2*StartIndex+1]<SortData[2*StartIndex+2])   
            {   
                MinChildrenIndex = 2*StartIndex+2;   
            }   
		}
		if(SortData[StartIndex] < SortData[MinChildrenIndex])   
        {   
            //交换i与MinChildrenIndex的数据   
            int tmpData =SortData[StartIndex];   
            SortData[StartIndex] =SortData[MinChildrenIndex];   
            SortData[MinChildrenIndex] =tmpData;   
            //堆被破坏，需要重新调整   
            StartIndex = MinChildrenIndex ;   
        }   
		else  
        {   
            //比较左右孩子均大则堆未破坏，不再需要调整   
            break;   
        }   
	}
	return;
}

void HeapSortData(int SortData[], int length)
{
	if (NULL == SortData || length < 2)
	{
		return;
	}
	int i = 0;
	for (i = length / 2 - 1; i >= 0; i--)
	{
		HeapAdjust(SortData, i, length);
	}
	for (i=length-1; i>0; i--)   
    {   
        //与最后一个记录交换   
        int tmpData =SortData[0];   
        SortData[0] =SortData[i];   
        SortData[i] =tmpData;   
        //将H.r[0..i]重新调整为大根堆   
        HeapAdjust(SortData, 0, i);   
    }   
	return;
}

三、归并排序

递归算法

void mergearray(int a[], int first, int mid, int last, int temp[])  
{  
    int i = first, j = mid + 1;  
    int m = mid,   n = last;  
    int k = 0;  
      
    while (i <= m && j <= n)  
    {  
        if (a[i] <= a[j])  
            temp[k++] = a[i++];  
        else  
            temp[k++] = a[j++];  
    }  
      
    while (i <= m)  
        temp[k++] = a[i++];  
      
    while (j <= n)  
        temp[k++] = a[j++];  
      
    for (i = 0; i < k; i++)  
        a[first + i] = temp[i];  
}  
void mergesort(int a[], int first, int last, int temp[])  
{  
    if (first < last)  
    {  
        int mid = (first + last) / 2;  
        mergesort(a, first, mid, temp);    //左边有序  
        mergesort(a, mid + 1, last, temp); //右边有序  
        mergearray(a, first, mid, last, temp); //再将二个有序数列合并  
    }  
}  
  
bool MergeSort(int a[], int n)  
{  
    int *p = new int[n];  
    if (p == NULL)  
        return false;  
    mergesort(a, 0, n - 1, p);
    delete[] p;  
    return true;  
}