排序算法总结

原创 2016年06月01日 23:21:07

提到算法,自然就避不开"排序"。不管是在面试中还是在实际程序开发中,排序算法都被经常用到。排序算法是最基本最常用的算法,不同的排序算法在不同的场景或应用中会有不同的表现。以下是总结下各种排序算法:

下面这个表格总结了各种排序算法的复杂度与稳定性的比较:




1. 冒泡排序

冒泡排序可谓是最经典的排序算法了,一种简单直观的算法。它是基于比较的排序算法,时间复杂度为O(n^2),其优点是实现简单,n较小时性能较好。这个算法的名字由来就是因为越小的元素会经由交换"浮"到数列的顶端。

算法原理:

重复地走访过要排序的数列,每次对相邻的数据进行两两比较,判断大小进行位置交换。这样一趟下来,最小的数就被排在了第一位,第二趟也是如此,如此类推,直到所有的数据排序完成。


算法实现:
// 冒泡排序
void bubble_sort(int arr[], int len)
{
    for (int i = 0; i < len - 1; i++)
    {
		for (int j = len - 1; j >= i; j--)
        {
            if (arr[j] < arr[j - 1])
            {
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }
    }
}




2. 选择排序

算法原理:

先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。

算法实现:
// 选择排序
void select_sort(int arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        int index = i;
        for (int j = i + 1; j < len; j++)
        {
            if (arr[j] < arr[index])
                index = j;
        }
		
        if (index != i)
        {
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp; 
        }
    }
}





3. 插入排序

算法原理:

将数据分为两部分,有序部分与无序部分,一开始有序部分包含第1个元素,依次将无序的元素插入到有序部分,直到所有元素有序。插入排序又分为直接插入排序、二分插入排序、链表插入等,这里只讨论直接插入排序。它是稳定的排序算法,时间复杂度为O(n^2)

算法实现:
// 插入排序
void insert_sort(int arr[], int len)
{
    for (int i = 1; i < len; i ++)
    {
        int j = i - 1;
        int k = arr[i];
        while (j > -1 && k < arr[j] )
        {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = k;
    }
}




4. 快速排序

快速排序是目前在实践中非常高效的一种排序算法,它不是稳定的排序算法,平均时间复杂度为O(nlogn),最差情况下复杂度为O(n^2)。

算法原理:

分治思想,通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

算法实现:
// 快速排序
void quick_sort(int arr[], int left, int right)
{
	if (left < right)
	{
		int i = left, j = right, target = arr[left];
		while (i < j)
		{
			while (i < j && arr[j] > target)
				j--;
			if (i < j)
				arr[i++] = arr[j];

			while (i < j && arr[i] < target)
				i++;
			if (i < j)
				arr[j] = arr[i];
		}
		arr[i] = target;
		quick_sort(arr, left, i - 1);
		quick_sort(arr, i + 1, right);
	}
}




5. 归并排序

算法原理:

归并排序具体工作原理如下(假设序列共有n个元素):
① 将序列每相邻两个数字进行归并操作(merge),形成floor(n/2)个序列,排序后每个序列包含两个元素;
② 将上述序列再次归并,形成floor(n/4)个序列,每个序列包含四个元素;
③ 重复步骤2,直到所有元素排序完毕。
归并排序是稳定的排序算法,其时间复杂度为O(nlogn),如果是使用链表的实现的话,空间复杂度可以达到O(1),但如果是使用数组来存储数据的话,在归并的过程中,需要临时空间来存储归并好的数据,所以空间复杂度为O(n)

算法实现:
// 归并排序
void merge(int arr[], int temp_arr[], int start_index, int mid_index, int end_index)
 {
    int i = start_index, j = mid_index + 1;
    int k = 0;
    while (i < mid_index + 1 && j < end_index + 1)
    {
        if (arr[i] > arr[j])
            temp_arr[k++] = arr[j++];
        else
            temp_arr[k++] = arr[i++];
    }
	
    while (i < mid_index + 1)
    {
        temp_arr[k++] = arr[i++];
    }
	
    while (j < end_index + 1)
        temp_arr[k++] = arr[j++];

    for (i = 0, j = start_index; j < end_index + 1; i++, j++)
        arr[j] = temp_arr[i];
}

void merge_sort(int arr[], int temp_arr[], int start_index, int end_index)
{
    if (start_index < end_index)
    {
        int mid_index = (start_index + end_index) / 2;
        merge_sort(arr, temp_arr, start_index, mid_index);
        merge_sort(arr, temp_arr, mid_index + 1, end_index);
        merge(arr, temp_arr, start_index, mid_index, end_index);
    }
}




6. 堆排序

二叉堆

二叉堆是完全二叉树或者近似完全二叉树,满足两个特性:

① 父结点的键值总是大于或等于(小于或等于)任何一个子节点的键值

② 每个结点的左子树和右子树都是一个二叉堆

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。

一般二叉树简称为堆。

堆的存储

一般都是数组来存储堆,i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 12 * i + 2。如第0个结点左右子结点下标分别为1和2。存储结构如图所示:



堆排序原理


堆排序的时间复杂度为O(nlogn)

算法原理(以最大堆为例):

①  先将初始数据R[1..n]建成一个最大堆,此堆为初始的无序区;

② 再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换,由此得到新的无序区R[1..n-1]和有序区R[n],且满足 

    R[1..n-1].keys≤R[n].key;

③ 由于交换后新的根R[1]可能违反堆性质,故应将当前无序区R[1..n-1]调整为堆。

④ 重复2、3步骤,直到无序区只有一个元素为止。


图例:(88,85,83,73,72,60,57,48,42,6


算法实现:

// 堆排序
/**
 * 将数组arr构建大根堆
 * @param arr 待调整的数组
 * @param i   待调整的数组元素的下标
 * @param len 数组的长度
 */
void heap_adjust(int arr[], int i, int len)
{
    int child;
    int temp;

    for (; 2 * i + 1 < len; i = child)
    {
        child = 2 * i + 1;  // 子结点的位置 = 2 * 父结点的位置 + 1
        
		// 得到子结点中键值较大的结点
        if (child < len - 1 && arr[child + 1] > arr[child])
            child++;
        
		// 如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点
        if (arr[i] < arr[child])
        {
            temp = arr[i];
            arr[i] = arr[child];
            arr[child] = temp;
        }
        else
            break;
    }
}

/**
 * 堆排序算法
 */
void heap_sort(int arr[], int len)
{
    int i;
    // 调整序列的前半部分元素,调整完之后第一个元素是序列的最大的元素
    for (int i = len / 2 - 1; i >= 0; i--)
    {
        heap_adjust(arr, i, len);
    }

    for (i = len - 1; i > 0; i--)
    {
        // 将第1个元素与当前最后一个元素交换,保证当前的最后一个位置的元素都是现在的这个序列中最大的
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        // 不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
        heap_adjust(arr, 0, i);
    }
}


PS: 欢迎关注微信公众号:开发者小黑屋,分享优质技术干货。 

这里写图片描述

版权声明:本文为博主原创文章,未经博主允许不得转载。

排序算法总结

  • 2015年07月04日 19:19
  • 390KB
  • 下载

排序算法总结

  • 2014年01月21日 13:52
  • 12KB
  • 下载

数据结构-八大排序算法总结

一.插入排序  1.直接插入算法    时间复杂度o(n^2)  空间复杂度o(1) #include #include #include #include /***************...

8个常见数据结构排序算法总结

  • 2013年11月15日 21:10
  • 23KB
  • 下载

各种排序算法总结

  • 2013年03月01日 13:21
  • 780B
  • 下载

各种排序算法的java实现及时间、空间复杂度、稳定程度总结

最近闲着没事,就随便看了看数据结构,看到各种排序算法时,突然心血来潮,就想,以前都是用C++实现的,能不能用java实现所有的排序算法呢?而且顺便练习一下递归的使用(因为我最不擅长使用的就是递归) ...

常用排序算法总结

  • 2013年06月01日 15:55
  • 4KB
  • 下载

第十三节:StringBuffer类_排序算法_自动装箱(个人总结)

StringBuffer类 StringBuffer在对字符串进行拼接时,不要再出现用"+"进行拼接了,当用+号进行两个变量代表的字符串拼接时,又会在常量池内产生新的对象以及新的垃圾,因此在使用...

C-C++排序算法总结

  • 2010年03月27日 13:06
  • 3KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:排序算法总结
举报原因:
原因补充:

(最多只允许输入30个字)