各种排序代码实现

最新推荐文章于 2022-09-25 21:41:25 发布
最新推荐文章于 2022-09-25 21:41:25 发布
阅读量482 收藏
点赞数
分类专栏： 成长之路 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lange_Taylor/article/details/99678961
版权
成长之路 同时被 3 个专栏收录
141 篇文章 0 订阅
订阅专栏
努力
40 篇文章 0 订阅
订阅专栏
数据结构
13 篇文章 0 订阅
订阅专栏

基于C语言实现的

其中堆排序和循环快排使用到栈。
stack.h：

#pragma once

typedef int STDataType;

typedef struct Stack
{
	STDataType* arr;
	int size;
	int capacity;
}Stack;
void StackInit(Stack* s, int capacity);
void StackPush(Stack* s,STDataType data);
void StackPop(Stack* s);
STDataType StackTop(Stack* s);
int StackEmpty(Stack* s);
int StackSize(Stack* s);
int StackCapacity(Stack* s);
void StackDestroy(Stack* s);
void CheckCapacity(Stack* s);

stack.c:

#include "stack.h"
#include <stdio.h>
#include <malloc.h>
#include <assert.h>

void StackInit(Stack* s,int capacity) {
	assert(s);
	s->arr = (STDataType*)malloc(sizeof(STDataType)*capacity);
	if (s->arr == NULL)
	{
		assert(0);
		return;
	}
	s->capacity = capacity;
	s->size = 0;
}
void StackPush(Stack* s,STDataType data) {
	assert(s);
	if (s->capacity == s->size)
	{
		CheckCapacity(s);
	}
	s->arr[s->size++] = data;
}
void StackPop(Stack* s) {
	assert(s);
	if (StackEmpty(s))
		return;
	s->size -= 1;
}
STDataType StackTop(Stack* s) {
	assert(s);
	return s->arr[s->size-1];
}
int StackEmpty(Stack* s) {
	assert(s);
	return s->size == 0;
}
int StackSize(Stack* s) {
	assert(s);
	return s->size;
}
int StackCapacity(Stack* s) {
	assert(s);
	return s->capacity;
}
void StackDestroy(Stack* s) {
	if (s->arr) {
		free(s->arr);
	}
	s->capacity = 0;
	s->size = 0;
}
void CheckCapacity(Stack* s) {
	assert(s);
	int newcapacity = 2 * s->capacity;
	STDataType* pTemp = (STDataType*)malloc(sizeof(STDataType)*newcapacity);
	if (pTemp == NULL) {
		assert(0);
		return;
	}
	for (int i = 0; i < s->size; i++) {
		pTemp[i] = s->arr[i];
	}
	free(s->arr);
	s->arr = pTemp;
	s->capacity = newcapacity;
}

Sort.h文件：

#pragma once

//时间复杂度:O(N^2)
//空间复杂度:O(1)
//稳定性;稳定
//冒泡排序
void BubbleSort(int arr[], int len);
//应用场景;数据量小,接近有序
//时间复杂度:O(N^2)
//空间复杂度:O(1)
//稳定性;稳定
//插入排序
void InsertSort(int arr[], int len);
void InsertSort1(int arr[], int left, int right) ；
//应用场景:数据量大,无序
//时间复杂度:O(N^1.25 -1.6N^1.25)
//空间复杂度:O(1)
//稳定性;不稳定
//希尔排序
void ShellSort(int arr[], int len);
//时间复杂度:O(N^2)
//空间复杂度:O(1)
//稳定性;稳定
//选择排序
void SelectSort(int arr[], int len);
void SelectSort1(int arr[], int len);
//时间复杂度:O(NlogN)
//空间复杂度:O(1)
//稳定性:不稳定
//大堆升序,小堆降序
//Top  k
//堆排序
void HeapSort(int arr[], int len);

//时间复杂度:O(NlogN)
//空间复杂度:O(N)
//稳定性:不稳定
//优化后的快排
void QuickSort(int arr[], int left, int right);

void MergeData(int arr[], int left, int  mid, int  right,int* temp);
//时间复杂度:O(NlogN)
//空间复杂度:O(N)
//稳定性:稳定
//归并排序   封装对外接口
void MergeSort(int arr[], int len);
void _MergeSort(int arr[], int left, int right,int* temp);
void MergeSortNor(int arr[], int len);

//时间复杂度:O(N)
//空间复杂度:O(N)
//稳定性:稳定
//计数排序
void CountSort(int arr[], int len);
//优化分割  三数取中法
int GetMiddleIndex(int arr[], int left, int right);
//三种分割区间方法
int Partion1(int arr[], int left, int right);
int Partion2(int arr[], int left, int right);
int Partion3(int arr[], int left, int right);

Sort.c:

#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <assert.h>
#include <string.h>
//打印函数
void PrintfArray(int arr[],int len) {
	for (int i = 0; i < len;++i) {
		printf("%d ",arr[i]);
	}
	printf("\n");
}
//交换函数
void Swap(int* a, int* b) {
  	     int tmp = *a;
		 * a = *b;
		 * b = tmp;
} 


//时间复杂度:O(N^2)
//空间复杂度:O(1)
//稳定性;稳定
int flag = 0;//0表示没有排序好  //稍加优化的冒泡排序                                                                                                                         |~                        
void BubbleSort(int arr[], int len) {
	
	   flag = 1;
	   for (int i = 0; i < len; i++) {
	       for (int j = len - 1; j > i; j--) {
		       if (arr[j - 1] > arr[j]) {				
			           flag = 0; 
			           Swap(&arr[j - 1],&arr[j]); 		
				}			
			}
		} 		
	}

//时间复杂度:O(N^2)
//空间复杂度:O(1)
//稳定性;稳定

void InsertSort(int arr[], int len) {
	for (int i = 1; i < len; ++i) {
		//待插入元素
		int key = arr[i];
		//找key的插入位置:与前面已经排好的元素比较
		int end = i - 1;
		while (end >= 0 && key < arr[end]) {
			arr[end + 1] = arr[end];
			end -= 1;
		}
		//插入元素
		arr[end + 1] = key;
	}
}

//时间复杂度:O(N^1.25 -1.6N^1.25)
//空间复杂度:O(1)
//稳定性;不稳定

void ShellSort(int arr[], int len) {
	int gap = len;
	while (gap>0) {
		gap = gap / 3 + 1;//O(N^1.25 -1.6N^1.25)时间复杂度
		for (int i = gap; i < len; ++i) {
			//待插入元素
			int key = arr[i];
			//找key的插入位置:与前面已经排好的元素比较
			int end = i - gap;
			while (end >= 0 && key < arr[end]) {
				arr[end + gap] = arr[end];
				end -= gap;
			}
			//插入元素
			arr[end + gap] = key;
		}
		gap -= 1;
	}
}

//堆排序向下调整
void AdjustDown(int arr[], int len, int parent) {
	int child = parent * 2 + 1;
	while (child < len) {
		if (child + 1 < len && arr[child + 1] > arr[child]) {
			child += 1;
		}			
		if (arr[child] > arr[parent]) {
				Swap(&arr[child], &arr[parent]);
				parent = child;
				child = parent * 2 + 1;
		}
			else
				return;		
	}
}

//时间复杂度:O(NlogN)
//空间复杂度:O(1)
//稳定性:不稳定
//Top  k

void HeapSort(int arr[],int len) {
	//建堆找倒数第一个非叶子节点
	int root = ((len - 2) >> 1);
	for (; root >= 0; --root) {
		AdjustDown(arr, len, root);
	}
	//排序  堆删除思想
	int end = len - 1;
	while (end) {
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, end, 0);
		end--;
	}
}




//缺陷:进行了重复比较
void SelectSort1(int arr[], int len) {
	
	for (int i = 0; i < len - 1;++i) {
		int Maxpos = 0;
		for (int j = 1; j < len - i;++j) {
			if (arr[j] > arr[Maxpos]) {
				Maxpos = j;
			}
			if(Maxpos != len-i-1)
			Swap(&arr[len-i-1], &arr[Maxpos]);
		}
	}
}
//时间复杂度:O(N^2)
//空间复杂度:O(1)
//稳定性;稳定
void SelectSort(int arr[], int len) {
	int begin = 0;
	int end = len - 1;
	while (begin<end) {
		int Maxpos = begin;
		int Minpos = begin;
		int index = begin+1;
		while (index<=end) {
			if (arr[index] > arr[Maxpos])
				Maxpos = index;
			if (arr[index] < arr[Minpos])
				Minpos = index;
			index++;
		}
		if (Minpos == end)
			Minpos = Maxpos;
		//可能会覆盖小元素位置,所以要更新Minpos位置
		
		if (Maxpos != end)
			Swap(&arr[Maxpos], &arr[end]);
		
		if (Minpos != begin)
			Swap(&arr[Minpos], &arr[begin]);
		begin++;
		end--;
	}

}

//优化分割  三数取中法 


int GetMiddleIndex(int arr[], int left, int right) {

	int mid = left + ((right - left) >> 1);
	if (arr[left] < arr[right - 1]) {
		if (arr[mid] < arr[left])
			return left;
		else if (arr[mid] > arr[right - 1])
			return right - 1;
		else
			return mid;
	}
	else {
		if (arr[mid] > arr[left])
			return left;
		else if (arr[mid] < arr[right - 1])
			return right - 1;
		else
			return mid;
	}
}

//分割方式
//第一种:hoare
int Partion1(int arr[], int left, int right) {
	int begin = left;
	int end = right-1;
	int mid = GetMiddleIndex(arr, left, right);
	Swap(&arr[mid], &arr[right - 1]);
	int key = arr[right-1];

	while (begin<end) {

		while (begin < end && arr[begin] <= key)
			begin++;
		while (begin < end && arr[end] >= key)
			end--;
		if(begin != end)
		Swap(&arr[begin], &arr[end]);
	}
	if(begin != right-1)
	Swap(&arr[right - 1], &arr[begin]);
	return begin;
}


//第二种:挖坑法
int Partion2(int arr[], int left, int right) {
	int begin = left;
	int end = right - 1;
	int mid = GetMiddleIndex(arr, left, right);
	Swap(&arr[mid], &arr[right - 1]);
	int key = arr[right - 1];
	while (begin<end) {
		while (begin < end && arr[begin] <= key)
			begin++;
		if (begin < end) {
			arr[end] = arr[begin];
			end--;
		}
		while (begin < end && arr[end] >= key)
			end--;
		if (begin < end) {
			arr[begin] = arr[end];
			begin++;
		}
	}
	arr[begin] = key;
	return begin;
	
}
//第三种:两个指针
int Partion3(int arr[], int left, int right) {
	int cur = left;
	int pre = cur - 1;
	int mid = GetMiddleIndex(arr, left, right);
	Swap(&arr[mid], &arr[right - 1]);
	int key = arr[right - 1];
	while (cur < right) {
		if (arr[cur] < key && ++pre != cur)
			Swap(&arr[pre], &arr[cur]); 
		cur++;
	}
	if(++pre != right)//防止越界
	Swap(&arr[pre], &arr[right - 1]);
	return pre;
}

void QuickSort(int arr[], int left, int right) {
	//[  )左闭右开
	if (right-left>1) {
		//分割左右区间
		int div = Partion3(arr, left, right);
		QuickSort(arr, left, div);
		QuickSort(arr, div + 1, right);
	}

}

//优化快排实现(相互配合)的调用接口
//修改的插入排序

void InsertSort1(int arr[], int left, int right) {
	for (int i = left; i < right; ++i) {
		//待插入元素
		int key = arr[i];
		//找key的插入位置:与前面已经排好的元素比较
		int end = i - 1;
		while (end >= 0 && key < arr[end]) {
			arr[end + 1] = arr[end];
			end -= 1;
		}
		//插入元素
		arr[end + 1] = key;
	}
}

//应用场景(数据量大,随机序列)
//优化之后的快排
//三数取中法
//减小递归深度 数据长度小于16时,用直接插入排序替换
//时间复杂度:O(NlogN)
//空间复杂度:O(N)
//稳定性:不稳定
void QuickSort1(int arr[], int left, int right) {
	//[  )左闭右开
	if (right - left < 16)
		InsertSort1(arr, left, right);
	else {
		//分割左右区间
		int div = Partion3(arr, left, right);
		QuickSort1(arr, left, div);
		QuickSort1(arr, div + 1, right);
	}

}
#include "stack.h"
void QuickSortNor(int arr[],int len) {
	int left = 0;
	int right = len;

	Stack s;
	StackInit(&s,len);
	StackPush(&s, right);
	StackPush(&s, left);
	int div = Partion3(arr, left, right);
	while (!StackEmpty(&s)) {
		left = StackTop(&s);
		StackPop(&s);
		right = StackTop(&s);
		StackPop(&s);
		if (right - left > 1) {
			int div = Partion3(arr, left, right);
			//[left,div)
			//[div+1,right)
			//保存右半部分
			StackPush(&s, right);
			StackPush(&s, div + 1);
			//保存左半部分
			StackPush(&s, div);
			StackPush(&s, left);
		}
	}
}

void MergeData(int arr[],int left,int  mid,int  right,int* temp) {
	int begin1 = left, end1 = mid;
	int begin2 = mid, end2 = right;
	int index = left;
		while (begin1 < end1 && begin2 < end2) {
			if (arr[begin1] < arr[begin2])
				temp[index++] = arr[begin1++];
			else
				temp[index++] = arr[begin2++];
		}
		while (begin1 < end1)
			temp[index++] = arr[begin1++];
		while (begin2 < end2)
			temp[index++] = arr[begin2++];
}


void _MergeSort(int arr[], int left, int right,int* temp) {
	if (right - left > 1) {
		int mid = left + ((right - left) >> 1);
		//[left,mid)
		//[mid,right)
		_MergeSort(arr, left, mid,temp);
		_MergeSort(arr, mid, right,temp);
		MergeData(arr, left, mid, right,temp);
		memcpy(arr+left, temp+left, sizeof(int)*(right - left));
	}
}

void MergeSort(int arr[], int len) {
	int* temp = (int*)malloc(sizeof(int)*len);
	if (NULL == temp) {
		assert(0);
		return;
	}
	_MergeSort(arr, 0, len, temp);
	free(temp);
}
//时间复杂度:O(NlogN)
//空间复杂度:O(N)
//稳定性:稳定
void MergeSortNor(int arr[], int len) {
	int* temp = (int*)malloc(sizeof(int)*len);
	if (NULL == temp) {
		assert(0);
		return;
	}
	int gap = 1;
	while (gap < len) {
		for (int i = 0; i < len; i += 2 * gap) {
			int left = i;
			int mid = left + gap;
			if (mid >= len)
				mid = len;
			int right = mid + gap;
			if (right >= len)
				right = len;
			MergeData(arr, left, mid, right, temp);
		}
		memcpy(arr, temp, sizeof(int)*len);
		gap *= 2;
	}
	free(temp);
}

void CountSort(int arr[],int len) {
	//找数据范围
	int minvalue = arr[0];
	int maxvalue = arr[0];
	for (int i = 0; i < len;++i) {
		if (arr[i] >= maxvalue)
			maxvalue = arr[i];
		if (arr[i] < minvalue)
			minvalue = arr[i];
	}
	int range = maxvalue - minvalue + 1;
	
	int* pCount = (int*)malloc(sizeof(int)*range);
	if (NULL == pCount) {
		assert(0);
		return;
	}
	memset(pCount, 0, sizeof(int)*range);
	//统计元素出现个数
	for (int i = 0; i < len;++i) {
		pCount[arr[i] - minvalue]++;
	}
	//回收元素
	int index = 0;
	for (int i = 0; i < range;++i) {
		while (pCount[i]) {
			arr[index++] = i + minvalue;
			pCount[i]--;
		}
	}
	free(pCount);
}


int main() {
					
		//int  arr[] = { 3,5,2,9,1,7,6,0,8,4 }; 
		//int  arr[] = { 2,5,1,7,4,6,9,3,8,0 };
		//int  arr[] = { 3,4,2,9,1,7,6,0,8,5 };
		int  arr[] = { 2,1,2,5,4,1,2,1,5,4,2,5,4,1,5,2,4,2,1,5,1,4,5,5,4 };
		PrintfArray(arr, sizeof(arr) / sizeof(arr[0]));
	    //BubbleSort(arr, sizeof(arr) / sizeof(arr[0]));
		//InsertSort(arr, sizeof(arr) / sizeof(arr[0]));
		//ShellSort(arr, sizeof(arr) / sizeof(arr[0]));
		//SelectSort1(arr, sizeof(arr) / sizeof(arr[0]));
		//SelectSort(arr, sizeof(arr) / sizeof(arr[0]));
		//QuickSort(arr, 0,sizeof(arr) / sizeof(arr[0]));
		QuickSort1(arr, 0, sizeof(arr) / sizeof(arr[0]));
		//MergeSort(arr, sizeof(arr) / sizeof(arr[0]));
		//MergeSortNor(arr, sizeof(arr) / sizeof(arr[0]));
		//CountSort(arr, sizeof(arr) / sizeof(arr[0]));
		//HeapSort(arr, sizeof(arr) / sizeof(arr[0]));
		//QuickSortNor(arr, sizeof(arr) / sizeof(arr[0]));
		PrintfArray(arr, sizeof(arr) / sizeof(arr[0]));
	    return 0; 
}

测试结果：
在这里插入图片描述

Lange_Taylor
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各类排序代码实现
啊奥的博客
07-23 4809
以下各种排序算法是我自己跟着算法描述写的（有参考其他人的），直接贴到VS里就能用，如果要看懂的话还是需要了解一下各种排序算法的实现原理 先随手总结一下各种排序的时间复杂度以及稳定性 排序算法 时间复杂度 辅助空间 稳定性 冒泡排序(交换排序类) O(n^2) ...
常见的八种基本排序的代码
tingzs111的博客
07-05 4154
简单的介绍了一下常见的七种排序以及一种非比较排序中的计数排序。
C语言的升序排列
sunmo0n的博客
12-17 1万+
@TOCC语言中的排列 1，代码 //升序排列 #include<stdio.h> void sort(int array[],int n); //排序函数声明 void swap(int *ex1,int *ex2); //交换函数声明 int main() { int a[10],i; printf(“请输入要排列的数字：\n”); for(i=0;i<(sizeof a/sizeof a[0]);i++){ scanf("%d",&a[i]);} sort
10种排序算法及代码实现
weixin_45548912的博客
05-27 2022
十大经典排序算法 0、算法概述 0.1 算法分类 十种常见排序算法可以分为两大类： 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 0.2 算法复杂度 0.3 相关概念 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b
排序及其代码详解~
m0_64028711的博客
09-25 1092
有七大重要排序及其代码详解~ 此处end表示一组数据有序序列的最后一位，用 i 控制，tmp则表示有序数据之后的一位数据，也就是我们需要插入有序数列中的数。
PHP 各种排序算法实现代码
01-20
php // 功能: PHP实现各种排序算法 // Author: windlike // Datetime: 2007-06-09 // 冒泡排序 function BubbleSort($arr){ $num = count($arr); for($i=1;$i<$num;$i++){ for($j=$num-1;$j>=$i;$j–){ if($arr[$...
JavaScript实现各种排序的代码详解
10-19
给大家介绍了js实现各种排序功能，包括冒泡排序，选择排序和插入排序，代码简单易懂，非常不错，具有参考借鉴价值，需要的的朋友参考下吧
js常用排序实现代码
12-12
代码如下: [removed] Array.prototype.swap = function(i, j) { var temp = this[i]; this[i] = this[j]; this[j] = temp; } Array.prototype.bubbleSort = function() { for (var i = this.length – 1; i > 0; –i...
选择排序 python 代码实现
11-06
选择排序（Selection Sort）是一种简单直观的排序算法。它的基本思想是每次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，放到已...
算法模块学习之二叉树- 前序排序、中序排序、后序排序
大头虾！！
04-28 1302
目的：分别打印二叉树- 前序排序、中序排序、后序排序结果 public static class Node { Node left; Node right; int value; public Node(int value) { this.value = value; } } 首先了解一下前序排序、中序排序、后序排序是怎样的 前序排序：对于每个节点都要满足，先打印节点，再打印左树，再打印右树
数据结构排序算法（一）：排序方法分类和各种排序方法的实现
青红造了个大白之成长记
07-08 8193
一、 实验目的1. 掌握各种常用排序的算法思想；2. 掌握各种常用排序的算法实现；3. 掌握各种常用排序时间复杂度，比较各种排序的优缺点。二.排序算法的归类：总的排序算法分为以下几类：1.插入类排序：如：直接插入排序，折半插入排序，希尔排序2.交换类排序：如：冒泡排序，快速排序，其中冒泡排序应该是计算机专业的学生最为熟悉的一种排序算法了，而快速排序则是在冒泡排序的基础上一次消除多个逆序对改进而来3...
8种常用的排序算法
pan16309的博客
05-18 1443
8种常用的排序算法 数据结构中的排序是非常重要的知识，将数据排序是处理数据的基本起手操作。从类型上分排序可以分为内部排序和外部排序，对保存在内存中的数据进行排序成为内部排序，对保存在磁盘上的数据排序称为外部排序。 本文将对内部排序常用的8中排序做一个简单介绍，作为一个程序员，需要熟练掌握这8种常用的排序，理解其排序思想，并能以代码实现。 8种排序中的时间复杂度和空间复杂度一览 可以...
各种排序实现及比较（Java）
夏倩倩的博客
08-06 434
排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。 内排序有可以分为以下几类：插入排序：直接插入排序、二分法插入排序、希尔排序。插入排序Java实现 选择排序：简单选择排序、堆排序。选择排序Java实现 交换排序：冒泡排序、快速排序。交换排序Java实现 归并排序：归并排序Java实现 基数
快速排序源代码
系统运维
03-23 91
#include &lt;iostream&gt; using namespace std; int quickSort(int *array,int x,int y) { int low=x,high=y; int key=array[x]; if(low&gt;high)return 1; if(low==high)return 0; while(low&lt;high) {...
选择排序及选择排序的优化算法详解及实现----c语言
zhao_miao的博客
09-20 1万+
  选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置(或末尾位置），直到全部待排序的数据元素排完。   由于选择排序一次能确定一个元素的位置，所以选择排序需要循环size-1次。   算法的稳定性： 不稳定 （比如序列【5， 5*， 3】第一趟就将第一个[5]与[3]交换，导致第一个5挪动...
线程安全之重排序
weixin_44799092的博客
05-11 490
重排序 一个处理器上面执行的多种操作，在其他处理器看来与该处理器上面程序指定的操作顺序不同 重排序是处理器，编译器，存储子系统为了改善程序执行性能而对内存访问操作执行的操作，它可以在不影响程序（单线程下）正确执行的条件改善程序执行性能 分类： 指令重排序 存储子系统重排序（内存重排序） 一些与重排序相关的概念 源代码顺序：源代码中所指定的内存访问操作 程序顺序：给定处理器中目标代码的执行顺序 执行顺序：处理器中代码的真正执行顺序 感知顺序：给定的处理器感知到的该处理器和其他处理器的内存访问操作 指令
原创：基于二叉树的中序遍历法排序代码
randy_01的博客
02-14 178
原创：基于二叉树的中序遍历法排序代码 搜索中资深排序算法工程师，要求掌握深度学习中的机器学习排序算法，比如ListNet算法等等。其实，排序算法有很多，比较著名的应用，比如从海量数据中寻找出topk（k值很小)的算法，实现逻辑很简单，要求是最优算法，这里不详细说。在搜索中，返回的文档，在考虑很多因素情况下的机器学习排序……截至到2014年，goog...
各种排序代码 .
http://www.softwareace.cn 王牌软件
10-09 461
#include #include const int SIZE = 100; const int MAX = 1000; using namespace std; //交换数据 void Swap(int &a, int &b) { int temp
数据库的升序降序排列
热门推荐
georgehenrywilliam的博客
08-22 5万+
数据库中使用order by语句进行排序，其中升序用asc，降序用desc。 如: select * from t order by 列a asc; -- 这是升序 asc可以省略不写 select * from t order by 列a desc; --这是降序
计数排序代码实现 C语言
最新发布
04-23
这段代码实现了计数排序算法。首先，它找出待排序数组中的最大值，然后创建一个计数数组，并将其初始化为0。接下来，它统计每个元素的出现次数，并根据计数数组重新排序原始数组。最后，打印排序后的数组。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值