數組排序演算法

❶ 排序演算法：有規律的數組排序

這個「規律」具體是什麼呢？我可以歸納出三種：

• 奇數項和偶數項各自都是有序的整數；

• 奇數項和偶數項各自都是有序的連續整數；

• 奇數項和偶數項各自都是有序的連續整數，且奇數項全部小於偶數項；

哪個是題主所說的「規律」？

❷ 用快速排序演算法，對下列數組排序

#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)的效率的，空間復雜度不記得了。。。