演算法數組排序

① 用「自然排序」演算法對數組排序

natsort
(PHP 4, PHP 5, PHP 7)
natsort — 用「自然排序」演算法對數組排序
說明
natsort ( array &$array ) : bool
本函數實現了一個和人們通常對字母數字字元串進行排序的方法一樣的排序演算法並保持原有鍵／值的關聯，這被稱為「自然排序」。本演算法和通常的計算機字元串排序演算法（用於 sort()）的區別見下面示例。
注意:
如果兩個成員完全相同，那麼它們在排序數組中的相對順序是未定義的。
參數
array
輸入的 array。
返回值
成功時返回 true， 或者在失敗時返回 false。
更新日誌
版本 說明
5.2.10 用零填充的數字字元串 (例如 '00005')現在本質上會忽略掉填充的前道零。
範例
示例 #1 natsort() 基本用法的操作示例

② 數組的排序演算法有哪些如何實現

c#冒泡演算法：

using System;
using System.Diagnostics;

namespace 經典演算法之冒泡排序
{
class Program
{
static void Main()
{
/* 冒泡排序網路:
* http://ke..com/view/254413.htm
* 核心是通過雙重循環將數組較小數往前移動,較大數往後移動
* 還可通過標識符(flag)來判斷本趟循環是否進行交換，
* 若一趟循環中一次交換都不發生，那麼說明已經排序完畢，
* 可以就此結束排序，加快排序的總體時間 */

/* 使用隨機數類生成一個隨機數列
* 特別注意：聲明並實例化一個類是需要消耗一定時間的，
* 盡量不要將類的實例化放在一個循環中生成，
* 這將導致程序運行非常緩慢 */

Random rand = new Random(); // 聲明並實例化一個隨機數類
int[] intArray = new int[100000]; // 初始化一個數組
int maxIndex = intArray.Length - 1; // 初始化最大索引變數

Console.WriteLine("冒泡排序前的數組：");

// 生成一個隨機數列
for (int i = 0; i <= maxIndex; i++) {
intArray[i] = rand.Next(1000);
Console.Write("{0}\t", intArray[i]);
}

Console.WriteLine();

// 開始進行冒泡排序
Stopwatch stw = new Stopwatch(); // 聲明並實例化停止監視類
stw.Start(); // 開始監視

bool isExchange = false; // 聲明交換標識符，表示本趟排序是否進行交換

for (int i = 0; i < maxIndex; i++) {
isExchange = false; // 重置交換標識符狀態

for (int j = maxIndex; j > i; j--) {

// 比較前後兩數大小
if (intArray[j] > intArray[j - 1]) {
// 後數大於前數，進行交換
int temp = intArray[j];
intArray[j] = intArray[j - 1];
intArray[j - 1] = temp;
isExchange = true; // 修改交換標識符為真
}
}

//continue;

// 根據交換標識符判斷本趟是否進行了交換
if (!isExchange) {
// 本趟沒有進行交換
break;
}

}

stw.Stop(); // 停止監視

// 輸出排序後的數組
Console.WriteLine("冒泡排序後的數組：");

foreach (int element in intArray) {
Console.Write("{0}\t", element);
}

Console.Write("排序消耗時間：" + stw.Elapsed.Milliseconds.ToString());
Console.ReadKey();
}
}
}

③ java數組排序 幾種排序方法詳細一點

JAVA中在運用數組進行排序功能時，一般有四種方法：快速排序法、冒泡法、選擇排序法、插入排序法。

快速排序法主要是運用了Arrays中的一個方法Arrays.sort（）實現。

冒泡法是運用遍歷數組進行比較，通過不斷的比較將最小值或者最大值一個一個的遍歷出來。

選擇排序法是將數組的第一個數據作為最大或者最小的值，然後通過比較循環，輸出有序的數組。

插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。下面我就將他們的實現方法一一詳解供大家參考。

<1>利用Arrays帶有的排序方法快速排序

publicclassTest2{
publicstaticvoidmain(String[]args){
int[]a={5,4,2,4,9,1};
Arrays.sort(a);//進行排序
for(inti:a){
System.out.print(i);
}
}
}

<2>冒泡排序演算法

publicstaticint[]bubbleSort(int[]args){//冒泡排序演算法
for(inti=0;i<args.length-1;i++){
for(intj=i+1;j<args.length;j++){
if(args[i]>args[j]){
inttemp=args[i];
args[i]=args[j];
args[j]=temp;
}
}
}
returnargs;
}

<3>選擇排序演算法

publicstaticint[]selectSort(int[]args){//選擇排序演算法
for(inti=0;i<args.length-1;i++){
intmin=i;
for(intj=i+1;j<args.length;j++){
if(args[min]>args[j]){
min=j;
}
}
if(min!=i){
inttemp=args[i];
args[i]=args[min];
args[min]=temp;
}
}
returnargs;
}

<4>插入排序演算法

publicstaticint[]insertSort(int[]args){//插入排序演算法
for(inti=1;i<args.length;i++){
for(intj=i;j>0;j--){
if(args[j]<args[j-1]){
inttemp=args[j-1];
args[j-1]=args[j];
args[j]=temp;
}elsebreak;
}
}
returnargs;
}

④ 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;
};

⑤ 求C語言將數組元素大小排序！！

C語言將數組元素大小排序方法：

以下使用的是冒泡排序法實線數組從小到大排序。

思想：每次相鄰兩個數比較，若升序，則將大的數放到後面，一次循環過後，就會將最大的數放在最後。

10、2、3、4、5、6、9、8、7、1是輸入的待排序的數列，經過第一次排序，將最大的,10放在最後，第二次排序，將剩下的2、3、4、5、6、9、8、7、1進行冒泡，將當前最大的9放在倒數第二的位置，以此類推。

以下是具體代碼：

#include <stdio.h>

int main(){

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

int i, j, temp, isSorted;

//優化演算法：最多進行 n-1 輪比較

for(i=0; i<10-1; i++){

isSorted = 1; //假設剩下的元素已經排序好了

for(j=0; j<10-1-i; j++){

if(nums[j] > nums[j+1]){

temp = nums[j];

nums[j] = nums[j+1];

nums[j+1] = temp;

isSorted = 0; //一旦需要交換數組元素，就說明剩下的元素沒有排序好

}

}

if(isSorted) break; //如果沒有發生交換，說明剩下的元素已經排序好了

}

for(i=0; i<10; i++){

printf("%d ", nums[i]);

}

printf(" ");

return 0;

}

(5)演算法數組排序擴展閱讀：

其他將數組從小到大排序的演算法

以下使用的是選擇排序法實現數組從小到大排序。

思想：從第一個數開始，每次和後面剩餘的數進行比較，若升序，則如果後邊的數比當前數字小，進行交換，和後面的所有的數比較、交換後，就會將當前的最小值放在當前的位置

輸入的序列為10、2、3、4、5、6、9、8、7、1進行一次排序後將最小的數放在了第一位(a[0]與它後面的所有數進行比較，若a[0]比後面的數大，進行交換)，以此類推。

以下是具體代碼：

#include <stdio.h>

int main(void){

int a[1001];

int n,i,j,t;

scanf("%d",&n);//n為要排序的數的個數

//輸入需要排序的數

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

scanf("%d",a+i);

//接下來進行排序

for(i=0;i<n-1;++i)//因為每次需要和a[i]後面的數進行比較,所以到a[n-2](倒數第2個元素)就行

{

for(j=i+1;j<n;++j)//j從i後一個開始,a[i]與a[j]進行比較

{

if(a[i]>a[j])//a[i]為當前值,若是比後面的a[j]大,進行交換

{

t=a[i];

a[i]=a[j];

a[j]=t;

}

}//每排序一次,就會將a[i](包括a[i])之後的最小值放在a[i]的位置

for(j=0;j<n;++j)

printf("%-5d",a[j]);

printf(" ");

}

return 0;

}

⑥ 數組排序是什麼

是將一個雜亂無章的數組進行一個快速排序，可以先從一個數組中取一個中間值。

排序演算法，通過特定的演算法因式將一組或多組數據按照既定模式進行重新排序。這種新序列遵循著一定的規則，體現出一定的規律，對於排序，我要求其具有一定的穩定性，即當兩個相同的元素同時出現於某個序列之中，則經過一定的排序演算法之後，兩者在排序前後的相對位置不發生變化。

常見的排序演算法：

1、選擇排序，選擇排序的基本思想是，基於直接選擇排序和堆排序這兩種基本的簡單排序方法。首先從第1個位置開始對全部元素進行選擇，選出全部元素中最小的給該位置，再對第2個位置進行選擇，在剩餘元素中選擇最小的給該位置。

2、快速排序，通過一趟排序演算法把所需要排序的序列的元素分割成兩大塊，其中，一部分的元素都要小於或等於另外一部分的序列元素，然後仍根據該種方法對劃分後的這兩塊序列的元素分別再次實行快速排序演算法，排序實現的整個過程可以是遞歸的來進行調用。

3、插入排序，通過一次插入一個元素的方式按照原有排序方式增加元素。這種比較是從該有序序列的最末端開始執行，即要插入序列中的元素最先和有序序列中最大的元素比較，若其大於該最大元素，則可直接插入最大元素的後面即可，否則再向前一位比較查找直至找到應該插入的位置為止。

⑦ java怎麼讓數組的數字從大到小排序

將數字從大到小排序的方法：

例如簡一點的冒泡排序，將第一個數字和後面的數字逐個比較大小，如果小於，則互換位置，大於則不動。此時，第一個數為數組中的最大數。然後再將第二個數與後面的數逐個比較，以次類推。

示例代碼如下：
publicclassTest{

publicstaticvoidmain(String[]args){
int[]array={12,3,1254,235,435,236,25,34,23};
inttemp;
for(inti=0;i<array.length;i++){
for(intj=i+1;j<array.length;j++){
if(array[i]<array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp; //兩個數交換位置
}
}
}
for(inti=0;i<array.length;i++){
System.out.print(array[i]+"");
}
}
}

數組對於每一門編程語言來說都是重要的數據結構之一，當然不同語言對數組的實現及處理也不盡相同。

Java 語言中提供的數組是用來存儲固定大小的同類型元素。

你可以聲明一個數組變數，如 numbers[100] 來代替直接聲明 100 個獨立變數 number0，number1，....，number99

(7)演算法數組排序擴展閱讀

Java中利用數組進行數字排序一般有4種方法：

1、選擇排序是先將數組中的第一個數作為最大或最小數，然後通過循環比較交換最大數或最小數與一輪比較中第一個數位置進行排序。

2、冒泡排序也是先將數組中的第一個數作為最大或最小數，循環比較相鄰兩個數的大小，滿足條件就互換位置，將最大數或最小數沉底。

3、快速排序法主要是運用Arrays類中的Arrays.sort方法（）實現。

4、插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。

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

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

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

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

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

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