排序算法伪代码

㈠ 求冒泡排序的全中文的伪代码

伪代码啊，还真不好描述：
假设有N个数，可以想象成所有的数分成两部分：上部和下部，上部的是排好序的，下部的没有。

外层循环N-1次（i从0到N-2）{ //每循环一次就能让一个下部数中最大的冒到上部来
内层循环从0开始，循环到j（j=N-i）{ //保证下部的每个位置都进行一次冒泡判断
如果当前的数比它上面的一个数大，就互换位置（冒上来一次）。
/* 这是互换代码
if(array[j]>array[j+1])
{
int tmp=array[j];
array[j]=array[j+1];
array[j+1]=tmp;
}
*/
//可以想象，如果足够大，该数会一直更新位置，一直往上冒，到达合适位置。
}
}

外层循环结束后就排好序了。
这个算法的特点就是如果一个数是下部中最大的，它就能一直往上冒，不管它当初在什么位置，内层一轮冒泡后它就能冒到上部去（成为上部里最小的）。N-1轮后就排好序了。

描述的不怎么好，还写不出来的话可以直接要代码（猜你是想自己写出来所以没贴代码）

㈡ 用伪代码写出使用子算法的冒泡排序算法,子算法是在未排序子表中做冒泡工作

#include “stdio.h”
#define N 10
main( )
{ int a[N+1];
int i,j,t;
for(i=1;i<=N;i++)
scanf(“%d”,&a[i]);
printf(“\n”);
for(j=1;j<N;j++)
for(i=1;i<N-j;i++)
if(a[i]>a[i+1])
{t=a[i];
a[i]=a[i+1];
a[i+1]=t;
}
printf(“the sorted numbers:\n”);
for(i=1;i<=N;i++)
printf(“%4d”,a[i]);
}

㈢ 我研究出一种新排序算法

我欣赏你的算法！孩子，相信自己，有朝一日你会成功的！不要听他们对你的评论，她们只是嫉妒你的才华！任何一个思想，都有一个微不足道的开端！

㈣ 区间排序算法的实现，代码C++，排序算法的问题

这不就类似于桶排序么，只不过桶的大小为序列的最大值减去最小值+1而已。

伪代码如下：

voidbucketsort(int*Input,intlen)
{
intu,w;
u=mininInput;
w=maxinInput;
int*bucket=newint[w-u+1];
for(inti=0;i<w-u+1;i++)
bucket[i]=0;
for(inti=0;i<len;i++)
bucket[Input[i]-u]++;
//printresult;
for(inti=0;i<w-u+1;i++)
while(bucket[i])
{
cout<<bucket[i]+u<<endl;
bucket[i]--;
}

㈤ 帮忙解释一下这段分治法的伪代码，或者翻译成python代码!

这是将一个数组A中A[p]到A[q]分成数组L，A[q+1]到A[r]分成数组R，然后再按从小到大的顺序重新排序合并起来。前提是A[p到q]和A[q+1到r]已经按重小到大顺序排好，不然这个函数没有意义。它是merge sort排序算法的一部分，先把数组分成两半，分别排序，在合并起来。比如说数组已经对前半部分和后半部分完成排序[3,2,5,1,6,4]-->[2,3,5,1,4,6]。通过MERGE函数分成[2,3,5]和[1,4,6].然后组合成[1,2,3,4,5,6]

㈥ 编写伪代码算法,读入用户输入的三个整数,然后按照数字排序输出它们.

以下的伪代码实现升序排序：
1）读入变量1，变量2，变量3
2）如果变量1>变量2，则交换变量1、变量2的值
3）如果变量1>变量3，则交换变量1、变量3的值
4）如果变量2>变量3，则交换变量2、变量3的值
5）输出变量1，变量2，变量3的值

㈦ 想问您一些排序算法的伪代码，谢啦

冒泡排序：网页链接

所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。

C++自带的algorithm库函数中提供了排序算法。

稳定的

冒泡排序（bubble sort） — O(n^2）

鸡尾酒排序(Cocktail sort，双向的冒泡排序) — O(n^2）

插入排序（insertion sort）— O(n^2)

桶排序（bucket sort）— O(n); 需要 O(k) 额外空间

计数排序(counting sort) — O(n+k); 需要 O(n+k) 额外空间

合并排序（merge sort）— O(nlogn); 需要 O(n) 额外空间

原地合并排序— O(n^2)

二叉排序树排序 （Binary tree sort） — O(nlogn)期望时间； O(n^2)最坏时间； 需要 O(n) 额外空间

鸽巢排序(Pigeonhole sort) — O(n+k); 需要 O(k) 额外空间

基数排序（radix sort）— O(n·k); 需要 O(n) 额外空间

Gnome 排序— O(n^2)

图书馆排序— O(nlogn) with high probability，需要 （1+ε)n额外空间

不稳定的

选择排序（selection sort）— O(n^2)

希尔排序（shell sort）— O(nlogn) 如果使用最佳的现在版本

组合排序— O(nlogn)

堆排序（heapsort）— O(nlogn)

平滑排序— O(nlogn)

快速排序（quicksort）— O(nlogn) 期望时间，O(n^2) 最坏情况； 对于大的、乱数列表一般相信是最快的已知排序

Introsort— O(nlogn)

耐心排序— O(nlogn+k) 最坏情况时间，需要 额外的 O(n+k) 空间，也需要找到最长的递增子串行（longest increasing subsequence）

不实用的

Bogo排序— O(n×n!) 期望时间，无穷的最坏情况。

Stupid sort— O(n^3); 递归版本需要 O(n^2) 额外存储器

珠排序（Bead sort） — O(n) or O（√n)，但需要特别的硬件

Pancake sorting— O(n)，但需要特别的硬件

stooge sort——O（n^2.7）很漂亮但是很耗时

㈧ 求一排序算法（思路或伪代码均可）

你从左往右,从上往下遍历每一个元素,执行一个调整函数.
这个函数大概是这样的:
函数1(x,y):
如果
元素[x,y+1]
没有超界
并且
元素[x,y]
大于
元素[x,y+1]
则
元素[x,y+1]
设为
目前最大的数字+1
找出全部和元素[x,y+1]关联的元素,改变他们的值,并在他们的坐标上执行函数1.
这里所说的关联,是指他们的初始值一样.目前最大数字是指整个阵列中最大的数字.