PHP常用排序算法实例小结【基本排序，冒泡排序，快速排序，插入排序】
13
如果您对PHP常用排序算法实例小结【基本排序，冒泡排序，快速排序，插入排序】感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于PHP常用排序算法实例小结【基本排序，冒泡排序，快
如果您对PHP常用排序算法实例小结【基本排序，冒泡排序，快速排序，插入排序】 感兴趣，那么本文将是一篇不错的选择，我们将为您详在本文中，您将会了解到关于PHP常用排序算法实例小结【基本排序，冒泡排序，快速排序，插入排序】 的详细内容，并且为您提供关于C语言排序算法之简单交换法排序，直接选择排序，冒泡排序、java-排序算法实现：冒泡排序，选择排序，插入排序、Java中选择排序，冒泡排序，插入排序，快速排序、JAVA实现选择排序，插入排序，冒泡排序，以及两个有序数组的合并 的有价值信息。
本文目录一览：
PHP常用排序算法实例小结【基本排序，冒泡排序，快速排序，插入排序】 PHP三种基础算法：冒泡，插入和快速排序法
rush:PHP;">
$array = array(2,3,5,6,9,8,1);
//冒泡排序思想，前后元素比较
//插入排序思想，就是从第二个元素开始，到最后一个元素都是这个需要排序的元素
//快速排序，找一个基准点把数组分成两组比较
本文实例总结了PHP常用排序算法。分享给大家供大家参考，具体如下：
protected = 'change private';
}
public function setValue($a){
self::$static = $a;
}
public function getValue(){
echo $this->private;
}
function __destruct(){
echo 'asdfsadf';
}
}
class paixu {
// 基本排序
public function t_sortArray($array) {
if(is_array($array) && count($array)>1) {
for($i=0; $i$v) {
if($key>0) {
if($array[$key-1]>$array[$key]) {
$array[$key] = $array[$key-1];
$array[$key-1] = $v;
$status = true;
}
}
}
if($status) {
return $this->c_sortArray($array);
} else {
return $array;
}
}
// 快速排序
public function v_sortArray($array) {
if(!is_array($array) || count($array)<=1){ return $array; }
if(count($array)>2) {
$m = $array[floor(count($array)/2)+1];
} else {
if($array[0]>$array[1]) {
$temp = $array[0];
$array[0] = $array[1];
$array[1] = $temp;
}
return $array;
}
$leftarray = array();
$rightarray = array();
foreach($array as $key=>$v) {
if($v>$m) {
$rightarray[] = $v;
}
if($v<$m) {
$leftarray[] = $v;
}
if($v==$m) {
$mid[] = $v;
}
}
$nleftarray = $this->v_sortArray($leftarray);
$nrightarray = $this->v_sortArray($rightarray);
return array_merge($nleftarray,$mid,$nrightarray);
}
// 直接插入排序
public function i_sortArray($array) {
if(!is_array($array) || count($array)<=1){ return $array; }
$newarray = array($array[0]);
$temp = 0;
foreach($array as $k=>$v) {
if($k>0) {
if($v>=$newarray[count($newarray)-1]) {
$newarray[] = $v;
} else {
foreach($newarray as $nk=>$nv) {
if($v<$nv) {
$temparray = array();
foreach($newarray as $ck=>$cv) {
if($ck<$nk) {
$temparray[$ck] = $cv;
} elseif($ck==$nk) {
$temparray[$ck] = $v;
$temparray[($ck+1)] = $cv;
} else {
$temparray[($ck+1)] = $cv;
}
}
$newarray = $temparray;
break;
}
}
}
}
}
return $newarray;
}
}
$bevin = new paixu;
$array = array(5,4,5);
$v = $bevin->t_sortArray($array);
print_r($v);
$v = $bevin->c_sortArray($array);
print_r($v);
$v = $bevin->v_sortArray($array);
print_r($v);
$v = $bevin->i_sortArray($array);
print_r($v);
运行结果：
4
[1] => 4
[2] => 4
[3] => 5
[4] => 5
[5] => 5
[6] => 5
[7] => 5
[8] => 5
[9] => 5
)
Array
(
[0] => 4
[1] => 4
[2] => 4
[3] => 5
[4] => 5
[5] => 5
[6] => 5
[7] => 5
[8] => 5
[9] => 5
)
Array
(
[0] => 4
[1] => 4
[2] => 4
[3] => 5
[4] => 5
[5] => 5
[6] => 5
[7] => 5
[8] => 5
[9] => 5
)
Array
(
[0] => 4
[1] => 4
[2] => 4
[3] => 5
[4] => 5
[5] => 5
[6] => 5
[7] => 5
[8] => 5
[9] => 5
)
更多关于PHP相关内容感兴趣的读者可查看本站专题：《》、《》、《》、《》、《》、《》、《》及《》
希望本文所述对大家PHP程序设计有所帮助。
C语言排序算法之简单交换法排序，直接选择排序，冒泡排序 C语言排序算法之简单交换法排序，直接选择排序，冒泡排序，最近考试要用到，网上也有很多例子，我觉得还是自己写的看得懂一些。
简单交换法排序
1 /*简单交换法 排序
2 根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置
3 交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动
4 不稳定
5 */
6 #include<windows.h>
7 #include<stdio.h>
8 void main(){
9 int i,j,arr[10 ]={20 ,36 ,58 ,23 ,10 ,9 ,14 ,99 ,3 ,66 },t;
10 int size = sizeof (arr)/sizeof (int );// 计算数组的大小
11 for (i = 0 ;i< size-1 ;i++){// n个数进行n-1轮比较
12 for (j = i+1 ;j< size;j++)// 每一轮比较时，后面的数与i为下标的数比较
13 if (arr[j]<arr[i]){// 如果i为下标的数比后面的一个数大，将两个数交换位置
14 t=arr[j];
15 arr[j]=arr[i];
16 arr[i]=t;
17 }
18 }
19
20 for (i = 0 ;i< size;i++){// 输出
21 printf(" %d " ,arr[i]);
22 }
23
24 system(" pause " );
25 }
直接选择排序
1 /* 选择排序
2 每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
3 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）
4 */
5 #include<windows.h>
6 #include<stdio.h>
7 void main(){
8 int min,i,j,arr[10 ]={20 ,36 ,58 ,23 ,10 ,9 ,14 ,99 ,3 ,66 },t;
9 int size = sizeof (arr)/sizeof (int );// 计算数组的大小
10 for (i = 0 ; i< size-1 ;i++){// n个数进行n-1轮比较
11 min = i;// 每一轮假定i为下标的这个数为最小值，记录下标
12 for (j = i+1 ;j < size;j++)// 每一轮比较时，后面的数与min为下标的数比较
13 if (arr[j]<arr[min]) min = j;// 后面的数比min为下标的数小，更换min
14 if (min != i){// 如果min的值发生了变化即当前下标为i的数不是最小值，交换
15 t = arr[i];
16 arr[i]=arr[min];
17 arr[min] = t;
18 }
19 }
20
21 for (i = 0 ;i< size;i++){// 输出
22 printf(" %d " ,arr[i]);
23 }
24
25 system(" pause " );
26
27 }
冒泡排序
/* 冒泡排序
重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成
*/
#include <windows.h>
#include <stdio.h>
void main(){
int min,i,j,arr[10 ]={20 ,36 ,58 ,23 ,10 ,9 ,14 ,99 ,3 ,66 },t,noswap;
int size = sizeof (arr)/sizeof (int );// 计算数组的大小
for (i = 0 ; i< size-1 ;i++){// n个数进行n-1轮比较
noswap = 1 ;// 标记是否发生交换，以避免对已经有序的序列再排序
for (j = 0 ;j<size-1 -i;j++){
if (arr[j]>arr[j+1 ]){// 如果前一个数比后一个数大，交换
t=arr[j];
arr[j] =arr[j+1 ];
arr[j +1 ]=t;
noswap = 0 ;// 发生了交换
}
}
if (noswap) break ; // 没有发生交换，说明已经有序，无需再排序，退出循环
}
for (i = 0 ;i< size;i++){// 输出
printf(" %d " ,arr[i]);
}
system( " pause " );
}
java-排序算法实现：冒泡排序，选择排序，插入排序
冒泡排序
原理：
从第一个数据开始，与第二个数据相比较，如果第二个数据小于第一个数据，则交换两个数据的位置。
指针由第一个数据移向第二个数据，第二个数据与第三个数据相比较，如果第三个数据小于第二个数据，则交换两个数据的位置。
依此类推，完成第一轮排序。第一轮排序结束后，最大的元素被移到了最右面。
依照上面的过程进行第二轮排序，将第二大的排在倒数第二的位置。
重复上述过程，没排完一轮，比较次数就减少一次。
例子：
待排序数据：7, 6, 9, 8, 5,1
第一轮排序过程：指针先指向7，7和6比较，6<7，交换6和7的位置，结果为：6,7,9,8,5,1
指针指向第二个元素7，7和9比较，9>7，不用交换位置，结果仍为：6,7,9,8,5,1
指针指向第三个元素9，比较9和8，8<9，交换8和9的位置，结果为：6,7,8,9,5,1
指针指向第四个元素9，比较9和5，5<9，交换5和9，结果为：6,7,8,5,9,1
指针指向第五个元素9，比较9和1，1<9，交换1和9的位置，结果为6,7,8,5,1,9
第一轮排序结束后，最大的数字9被移到了最右边。
进行第二轮排序，过程同上，只是由于最大的9已经放在最右边了，因此不用在比较9了，少了一次比较，第二轮结束的结果为：6,7,5,1,8,9
第三轮结果：6,5,1,7,8,9
第四轮比较结果：5,1,6,7,8,9
第五轮比较结果：1,5,6,7,8,9
最终排序结果为：1,5,6,7,8,9，由上可知N个数据排序，需要进行N-1轮排序；第i轮排序需要的比较次数为N-i次。
思路：需要两层循环，第一层循环i表示排序的轮数，第二层循环j表示比较的次数。
实现：
import java.util.Arrays;
public class TestBubbleSort1 {
//冒泡排序
public static void main(String[] args) {
//定义数组
int[] arr = {7, 6, 9, 8, 5, 1};
//排序前的数组
System.out.print("排序前的数组：");
System.out.println(Arrays.toString(arr));
//排序
//大循环。循环n-1次
boolean flag = true;
for (int i = 0; i < arr.length - 1; i++) {
//小循环,每次比较相邻的两个元素
for (int j = 0; j < arr.length - 1; j++) {
//如果前一个数大于第二个数
if (arr[j] > arr[j + 1]) {
int temp;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = false;
}
}
//判断是否有序
if (flag) {
break;
}
}
//排序后的数组
System.out.print("排序前的数组：");
System.out.println(Arrays.toString(arr));
}
}
总结： N个元素需要排序N-1轮；
第i轮需要比较N-i次；
N个元素排序，需要比较n（n-1）/2次；
冒泡排序的算法复杂度较高，为O（n*n）
图片
选择排序
原理
从第一个元素开始，分别与后面的元素向比较，找到最小的元素与第一个元素交换位置；
从第二个元素开始，分别与后面的元素相比较，找到剩余元素中最小的元素，与第二个元素交换；
重复上述步骤，直到所有的元素都排成由小到大为止。
例子
待比较数据：7, 6, 9, 8, 5,1
第一轮：此时指针指向第一个元素7，找出所有数据中最小的元素，即1，交换7和1的位置，排序后的数据为：1,6,9,8,5,7
第二轮：第一个元素已经为最小的元素，此时指针指向第二个元素6，找到6,9,8,5,7中最小的元素，即5，交换5和6的位置，排序后的结果为：1,5,9,8,6,7
第三轮：前两个元素为排好序的元素，此时指针指向第三个元素9，找到9,8,6,7中最小的元素，即6，交换6和9的位置，排序后的结果为：1,5,6,8,9,7
第四轮：前三个元素为排好序的元素，此时指针指向第四个元素8，找到8,9,7中最小的元素，即7，交换8和7的位置，排序后的结果为：1,5,6,7,9,8
第五轮：前四个元素为排好序的元素，此时指针指向第五个元素9，找到9,8中最小的元素，即8，交换9和8的位置，排序后的结果为：1,5,6,7,8,9
到此，全部排序完成。
分析：从上面的原理可以看出，与冒泡排序不同，选择排序每排完一轮都把最小的元素移到了最左面，然后下一轮排序的比较次数比上一轮减少一次，即第i轮排序需要比较N-i次。因此，和冒泡排序一样，N个数据比较大小，需要排序N-1轮，第i轮排序需要比较N-i次。
思路：需要两次循环，第一层循环i表示每轮指针指向的位置，将最小值min初始化为第i个元素，第二层循环从j=i+1开始，分别与min比较，如果小于min，则更新min的值，内层循环结束后；交换min元素和第i个元素的位置。以此类推进行下一轮循环，直到i=length时停止循环。当i=length时，说明小的元素已经全部移到了左面，因此无需进行内层循环了。
实现
import java.util.Arrays;
public class TestBubbleSort2 {
// 选择排序
public static void main(String[] args) {
// 定义数组
int [] arr = {7, 6, 9, 8, 5, 1};
// 排序前的数组
System.out.print("排序前的数组：");
System.out.println(Arrays.toString(arr));
// 排序
// 大循环。循环n-1次
for (int i = 0; i < arr.length-1; i++) {
// 假设第i个元素最小
int minIndex = i;
// i+1开始，依次用最小的比较
for (int j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) {
minIndex = j;
}
}
// 第一趟比较完，比较最小值索引是不是第i个
if (minIndex != i) {
int temp;
temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
}
// 排序后的数组
System.out.print("排序前的数组：");
System.out.println(Arrays.toString(arr));
}
}
总结 N个元素需要排序N-1轮；
第i轮需要比较N-i次；
N个元素排序，需要比较n（n-1）/2次；
选择排序的算法复杂度仍为O（n*n）；
相比于冒泡排序，选择排序的交换次数大大减少，因此速度要快于冒泡排序
图片
插入排序
原理：
将指针指向某个元素，假设该元素左侧的元素全部有序，将该元素抽取出来，然后按照从右往左的顺序分别与其左边的元素比较，遇到比其大的元素便将元素右移，直到找到比该元素小的元素或者找到最左面发现其左侧的元素都比它大，停止；
此时会出现一个空位，将该元素放入到空位中，此时该元素左侧的元素都比它小，右侧的元素都比它大；
指针向后移动一位，重复上述过程。每操作一轮，左侧有序元素都增加一个，右侧无序元素都减少一个。
例子： 待比较数据：7, 6, 9, 8, 5,1
第一轮：指针指向第二个元素6，假设6左面的元素为有序的，将6抽离出来，形成7,_,9,8,5,1，从7开始，6和7比较，发现7>6。将7右移，形成_,7,9,8,5,1，6插入到7前面的空位，结果：6,7,9,8,5,1
第二轮：指针指向第三个元素9，此时其左面的元素6,7为有序的，将9抽离出来，形成6,7,_,8,5,1，从7开始，依次与9比较，发现9左侧的元素都比9小，于是无需移动，把9放到空位中，结果仍为：6,7,9,8,5,1
第三轮：指针指向第四个元素8，此时其左面的元素6,7,9为有序的，将8抽离出来，形成6,7,9,_,5,1，从9开始，依次与8比较，发现8<9，将9向后移，形成6,7,_,9,5,1，8插入到空位中，结果为：6,7,8,9,5,1
第四轮：指针指向第五个元素5，此时其左面的元素6,7,8,9为有序的，将5抽离出来，形成6,7,8,9,_,1，从9开始依次与5比较，发现5比其左侧所有元素都小，5左侧元素全部向右移动，形成_,6,7,8,9,1，将5放入空位，结果5,6,7,8,9,1。
第五轮：同上，1被移到最左面，最后结果：1,5,6,7,8,9。
思路：需要两层循环，第一层循环index表示上述例子中的指针，即遍历从坐标为1开始的每一个元素；第二层循环从leftindex=index-1开始，leftindex--向左遍历，将每一个元素与i处的元素比较，直到j处的元素小于i出的元素或者leftindex<0；遍历从i到j的每一个元素使其右移，最后将index处的元素放到leftindex处的空位处。
实现
import java.util.Arrays;
public class TestInsertionSort {
//插入排序
public static void main(String[] args){
//定义数组
int[] arr = {7, 6, 9, 8, 5, 1};
//排序前的数组
System.out.print("排序前的数组：");
System.out.println(Arrays.toString(arr));
//排序
//大循环。循环n次
for (int i=0;i<arr.length;i++){
int temp=arr[i];
//用作比较的数据
int leftIndex=i-1;
while (leftIndex>=0&&arr[leftIndex]>temp){
//当比到最左边或者遇到比temp小的数据时，结束循环
arr[leftIndex+1]=arr[leftIndex];
leftIndex--;
}
arr[leftIndex+1]=temp;
//把temp放到空位上
}
//排序后的数组
System.out.print("排序前的数组：");
System.out.println(Arrays.toString(arr));
}
}
总结：时间复杂度，由于仍然需要两层循环，插入排序的时间复杂度仍然为O(n*n)。
图片
Java中选择排序，冒泡排序，插入排序，快速排序 一:冒泡法排序
//冒泡排序 注：从小到大排
这只是冒泡排序的一种，当然也可以从后往前排。
算法步骤
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
动画演示
参考代码
public static void bubbleSort(int array[]) {int t = 0;for (int i = 0; i < array.length - 1; i++)for (int j = 0; j < array.length - 1 - i; j++)if (array[j] > array[j + 1]) {
二:选择排序
//特点：效率低，容易实现。
算法步骤
动画演示
参考代码
public static void selectSort(int array[]) {int t = 0;for (int i = 0; i < array.length - 1; i++){int index=i;for (int j = i + 1; j < array.length; j++)if (array[index] > array[j])if (index!=i){ //找到了比array[i]小的则与array[i]交换位置
三:插入排序
算法步骤
动画演示
参考代码
public static void insertionSort(int array[]) {int i, j, t = 0;for (i = 1; i < array.length; i++) {if (array[i]<array[i-1]){for (j = i - 1; j >= 0 && t < array[j]; j--) //插入array[i]
四:快速排序
接下来对划分完的子序列进行快排直到子序列为一个元素为止。
算法步骤
从数列中挑出一个元素，称为 “基准”（pivot）;
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
动画演示
参考代码
public static void quickSort(int array[], int low, int high) {// 传入low=0，high=array.length-1; int pivot, p_pos, i, t;// pivot->位索引;p_pos->轴值。 if (low < high) {for (i = low + 1; i <= high; i++)if (array[i] < pivot) { // 分而治之 quickSort (array, low, p_pos - 1);// 排序左半部分 quickSort (array, p_pos + 1, high);// 排序右半部分
五:测试
package com.svse.paixu;import java.util.Arrays;public class JavaSort {
//打印方法
public static void print(int[] arr) {
System.out .print("[");for (int i = 0; i < arr.length; i++) {if (i == arr.length-1) {out .println(arr[i] + "]");else {out .print(arr[i] + ",");
public static void main(String[] args) {int[] array = { 37, 47, 23, 100, 19, 56, 56, 99, 9 };
print (array);//排序前 //冒泡排序 //选择排序 //插入排序 //快速排序 out .println("排序后： " + Arrays.toString(array));
print (array);//排序后
六:各种排序算法性能比较
JAVA实现选择排序，插入排序，冒泡排序，以及两个有序数组的合并 一直到大四才开始写自己的第一篇博客，说来实在有点羞愧。今天写了关于排序的算法题，有插入排序，冒泡排序，选择排序，以下贴上用JAVA实现的代码：
public class test5
{
public static void print(int []array) //输出数组方法
{
for(int i=0;i<array.length;i++)
System.out.print(" "+array[i]);
}
public static void selectsort(int array[]) //选择排序方法
{
for (int i = 0; i < array.length; i++)
{
int min=i;
for(int j=i+1;j<array.length;j++)
if(array[min]>array[j])
min =j;
if(i!=min)
{
int temp=array[i];
array[i]=array[min];
array[min]=temp;
}
}
}
public static void insertsort(int array[]) //插入排序方法
{
for (int i = 1; i < array.length; i++)
{
int a=array[i];
int j=i-1;
for(;j>=0;j--)
{
if(a<array[j])
array[j+1]=array[j];
else
break;
}
array[j+1]=a;
}
}
public static void bubblesort(int array[]) //冒泡排序
{
for(int i=0;i<array.length-1;i++)
{
for(int j=0;j<array.length-1-i;j++)
{
if(array[j]>array[j+1])
{
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
}
public static int[] merge(int a[],int b[]) //两个有序数组的合并
{
int c[]=new int[a.length+b.length];
int i=0,j=0,k=0;
while (i<a.length&&j<b.length)
{
if (a[i]>b[j])
c[k++]=b[j++];
else
c[k++]=a[i++];
}
while(i<a.length)
c[k++]=a[i++];
while(j<b.length)
c[k++]=b[j++];
return c;
}
public static void main(String[] args)
{
int a[]={55,76,29,80,92,41,16};
int b[]={73,10,84,99,69,45};
// System.out.println("hello" );
System.out.print("数组a：" );
print(a);
System.out.print(''\n'');
System.out.print("数组b：" );
print(b);
System.out.print(''\n'');
System.out.print("选择排序：" );
// selectsort(a);
print(a);
System.out.print(''\n'');
System.out.print("冒泡排序：" );
bubblesort(a);
print(a);
System.out.print(''\n'');
System.out.print("插入排序：" );
insertsort(b);
print(b);
System.out.print(''\n'');
System.out.print("合并数组：" );
print(merge(a, b));
}
}
运行后的结果如下图所示
今天的关于PHP常用排序算法实例小结【基本排序，冒泡排序，快速排序，插入排序】 的分享已经结束，谢谢您的关注，如果想了解更多关于C语言排序算法之简单交换法排序，直接选择排序，冒泡排序、java-排序算法实现：冒泡排序，选择排序，插入排序、Java中选择排序，冒泡排序，插入排序，快速排序、JAVA实现选择排序，插入排序，冒泡排序，以及两个有序数组的合并 的相关知识，请在本站进行查询。
