排序合集(十大经典排序算法)

已于 2023-09-24 15:45:54 修改
阅读量44 收藏
点赞数
分类专栏： 算法 文章标签： 排序算法 算法 数据结构
于 2023-09-24 15:43:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53478188/article/details/133021622
版权

        本篇介绍了十大经典排序算法,包括冒泡排序,选择排序,插入排序,希尔排序,快速排序,归并排序,堆排序,计数排序,桶排序,基数排序.

        代码的实现是c语言版的.例子中只是简单给出了对于整数数组的排序,若想对其他数据进行排序可以使用函数模板,对类中数据进行排序需要重载比较运算符.

1. 冒泡排序(Bubble Sort)

排序原理

        冒泡排序是一种简单直观的排序方式,通过遍历要排序的数列,对其中元素进行两两比较,如果顺序不对就相互交换,重复这一过程直到没有元素需要交换,此时数列已完成排序.

动图演示

代码实现

        非递归实现:
void bubblesort(int *arr,unsigned int n){
    if(n<2) return;
    int count,index;    //count--排序的次数  index--要排序的元素下标
    int temp,ifswap;

    for(count = n-1;count > 0;count--){    //进行n-1次比较
        ifswap = 0;
        for(index = 0;index < count;index++){    //比较0~count之间的元素,count之后是排序好的
            if(arr[index] > arr[index+1]){
                temp = arr[index+1];
                arr[index+1] = arr[index];
                arr[index] = temp;
                ifswap = 1;
            }
        }
        if(0 == ifswap) return;
    }
}
        递归实现:
void bubblesort(int* arr,unsigned int n){
    if(n<2) return;
    int index;
    int temp,ifswap = 0;
    for(index = 0;index < n-1;index++){
        if(arr[index] > arr[index+1]){
            temp = arr[index+1];
            arr[index+1] = arr[index];
            arr[index] = temp;
            ifswap = 1;
        }
    }
    if(0 == ifswap) return;
    bubblesort(arr,--n);
}

        平均的时间复杂度:O(n^{2})

        平均的空间复杂度:O(1)

2. 选择排序(Selection Sort)

排序原理

        选择排序是一种比较简单直观的排序,在未排序的数列中找到最小(大)元素,放到数列的起始位置,再从剩余未排序数列中找到最小(大)元素,放到已排序数列的末尾,一直重复此步骤直到所有元素都排序完毕.

动图演示

代码实现

        非递归实现
void selectionsort(int* arr, unsigned int n) {
	if (n < 2)	return;
	int left, right;	//每次排序的最左和最右的下标
	int index;			//每次排序的元素位置
	int minpos, maxpos;		//每次循环选出的最小值,最大值下标
	left = 0, right = n - 1;
	while (left < right) {
		minpos = maxpos = left;
		for (index = left; index <= right; index++) {		//在left到right之间选择元素
			if (arr[index] < arr[minpos])	minpos = index;		//记录更小的元素
			if (arr[index] > arr[maxpos])	maxpos = index;		//记录更大的元素
		}

		//如果本次循环的最小元素不是在最左边,就交换最小元素和最左元素的位置
		if (minpos != left)	swap(arr[left], arr[minpos]);
		//如果最大值元素的位置是在最左边,上边已经把最小元素和最左边元素交换了位置,所以要把最大值下标修改成最小值下标
		if (maxpos == left)	maxpos = minpos;
		//如果本次循环的最大元素不在最右边,就交换最右边的元素和最大值
		if (maxpos != right)	swap(arr[right], arr[maxpos]);

		left++; right--;
	}
}
        递归实现
void selectionsort(int* arr, unsigned int n) {
	if (n < 2)	return;
	int left, right;	//每次排序的最左和最右的下标
	int index;			//每次排序的元素位置
	int minpos, maxpos;		//每次循环选出的最小值,最大值下标
	left = 0, right = n - 1;

	minpos = maxpos = left;
	for (index = left; index <= right; index++) {		//在left到right之间选择元素
		if (arr[index] < arr[minpos])	minpos = index;		//记录更小的元素
		if (arr[index] > arr[maxpos])	maxpos = index;		//记录更大的元素
	}

	//如果本次循环的最小元素不是在最左边,就交换最小元素和最左元素的位置
	if (minpos != left)	swap(arr[left], arr[minpos]);
	//如果最大值元素的位置是在最左边,上边已经把最小元素和最左边元素交换了位置,所以要把最大值下标修改成最小值下标
	if (maxpos == left)	maxpos = minpos;
	//如果本次循环的最大元素不在最右边,就交换最右边的元素和最大值
	if (maxpos != right)	swap(arr[right], arr[maxpos]);
	n -= 2;
	selectionsort1(++arr, n);


}

        平均时间复杂度:O(n^{2})

        平均空间复杂度:O(1)

3. 插入排序(Insertion Sort)

排序原理

        插入排序是一种简单直观的排序方式,原理也很容易理解,通过构建有序序列,对于未排序的数据，在已排序序列中从后向前扫描，找到相应位置并插入。

动图演示

代码实现

void insertsort(int* arr, unsigned int n) {
		if (n < 2) return;
		int temp, index, num;
		for (index = 1; index < n; index++) {
			temp = arr[index];
			for (num = index - 1; num >= 0 && arr[num] > temp; num--) {
				for (num = index - 1; num >= 0; num--) {
					if (arr[num] <= temp)	break;
					arr[num + 1] = arr[num];	//逐个右移
				}
				arr[num + 1] = temp;
			}
		}
	}

       平均时间复杂度:O(n^{2})

        平均空间复杂度:O(1)

对于插入排序,寻找插入位置和移动元素是很浪费时间的操作,需要用一些优化方法:

1. 对已排好的序列使用二分查找法,可以提高寻找的效率.

2. 每次移动多个元素:假设每次拿出n个元素当成一个子序列,先将该n个元素排序,再从后往前寻找插入位置,此时不是一个一个找,而是n个间隔跳跃式寻找,当该子序列中的元素寻找到了位置插入之后,剩余元素按照n-1个间隔跳跃式寻找,直到子序列中每个元素都以插入到正确位置.

3. 数据链表化:当要排序的不是简单的数而是结构体,此时移动元素的开销就会变得很大.而链表的特性是对于插入操作的平均时间复杂度为O(1),这时使用链表对于数据的管理就会节省内存资源.

4. 使用希尔排序:在插入排序的基础上进行优化,性能更高的一种排序方式.

4. 希尔排序(Shell Sort)

排序原理

        希尔排序,也称递减增量排序,算法基于插入排序的以下两点性质而提出改进方法的：

  • 插入排序在对几乎已经排好序的数据操作时,效率高,即可以达到线性排序的效率；
  • 但插入排序一般来说是低效的,因为插入排序每次只能将数据移动一位；

        希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列,然后再对每个组进行插入排序,先让数列整体大致有序,然后多次调整分组方式,使数列更加有序,最后再使用一次插入排序,整个数列将全部有序.

选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

按增量序列个数 k，对序列进行 k 趟排序；

每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

动图演示

代码实现

	void groupsort(int* arr, unsigned int n, int pos, int step) {	//pos--分组起始位置  step--增量
		int temp, index, num;	
		for (index = pos + step; index < n; index += step) {
			temp = arr[index];
			for (num = index - step; num >= 0 && arr[num] > temp; num -= step) {	//从已排序的最右边开始,把大于当前排序的元素后移
				for (num = index - step; num >= 0; num -= step) {
					if (arr[num] <= temp)	break;
					arr[num + step] = arr[num];		//逐个后移
				}
				arr[num + step] = temp;	//插入当前排序元素
			}
		}
	}
	void shellsort(int* arr, unsigned int n) {
		int step;
		for (step = n / 2; step > 0; step /= 2) {
			for (int i = 0; i < step; i++) {	//一共step个组
				groupsort(arr, n, i, step);
			}
		}
	}

希尔排序在插入排序的基础上减少了查找次数和移动元素的次数,提高了性能.对于排序中增量的选取,这步骤是影响效率的关键.

        通常增量序列选择为:D_{M}=\left \lfloor N/2 \right \rfloor , D_{K}=\left \lfloor D_{K+1}/2 \right \rfloor , 最小增量为1.

        如果增量元素不互斥,那么有些增量就会不起作用,于是就有大佬提出了以下几个序列:Hibbard增量序列、Knuth增量序列、Sedgewick增量序列等等.

5. 快速排序(Quick Sort)

排序原理

        快速排序是由东尼·霍尔所发展的一种排序算法。采用分治思想将冒泡排序进行改进,大幅提高排序效率.在平均状况下的时间复杂度为O(nlogn),最坏情况下需要O(n^{2})(比如说对顺序数列进行快速排序).对绝大多数顺序性较弱的随机数列而言,快速排序总是优于归并排序.

基本思想:

        1. 先从数列中取出一个元素作为基准数.

        2. 扫描数列,将比基准数小的元素全部放到它的左边,大于或等于基准数的元素全部放到它的右边,得到左右两个区间.

        3. 对左右区间重复第二步,直到各区间少于两个元素.

动图演示

代码实现

void quicksort(int* arr, unsigned int n) {
		if (n < 2) return;
		int left, right;
		int mvnum;
		int temp = arr[0];	//选取最左边的数为基准数
		left = 0, right = n - 1, mvnum = 2;		//当前应该移动的下标:1--左下标	2--右下标
		while (left < right) {
			if (2 == mvnum) {
				if (arr[right] >= temp) {	//右下标元素大于基准数,继续移动右下标
					right--; continue;
				}
				arr[left] = arr[right];		//小于基准数填到左下标中
				left++; mvnum = 1;	//下次移动左下标
				continue;
			}
			if (1 == mvnum) {
				if (arr[left] <= temp) {
					left++; continue;
				}
				arr[right] = arr[left];
				right--; mvnum = 2;
				continue;
			}
		}
		arr[left] = temp;		//左右下标重合,把基准数填入
		quicksort(arr, left);		//递归左边序列
		quicksort(arr + left + 1, n - left - 1);		//递归右边序列
	}

快速排序的优化方法

1. 由于快速排序采用分治的思想,基准数的选取会影响到递归的深度,从而影响排序效率.

        我们可以从数列中选出多个数构成子序列,在这个子序列中选出一个位于中间的数当作基准数,这样进行排序的时候不至于基准数的左右两边的数量差距过大,可以提升排序的效率.

2. 结合插入排序,对于区间小于10个元素的,采用插入排序会使效率更高.

6. 归并排序(Merge Sort)

排序原理

        归并排序就是将已经有序的子序列合并,得到一个新的有序序列.作为分治思想的经典应用,归并排序的实现可采用递归和迭代两种方式.

和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是 O(nlogn) 的时间复杂度.代价是需要额外的内存空间.

算法步骤:

  1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

  2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

  3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

  4. 重复步骤 3 直到某一指针达到序列尾；

  5. 将另一序列剩下的所有元素直接复制到合并序列尾。

动图演示

代码实现

        递归实现
void _mergesort(int* arr, int* arrtmp, int start, int end) {	//arr--待排序数组首地址  arrtmp--用于排序的临时数组首地址
		if (start >= end) return;
		int mid = start + (end - start) / 2;
		int istart1 = start, iend1 = mid;
		int istart2 = mid + 1, iend2 = end;
		_mergesort(arr, arrtmp, istart1, iend1);
		_mergesort(arr, arrtmp, istart2, iend2);

		int num = start;		//已排序数组计数器
		while (istart1 <= iend1 && istart2 <= iend2) {		//把区间两边数列合并到已排序的数组中
			arrtmp[num++] = arr[istart1] < arr[istart2] ? arr[istart1++] : arr[istart2++];
		}
		while (istart1 <= iend1) arrtmp[num++] = arr[istart1++];	//把左边数列其他元素追加到已排序数组
		while (istart2 <= iend2) arrtmp[num++] = arr[istart2++];	//把右边数列其他元素追加到已排序数组
		memcpy(arr + start, arrtmp + start, (end - start + 1) * sizeof(int));
	}
	void mergesort(int* arr, unsigned int len) {	//排序主函数
		int* arrtmp = (int*)malloc(len); //分配一个与待排序数组相同大小的数组
		if (len < 2) return free(arrtmp);
		_mergesort(arr, arrtmp, 0, len - 1);		//调用递归函数进行排序
	}
        非递归实现
int min(int x, int y) {
    return x < y ? x : y;
}
void merge_sort(int arr[], int len) {
    int *a = arr;
    int *b = (int *) malloc(len * sizeof(int));
    int seg, start;
    for (seg = 1; seg < len; seg += seg) {
        for (start = 0; start < len; start += seg * 2) {
            int low = start, mid = min(start + seg, len), high = min(start + seg * 2, len);
            int k = low;
            int start1 = low, end1 = mid;
            int start2 = mid, end2 = high;
            while (start1 < end1 && start2 < end2)
                b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
            while (start1 < end1)
                b[k++] = a[start1++];
            while (start2 < end2)
                b[k++] = a[start2++];
        }
        int *temp = a;
        a = b;
        b = temp;
    }
    if (a != arr) {
        int i;
        for (i = 0; i < len; i++)
            b[i] = a[i];
        b = a;
    }
    free(b);
}

7. 堆排序(Heap Sort)

排序原理

        堆排序是利用堆这种数据结构而设计的一种排序算法,堆具备以下特点:

                1. 完全二叉树.

                2. 二叉树每个节点的值都大于或等于其左右子节点的值,称为最大堆;每个节点的值小于或等于其左右子节点的值,称为最小堆.

                3. 最大堆用于升序,最小堆用于降序.平均时间复杂度为O(nlogn).

        堆也可转换成数组来表示:       

                N[i] 的左节点 : N[2i+1] ;  N[i] 的右节点 : N[2i+2] ;  N[i]的父节点 : N[(i-1)/2].

算法步骤:

  1. 创建一个堆 H[0……n-1]；

  2. 把堆首（最大值）和堆尾互换；

  3. 把堆的尺寸缩小 1,并调用 shift_down(0),目的是把新的数组顶端数据调整到相应位置；

  4. 重复步骤 2,直到堆的尺寸为 1.

动图演示

代码实现

	void swap(int* a, int* b) { int t = *b; *b = *a; *a = t; }	
    void heapsort(int* arr, int len) {
		int index;
		for (index = (len - 1) / 2; index >= 0; index--) {	//从最后一个父节点开始调整
			heapify(arr, index, len - 1);
		}
		for (index = len - 1; index > 0; index--) {		//将第一个元素和已排好的元素前一位做交换,再重新调整
			swap(&arr[0], &arr[index]);
			heapify(arr, 0, index - 1);
		}
	}
        循环实现heapify
    //采用循环实现heapify(元素下沉)
	void heapify(int* arr, int start, int end) {	//start--待heapify节点的下标  end--待排序数组最后一个元素的下标
		int dad = start;
		int son = dad * 2 + 1;	//确认父节点和左子节点下标

		while (son <= dad) {
			if ((son + 1 <= end) && (arr[son] < arr[son + 1]))son++;	//比较两个子节点大小,选择最大的
			if (arr[dad] > arr[son]) return;	//如果调整完毕,跳出函数
			swap(&arr[dad], &arr[son]);		//否则交换父子内容再进行比较
			dad = son;
			son = dad * 2 + 1;
		}
	}
         递归实现heapify
	//采用递归实现heapify
	void heapify(int* arr, int start, int end) {
		int dad = start;
		int son = dad * 2 + 1;	//确认父节点和左子节点下标

		if (son > end) return;
		if ((son + 1 <= end) && (arr[son] < arr[son + 1]))son++;	//比较两个子节点大小,选择最大的
		if (arr[dad] > arr[son]) return;	//如果调整完毕,跳出函数
		swap(&arr[dad], &arr[son]);		//否则交换父子内容再进行比较
		heapify(arr, son, end);
	}

8. 计数排序(Counting Sort)

排序原理

        计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中.作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数.

要想将计数排序的时间复杂度降低到O(n+k),需要满足两个条件:

        1. 需要排序的元素是整数.

        2. 排序元素的取值要在一定范围内,并且比较集中.

算法的步骤如下：

        1. 找出待排序的数组中最大和最小的元素

        2. 统计数组中每个值为i的元素出现的次数，存入数组C的第i项

        3. 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）

        4. 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

动图演示

代码实现

基础的计数排序在某些情况下会存在空间浪费的问题,所以要优化就需要在创建计数数组地方做改动.将数组长度定为max-min+1,即不仅要找出最大值,也要找到最小值,根据两者的差确定计数数组的长度.

        优化后:

void arrmax(int* arr, unsigned int len, int* min, int* max) {
		int i;
		*min = *max = arr[0];
		for (i = 0; i < len; i++) {
			if (*max < arr[i]) *max = arr[i];
			if (*min < arr[i]) *min = arr[i];
		}
	}
	void countsort(int* arr, int len) {
		if (len < 2) return;
		int min, max;
		arrmax(arr, len, &min, &max);
		int* arrtmp = (int*)malloc((max - min + 1)*sizeof(int));		//临时数组
		memset(arrtmp, 0, sizeof(arrtmp));

		int i, j, k;
		for (i = 0; i < len; i++) {		//临时数组计数
			arrtmp[arr[i] - min]++;
		}
		i = 0;
		for (j = 0; j < max - min + 1; j++) {		//把临时数组计数的内容填充到arr中
			for (k = 0; k < arrtmp[j]; k++) {
				arr[i++] = j + min;
			}
		}
		free(arrtmp);
	}

9. 桶排序(Bucket Sort)

排序原理

        假设输入数据服从均匀分布,将数据分到有限的桶中,然后对每个桶分别排序,最后把全部桶的数据都合并.

        时间复杂度取决于对每个桶之间数据进行排序的时间复杂度,因为其他部分的时间复杂度都为O(n).显然,桶划分的越小,每个桶所需要的排序时间也越小,但空间消耗就会增大.

        桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：

  1. 在额外空间充足的情况下，尽量增大桶的数量
  2. 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。

什么时候最快:        当输入的数据可以均匀分配到每个桶中.

什么时候最慢:        当输入的数据都被分配到了一个桶中.

桶思想:

        要想把桶排序的效率发挥出来 , 就应该让它处理均匀分布的数据 .  如果在程序设计过程中处理的数据是分布均匀的那最好 , 如果不是均匀分布的就可以在设计时候让其均匀分布 , 或者转换成均匀的分布 .  比如在游戏账号的查找中 , 可能出现各种非整型的数据 , 可以给其分配一个整数的id , 有了这样一个映射, 查找这种均匀分布的id效率就会提升.  还有在数据库设计时候 ,  为了提升效率,把大的表分到不同的库 , 分成不同的表 ,  也是桶思想的一种体现 .  这种思想对于我们处理海量数据是非常重要的.

示意图

元素分布在桶中:

元素在每个桶中进行排序:

代码实现

        对桶内元素进行排序使用的是冒泡排序

void bubblesort(int* arr, unsigned int n) {
		if (n < 2) return;
		int count, index;    //count--排序的次数  index--要排序的元素下标
		int temp, ifswap;

		for (count = n - 1; count > 0; count--) {    //进行n-1次比较
			ifswap = 0;
			for (index = 0; index < count; index++) {    //比较0~count之间的元素,count之后是排序好的
				if (arr[index] > arr[index + 1]) {
					temp = arr[index + 1];
					arr[index + 1] = arr[index];
					arr[index] = temp;
					ifswap = 1;
				}
			}
			if (0 == ifswap) return;
		}
	}
	void bucketsort(int*arr,int len) {
		int bucket[5][5];	//分配五个桶
		int bucketsize[5];	//每个桶中的元素个数计数器

		memset(bucket, 0, sizeof(bucket));
		memset(bucketsize, 0, sizeof(bucketsize));

		//把数组arr数据放到桶中
		for (int i = 0; i < len; i++) {
			bucket[arr[i] / 10][bucketsize[arr[i] / 10]++] = arr[i];	//可以得到桶的下标
		}
		//对每个桶进行排序
		for (int i = 0; i < 5; i++) {
			bubblesort(bucket[i], bucketsize[i]);
		}
		int i, j, k = 0;
		for (i = 0; i < 5; i++) {	//把每个桶的数据填充到数组arr中
			for (j = 0; j < bucketsize[i]; j++) {
				arr[k++] = bucket[i][j];
			}
		}
	}

10.基数排序(Radix Sort)

排序原理

        基数排序是桶排序的升级版,也是一种非比较型排序算法.在排序时将整数按位数切割成不同的数字,然后按每个位数分别比较.

计数排序  ---  桶排序 ---  基数排序

这三种排序算法都利用了桶的概念,区别是对桶的使用方法：

  • 基数排序：根据键值的每位数字来分配桶；
  • 计数排序：每个桶只存储单一键值；
  • 桶排序：每个桶存储一定范围的数值；

动图演示

代码实现

int arrmax(int* arr, unsigned int len) {
		int i;
		int max = arr[0];
		for (i = 0; i < len; i++) {
			if (max < arr[i]) max = arr[i];
		}
		return max;
	}
	void _radixsort(int* arr, int len, int exp) {
		int num = 0;
		int* result = (int*)malloc(len * sizeof(int));
		int buckets[10] = { 0 };
		if (result) {
			for (num = 0; num < len; num++)			// 遍历arr,将数据出现的次数存储在buckets中.
				buckets[(arr[num] / exp) % 10]++;

			for (num = 1; num < 10; num++)			//调整buckets各元素的值,调整后的值就是arr中元素在result中的位置.
				buckets[num] = buckets[num] + buckets[num - 1];

			for (num = len - 1; num >= 0; num--) {
				int iexp = (arr[num] / exp) % 10;
				result[buckets[iexp] - 1] = arr[num];
				buckets[iexp]--;
			}
			memcpy(arr, result, sizeof(int) * len);
			free(result);
		}
	}
	void radixsort(int* arr, int len) {
		int max = arrmax(arr, len);		//获取数组arr中的最大值
		int exp;				//排序指数,1 -- 个位排序  10 -- 十位排序...

		for (exp = 1; max / exp > 0; exp *= 10) {		//按指数位排序
			_radixsort(arr, len, exp);
		}
	}
}

一口三明治3Mz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
十大经典排序算法.docx
01-31
十大经典排序算法.docx
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
十大经典排序算法-归并排序算法详解
qq_35344198的博客
06-19 11万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
算法学习总结（2）——温故十大经典排序算法
科技D人生
08-29 5万+
一、什么是排序算法 1.1、排序定义 对一序列对象根据某个关键字进行排序。 1.2、排序术语 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；内排序：所有排序操作都在内存中完成；外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；时间复杂度：一个算法执行所耗费的时间。空间...
常用十大排序算法
热门推荐
qq_51664685的博客
04-26 12万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
十大经典排序算法
风起时~微凉的博客
10-21 3万+
稳定排序： 冒泡排序、插入排序、归并排序 非稳定排序： 选择排序、希尔排序、堆排序、快速排序 1、冒泡排序 冒泡排序就是把小的元素往前调或者把大的元素往后调，比较是相邻的两个元素比较，交换也发生在这两个元素之间。（类似于气泡上浮过程） 动图如下： 步骤： 1、比较相邻的元素，如果第一个比第二个大，则交换 2、对每对相邻元素重复步骤1操作，筛选出最大元素 3、针对所有元素重复步骤1、2（除最后一个元素，已经是最大） 示例代码： void bubbleSort(std::vec..
十大经典排序算法——java语言
weixin_56781779的博客
11-11 5571
一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、归并排序 六、快速排序 七、堆排序 八、计数排序 九、桶排序 十、基数排序
十大经典排序算法（Java实现）
qq_43794633的博客
12-04 1万+
为了加深对这十种算法的理解，固写此文。首先可用如下表来简单概括这十种算法： 目录1、冒泡排序2、选择排序3、插入排序4、希尔排序5、归并排序6、快速排序7、堆排序8、计数排序9、桶排序10、基数排序 十大经典排序算法 平均时间复杂度 最好时间复杂度 最坏时间复杂度 空间复杂度 排序方式 稳定性 冒泡排序 O\OmicronO(n2) O\OmicronO(n) O\OmicronO(n2) O\OmicronO(1) In-place 稳定 选择排序 O\OmicronO(n2) O\O
数据结构-十大经典排序算法
qq_64010161的博客
12-09 2903
数据结构-十大经典排序算法（冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序）
十大经典排序算法-快速排序算法详解
qq_35344198的博客
06-16 8万+
一、什么是快速排序 1.概念 快速排序（Quick Sort）是从冒泡排序算法演变而来的，实际上是在冒泡排序基础上的递归分治法。快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照快速排序的思想，我们先选择一个基准元素，进行排序 我们选取4为我们的基准元素，并设置基准元素的位置为index，设置两个指针left和right，分别指向最左
c++十大经典排序算法
客舟中
12-28 5618
代码 1 冒泡排序 冒泡排序是一种简单直观的入门排序算法。它的原理就是从第一个元素开始，与后面的元素逐个比较，如果顺序不对就交换，直到没有可比较的元素为止。 1 // 冒泡排序 2 void BublingSort(int *arr, int len) 3 { 4 if(len == 0) 5 { 6 return; 7 } 8 std::cout<<"冒泡排序"<<std::endl; 9 for(i
十大经典排序算法.pdf
12-08
十大经典排序算法 排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中 进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序 记录，在...
十大经典排序算法源码.cpp
05-02
爆肝整理！堪称全网最详细的十大常用经典排序算法总结！！！ C++模板类实现，附带部分测试用例！！！
排序1——直接插入排序，希尔排序，选择排序，堆排序
2301_80224556的博客
05-11 745
2.2.2.1. 希尔排序是对直接插入排序的优化。2.2.2.2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。2.2.2.2.2.2.4. 稳定性：不稳定。
Java 7大排序
m0_74270127的博客
05-10 812
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
【算法】NOIP2003神经网络
最新发布
littlegengjie的博客
05-13 592
图中，X1—X3是信息输入渠道，Y1－Y2是信息输出渠道，C1表示神经元目前的状态，Ui是阈值，可视为神经元的一个内在参数。然后根据拓扑排序一次遍历该图的所有点（例如便利到点1，会遍历所有以点1位直接前驱的点），遍历点1之后，3、4、5的状态均为1，遍历点2之后3、4、5均为2，将所有输出点的状态减去阈值，就为最终状态。现在，给定一个神经网络，及当前输入层神经元的状态（Ci），要求你的程序运算出最后网络输出层的状态。再下面P行，每行由两个整数i，j及一个整数Wij，表示连接神经元i、j的边权值为Wij。
1080：余数相同问题
如果没有特别说明，c++都是基于GCC-4.9.2运行的
05-11 378
【代码】：1080：余数相同问题
找第二大的数（分治法）
2201_75525567的博客
05-11 302
这段代码通过递归的方式，将数组分为两半，并分别找出左半部分和右半部分的两个最大数，然后比较这四个数的大小，得到第二大的数。这段代码是用来找出数组中第二大的数的。
C# 十大经典排序算法
09-21
C# 的十大经典排序算法包括二叉树排序、快速排序、希尔排序、插入排序、冒泡排序、选择排序等。这些算法都有自己的特点和适用场景。二叉树排序是一种基于二叉树的排序算法，它通过构建排序二叉树来实现排序。快速...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值