数组排序算法

❶ 排序算法：有规律的数组排序

这个“规律”具体是什么呢？我可以归纳出三种：

• 奇数项和偶数项各自都是有序的整数；

• 奇数项和偶数项各自都是有序的连续整数；

• 奇数项和偶数项各自都是有序的连续整数，且奇数项全部小于偶数项；

哪个是题主所说的“规律”？

❷ 用快速排序算法，对下列数组排序

#include<iostream>
using namespace std;
int Por(int *ar,int l,int h){
int k=ar[l];
while(l<h){
while(l<h&&k<=ar[h])
h--;
ar[l]=ar[h];
while(l<h&&k>=ar[l])
l++;
ar[h]=ar[l];
}
ar[l]=k;
return l;
}
void QSort(int *ar,int l,int h,int n){
if(l<h){
int m=Por(ar,l,h);
for(int i=0;i<n;i++)
cout<<ar[i]<<" ";
cout<<endl;
QSort(ar,l,m-1,n);
QSort(ar,m+1,h,n);
}
}
int main(){
int n,*ar;
cin>>n;
ar=new int[n];
for(int i=0;i<n;i++)
cin>>ar[i];
QSort(ar,0,n-1,n);
return 0;
}
输入：
8
60 56 65 99 22 16 88 100
输出：
16 56 22 60 99 65 88 100
16 56 22 60 99 65 88 100
16 22 56 60 99 65 88 100
16 22 56 60 88 65 99 100
16 22 56 60 65 88 99 100

❸ 对数组排序,如果排序数据量很大,排序算法仍然适用吗

#include<stdio.h>

intmain()

{

inti=0;

inta[10]={0,5,2,3,6,9,8,7,4,1};

intj=0;

inttmp=0;

intm=sizeof(a)/sizeof(a[0]);//s数组大小

for(i=0;i<m-1;i++)//比较m-1次

{

for(j=0;j<m-i-1;j++)//最后一次比较a[m-i-1]与a[m-i-2]

{

if(a[j]>a[j+1])//如果a[j]比a[j+1]大则交换内容

{

tmp=a[j+1];

a[j+1]=a[j];

a[j]=tmp;

}

}

}

for(i=0;i<m;i++)

{

printf("%d",a[i]);//打印

}

printf(" ");

return0;

}

❹ 给定一个整数数组a,请实现一个排序算法，将该数组从大到小排列并输出

#include <stdio.h>
# define N 100
void main ()
{
int i,j,t,n,a[N];
printf("请输入数组元素个数n:");
scanf("%d",&n);
printf("请输入%d个数:",n);
for(i=0;i<n;i++)
scanf("%d",&a[i]);
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(a[i]<a[j])
{
t=a[i];
a[i]=a[j];
a[j]=t;
}
for(i=0;i<n;i++)
printf("%-5d",a[i]);
}

❺ c语言考试。问数组，常见的数组排序算法有那几种选择一个描述过程。

有插入排序：直接插入排序、折半插入排序、希尔排序；交换排序：冒泡排序、快速排序；选择排序：简单选择排序、堆排序；归并排序；基数排序。
常用冒泡排序的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面（数组由小到大排序）。即首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后，此时第一趟结束，在最后的数必是所有数中的最大数。重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到最大数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最大数。如此下去，直至最终完成排序。
由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。
用二重循环实现，外循环变量设为i，内循环变量设为j。外循环重复9次，内循环依次重复9，8，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i,
j的值依次为1,2,...10-i。
代码：
for(i=0;
i<NUM-1;
i++)
/*外循环：控制比较趟数*/
for(j=NUM-1;
j>i;
j--)
/*内循环：进行每趟比较*/
if(data[j]<data[j-1])
/*如果data[j]大于data[j-1],交换两者的位置*/
{temp=data[j];
data[j]=data[j-1];
data[j-1]=temp;
};

❻ 数组排序

既然是排序问题，那就看你写的排序函数就知道了。
从 for(i=0;i<=10;i++)
{
for(j=0;j<=10-i;j++)
来看，你应该是想写个冒泡排序的，就是按轮数，每轮相邻数两两比较，小的（或大的）往后靠。
那就这样写：
for(i=1;i<10;i++) // 轮数，10个数，比较9轮
{
for(j=1;j<=10-i;j++) // 每轮比较的数目，最多是第一轮，有9个（1跟2，2跟3，……9跟10）
{
if ( a[j-1] < a[j]) //小的往后靠
{
d = a[j];
a[j] = a[j-1];
a[j-1] = d;
}
}
}

建议楼主在网上搜点排序算法的介绍看看，看算法到底是怎么回事，没弄清楚很容易弄错。

跟着你的提问，你说的问题归根到底还是你算法有明显的逻辑错误。
既然指定了数组大小是n，那么从0开始，数组下标最大是n-1，你把i设成i<=n，在第一次你说的不行的函数内部，当i=19时，j=20符合j<=20，接着内部的if语句，就会出现a[19] < a[20]这种错误，a[20]压根不存在。排序函数改成你随后的，因为j变成了j < n，当i=19时，j=20，j所在的for循环结束，后面的语句都走不到，因此也就不存在问题。

❼ Java通过几种经典的算法来实现数组排序

JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。
快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。
冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。
选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。
插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。
<1>利用Arrays带有的排序方法快速排序

public class Test2{ public static void main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } }

<2>冒泡排序算法

public static int[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;i<args.length-1;i++){ for(int j=i+1;j<args.length;j++){ if (args[i]>args[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; }

<3>选择排序算法

public static int[] selectSort(int[] args){//选择排序算法 for (int i=0;i<args.length-1 ;i++ ){ int min=i; for (int j=i+1;j<args.length ;j++ ){ if (args[min]>args[j]){ min=j; } } if (min!=i){ int temp=args[i]; args[i]=args[min]; args[min]=temp; } } return args; }

<4>插入排序算法

public static int[] insertSort(int[] args){//插入排序算法 for(int i=1;i<args.length;i++){ for(int j=i;j>0;j--){ if (args[j]<args[j-1]){ int temp=args[j-1]; args[j-1]=args[j]; args[j]=temp; }else break; } } return args; }

❽ 如何将数组按某值的差值用冒泡排序算法进行排序

/* * 冒泡排序 */public class BubbleSort {public static void main(String[] args) {int[] arr={6,3,8,2,9,1};System.out.println("排序前数组为：");for(int num:arr){System.out.print(num+" ");}for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次if(arr[j]>arr[j+1]){int temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}}} System.out.println();System.out.println("排序后的数组为："); for(int num:arr){ System.out.print(num+" "); } } }

❾ 关于数组排序

“而实际的运算速度，冒泡比擂台要快”
不知道这个结论你是怎么得出来的？

我的结论是：
1. 看if那句比较的次数。
对于擂台法：外循环n-1次，每次进行内循环分别为n-1,n-2,……1，所以一共做的比较次数n(n-1)/2
对于冒泡法：外循环n-1次，每次进行内循环分别为n-1,n-2,……1，所以一共做的比较次数n(n-1)/2
所以对于比较的次数来讲，他们是一样的

2. 交换元素的次数，这个和被排序的数组有关，所以要算平均情况。我写了个程序尝试了由0到9这9个数字组成的长为5的所有数组（这种数组共有10的5次方个），分别让这两种算法对每一种情况进行排序，结果对于这10万个数组，擂台法共交换元素407205次，冒泡法共交换元素450000次，所以前者更快。

排序算法中，平均情况下应该是快速排序比较好吧，虽然最坏情况下他会达到O(n^2)，另外归并排序，堆排序，希尔排序，都是可以达到O(nlogn)的效率的，空间复杂度不记得了。。。