php四种基础算法：冒泡,选择,插入和快速排序法 PHP基础教程

php常见算法常见的php算法主要包括字符串处理、数组操作、排序算法和查找算法等。

下面将分别介绍这些算法的实现原理和应用场景。

一、字符串处理算法1. 字符串反转算法：将一个字符串倒序输出。

实现原理：使用循环遍历字符串，逐个将字符添加到一个新的字符串中，最后输出新字符串。

应用场景：密码加密、字符串匹配等。

2. 字符串查找算法：在一个字符串中查找指定的子串。

实现原理：使用循环遍历字符串，逐个比较子串和字符串中的字符，如果相等则返回匹配位置。

应用场景：文本搜索、关键字过滤等。

3. 字符串替换算法：将字符串中指定的字符或子串替换成新的字符或子串。

实现原理：使用str_replace函数或正则表达式实现替换操作。

应用场景：敏感词过滤、模板替换等。

二、数组操作算法1. 数组排序算法：对数组中的元素进行排序。

实现原理：使用内置的排序函数，如sort、asort、ksort等，或者使用冒泡排序、快速排序等自定义算法。

应用场景：对查询结果进行排序、数据分析等。

2. 数组去重算法：去除数组中重复的元素。

实现原理：使用array_unique函数或循环遍历数组，逐个比较元素并去重。

应用场景：数据去重、查找唯一元素等。

3. 数组合并算法：将多个数组合并成一个数组。

实现原理：使用array_merge函数或循环遍历数组，逐个将元素添加到新数组中。

应用场景：数据拼接、多个数组合并等。

三、排序算法1. 冒泡排序算法：对数组进行升序或降序排序。

实现原理：使用嵌套循环遍历数组，比较相邻元素并交换位置，直到完成排序。

应用场景：小规模数据的排序。

2. 快速排序算法：对数组进行升序或降序排序。

实现原理：选择一个基准元素，将小于基准的元素放在左边，大于基准的元素放在右边，递归地对左右两部分进行排序。

应用场景：大规模数据的排序。

3. 插入排序算法：对数组进行升序或降序排序。

实现原理：将数组分为已排序和未排序两部分，每次从未排序部分选择一个元素插入到已排序部分的正确位置。

学IT技能上我学院网
PHP冒泡、选择、插入、快速排序4种基础算法详解举例：分别用PHP中冒泡排序法，快速排序法，选择排序法，插入排序法将下面数组中的值按照从小到的顺序进行排序。

这里用4种算法来进行解析。

1. 冒泡排序法
思路分析：法如其名，就是像冒泡一样，每次从数组当中冒一个最大的数出来。

比如：
2,4,1 // 第一次冒出的泡是4
2,1,4 // 第二次冒出的泡是2
1,2,4 // 最后就变成这样
学IT技能上我学院网
2. 选择排序法：
选择排序法思路：每次选择一个相应的元素，然后将其放到指定的位置。

学IT技能上我学院网
学IT技能上我学院网
3.插入排序法
插入排序法思路：将要排序的元素插入到已经假定排序号的数组的指定位置。

学IT技能上我学院网
学IT技能上我学院网
4.快速排序法
学IT技能上我学院网
学IT技能上我学院网
PHP冒泡、选择、插入、快速排序4种基础算法详解到这里就结束了，欢迎大家关注我学院网微信公众号（woxueyuan_com），我们会在微信公众号上为大家推荐你喜欢的视频教程。

数组创建数组的方式一：在PHP中，数组的元素存放的值可以是任何类型的数据创建数组的方式二：$arr[null] = "youlove";echo $arr[null]."<br/>";//可以打印出youlove echo $arr[""];//可以打印出youlove在PHP中null等价于""访问数组的时候不可以越界，即下标不可以使用数组中不存在的在PHP中数组可以动态添加的举例：$a = array(5,9);$a[2] = 89;echo $a[2];注：进行动态添加数组的时候也可以跳过key,比如上面的例子可以改写这样$a = array(5,9);$a[3] = 89;echo $a[3];也是对的（这相当于key 2没有用）。

索引即数组中的关键字不会重建一维数组小结：例子(冒泡排序)：$arr = array (11,0,-100,82,22,-1,77,66); //小——> 大for($i=0; $i<count($arr)-1; $i++)//整个数组的大循环{for($j=0; $j<count($arr)-1-$i; $j++)//在每一次大循环中的进行的小循环{$change = 0;if($arr[$j]>$arr[$j+1])//如果前面一个数组元素大于后面一个数组元素，则执行元素交换代码{$change = $arr[$j];$arr[$j] =$arr[$j+1];$arr[$j+1] = $change;}}}print_r($arr);输出结果：Array ( [0] => -100 [1] => -1 [2] => 0 [3] => 11 [4] => 22 [5] => 66 [6] => 77 [7] => 82 )以上代码使用函数是这样的【注释：变化的代码是红色部分】：$myarr = array (11,0,-100,82,22,-1,77,66);function bubblesort($arr){for($i=0; $i<count($arr)-1; $i++){for($j=0; $j<count($arr)-1-$i; $j++){$change = 0;if($arr[$j]>$arr[$j+1]){$change = $arr[$j];$arr[$j] =$arr[$j+1];$arr[$j+1] = $change;}}}return $arr;}$myarr = bubblesort($myarr);print_r($myarr);或者也可以这样改（推荐使用）：$myarr = array (11,0,-100,82,22,-1,77,66); //小——> 大function bubblesort(&$arr)//加上地址符就可以实现{for($i=0; $i<count($arr)-1; $i++){for($j=0; $j<count($arr)-1-$i; $j++){$change = 0;if($arr[$j]>$arr[$j+1]){$change = $arr[$j];$arr[$j] =$arr[$j+1];$arr[$j+1] = $change;}}}}bubblesort($myarr);//函数调用print_r($myarr);从上面的代码可以看出，在调用函数的时候，默认的是值传递。

以下是使用PHP 实现的9个经典的排序算法：1. 冒泡排序```function bubble_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}for ($i = 0; $i < $n; $i++) {for ($j = 0; $j < $n - $i - 1; $j++) {if ($arr[$j] > $arr[$j+1]) {$temp = $arr[$j+1];$arr[$j+1] = $arr[$j];$arr[$j] = $temp;}}}return $arr;}```2. 选择排序```function selection_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}for ($i = 0; $i < $n; $i++) {$minIndex = $i;for ($j = $i+1; $j < $n; $j++) {if ($arr[$j] < $arr[$minIndex]) {$minIndex = $j;}}$temp = $arr[$i];$arr[$i] = $arr[$minIndex];$arr[$minIndex] = $temp;}return $arr;}```3. 插入排序```function insertion_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}for ($i = 1; $i < $n; $i++) {$value = $arr[$i];$j = $i - 1;for (; $j >= 0; $j--) {if ($arr[$j] > $value) {$arr[$j+1] = $arr[$j];} else {break;}}$arr[$j+1] = $value;}return $arr;}```4. 快速排序```function quick_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$pivotIndex = floor($n/2);$pivot = $arr[$pivotIndex];$left = array();$right = array();for ($i = 0; $i < $n; $i++) {if ($i == $pivotIndex) {continue;} else if ($arr[$i] < $pivot) {$left[] = $arr[$i];} else {$right[] = $arr[$i];}}return array_merge(quick_sort($left), array($pivot), quick_sort($right));}```5. 归并排序```function merge_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$mid = floor($n/2);$left = array_slice($arr, 0, $mid);$right = array_slice($arr, $mid);$left = merge_sort($left);$right = merge_sort($right);$newArr = array();while (count($left) && count($right)) {$newArr[] = $left[0] < $right[0] ? array_shift($left) : array_shift($right);}return array_merge($newArr, $left, $right);}```6. 堆排序```function heap_sort(&$arr) {$n = count($arr);if ($n <= 1) {return;}build_heap($arr);for ($i = $n-1; $i > 0; $i--) {$temp = $arr[0];$arr[0] = $arr[$i];$arr[$i] = $temp;heapify($arr, 0, $i);}}function build_heap(&$arr) {$n = count($arr);for ($i = floor($n/2)-1; $i >= 0; $i--) {heapify($arr, $i, $n);}}function heapify(&$arr, $i, $n) {$left = 2*$i+1;$right = 2*$i+2;$largest = $i;if ($left < $n && $arr[$left] > $arr[$largest]) {$largest = $left;}if ($right < $n && $arr[$right] > $arr[$largest]) {$largest = $right;}if ($largest != $i) {$temp = $arr[$i];$arr[$i] = $arr[$largest];$arr[$largest] = $temp;heapify($arr, $largest, $n);}}```7. 希尔排序```function shell_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$gap = floor($n/2);while ($gap > 0) {for ($i = $gap; $i < $n; $i++) {$temp = $arr[$i];for ($j = $i-$gap; $j >= 0 && $arr[$j] > $temp; $j -= $gap) {$arr[$j+$gap] = $arr[$j];}$arr[$j+$gap] = $temp;}$gap = floor($gap/2);}return $arr;}```8. 计数排序```function counting_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$maxVal = max($arr);$countArr = array_fill(0, $maxVal+1, 0);for ($i = 0; $i < $n; $i++) {$countArr[$arr[$i]]++;}for ($i = 1; $i < $maxVal+1; $i++) {$countArr[$i] += $countArr[$i-1];}$tmpArr = array();for ($i = $n-1; $i >= 0; $i--) {$tmpArr[$countArr[$arr[$i]]-1] = $arr[$i];$countArr[$arr[$i]]--;}for ($i = 0; $i < $n; $i++) {$arr[$i] = $tmpArr[$i];}return $arr;}```9. 桶排序```function bucket_sort($arr) {$n = count($arr);if ($n <= 1) {return $arr;}$maxVal = max($arr);$bucketSize = 10;$bucketCount = floor($maxVal / $bucketSize) + 1;$buckets = array();for ($i = 0; $i < $bucketCount; $i++) {$buckets[$i] = array();}for ($i = 0; $i < $n; $i++) {$index = floor($arr[$i] / $bucketSize);array_push($buckets[$index], $arr[$i]);}$newArr = array();for ($i = 0; $i < $bucketCount; $i++) {$bucketArr = $buckets[$i];$len = count($bucketArr);if ($len > 1) {sort($bucketArr);}for ($j = 0; $j < $len; $j++) {array_push($newArr, $bucketArr[$j]);}}return $newArr;}```以上就是使用PHP 实现的9个经典的排序算法。

php二维数组排序方法篇一：php多维数组排序php多维数组排序usort―采用用户自定义的比较函数对数组中的值展开排序说明boolusort(array&$array,callback$cmp_function)本函数将用用户自定义的比较函数对一个数组中的值进行排序。

如果要排序的数组需要用一种不寻常的标准进行排序，那么应该使用此函数。

比较函数必须在第一个参数被指出大于，等同于或大于第二个参数时分别回到一个大于，等同于或大于零的整数。

注意:如果两个成员比较结果相同，则它们在排序后的数组中的顺序未经定义。

到php4.0.6之前，用户自定义函数将保留这些单元的原有顺序。

但是由于在4.1.0中引进了新的排序算法，结果将不是这样了，因为对此没有一个有效的解决方案。

特别注意:本函数为array中的单元剥夺代莱键名。

这将删掉旧有的键名而不仅就是再次排序。

如果成功则返回true，失败则返回false。

采用多维数组的usort()例子java代码1.<?php2.functioncmp($a,$b)3.{4.returnstrcmp($a["fruit"],$b["fruit"]);5.}6.7.$fruits[0]["fruit"]="lemons";8.$fruits[1]["fruit"]="apples";9.$fruits[2]["fruit"]="grapes";10.ort($fruits,"cmp");12.13.while(list($key,$value)=each($fruits)){14.echo"/$fruits[$key]:".$value["fruit"]."/n";15.}16.?>[java]viewplaincopyprint?1.<?php2.functioncmp($a,$b)3.{4.returnstrcmp($a["fruit"],$b["fruit"]);5.}6.7.$fruits[0]["fruit"]="lemons";8.$fruits[1]["fruit"]="apples";9.$fruits[2]["fruit"]="grapes";10.ort($fruits,"cmp");12.13.while(list($key,$value)=each($fruits)){14.echo"/$fruits[$key]:".$value["fruit"]."/n";15.}16.?>当排序多维数组时，$a和$b包含到数组第一个索引的引用。

php经典算法1.冒泡算法,排序算法，由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序$array = array(a,f,c,b,e,h,j,i,g);function maopao_fun($array){if($len <= 1) {return $arr;}$count = count($array);for($i=0;$i<$count;$i++){for($j=$count-1;$j>$i;$j--){if($array[$j] > $array[$j-1]){$tmp = $array[$j];$array[$j] = $array[$j-1];$array[$j-1] = $tmp;}}}return $array;}2.快速排序,快速排序（Quicksort）是对冒泡排序的一种改进。

由C. A. R. Hoare在1962年提出。

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

function quickSort($arr){$len = count($arr);if($len <= 1) {return $arr;}$key = $arr[0];$left_arr = array();$right_arr = array();if($arr[$i] <= $key){$left_arr[] = $arr[$i];} else {$right_arr[] = $arr[$i];}}$left_arr = quickSort($left_arr);$right_arr = quickSort($right_arr);return array_merge($left_arr, array($key), $right_arr);}3.选择排序每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

链表排序（冒泡、选择、插⼊、快排、归并、希尔、堆排序）这篇⽂章分析⼀下链表的各种排序⽅法。

以下排序算法的正确性都可以在LeetCode的这⼀题检测。

本⽂⽤到的链表结构如下（排序算法都是传⼊链表头指针作为参数，返回排序后的头指针）struct ListNode {int val;ListNode *next;ListNode(int x) : val(x), next(NULL) {}};插⼊排序（算法中是直接交换节点，时间复杂度O（n^2）,空间复杂度O（1））class Solution {public:ListNode *insertionSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.if(head == NULL || head->next == NULL)return head;ListNode *p = head->next, *pstart = new ListNode(0), *pend = head;pstart->next = head; //为了操作⽅便，添加⼀个头结点while(p != NULL){ListNode *tmp = pstart->next, *pre = pstart;while(tmp != p && p->val >= tmp->val) //找到插⼊位置{tmp = tmp->next; pre = pre->next;}if(tmp == p)pend = p;else{pend->next = p->next;p->next = tmp;pre->next = p;}p = pend->next;}head = pstart->next;delete pstart;return head;}};选择排序（算法中只是交换节点的val值，时间复杂度O（n^2）,空间复杂度O（1））class Solution {public:ListNode *selectSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.//选择排序if(head == NULL || head->next == NULL)return head;ListNode *pstart = new ListNode(0);pstart->next = head; //为了操作⽅便，添加⼀个头结点ListNode*sortedTail = pstart;//指向已排好序的部分的尾部while(sortedTail->next != NULL){ListNode*minNode = sortedTail->next, *p = sortedTail->next->next;//寻找未排序部分的最⼩节点while(p != NULL){if(p->val < minNode->val)minNode = p;p = p->next;}swap(minNode->val, sortedTail->next->val);sortedTail = sortedTail->next;}head = pstart->next;delete pstart;return head;}};快速排序1（算法只交换节点的val值，平均时间复杂度O（nlogn）,不考虑递归栈空间的话空间复杂度是O（1））这⾥的partition我们参考(选取第⼀个元素作为枢纽元的版本，因为链表选择最后⼀元素需要遍历⼀遍)，具体可以参考这⾥我们还需要注意的⼀点是数组的partition两个参数分别代表数组的起始位置，两边都是闭区间，这样在排序的主函数中：void quicksort(vector<int>&arr, int low, int high){if(low < high){int middle = mypartition(arr, low, high);quicksort(arr, low, middle-1);quicksort(arr, middle+1, high);}}对左边⼦数组排序时，⼦数组右边界是middle-1，如果链表也按这种两边都是闭区间的话，找到分割后枢纽元middle，找到middle-1还得再次遍历数组，因此链表的partition采⽤前闭后开的区间（这样排序主函数也需要前闭后开区间），这样就可以避免上述问题class Solution {public:ListNode *quickSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.//链表快速排序if(head == NULL || head->next == NULL)return head;qsortList(head, NULL);return head;}void qsortList(ListNode*head, ListNode*tail){//链表范围是[low, high)if(head != tail && head->next != tail){ListNode* mid = partitionList(head, tail);qsortList(head, mid);qsortList(mid->next, tail);}}ListNode* partitionList(ListNode*low, ListNode*high){//链表范围是[low, high)int key = low->val;ListNode* loc = low;for(ListNode*i = low->next; i != high; i = i->next)if(i->val < key){loc = loc->next;swap(i->val, loc->val);}swap(loc->val, low->val);return loc;}};快速排序2（算法交换链表节点，平均时间复杂度O（nlogn）,不考虑递归栈空间的话空间复杂度是O（1））这⾥的partition，我们选取第⼀个节点作为枢纽元，然后把⼩于枢纽的节点放到⼀个链中，把不⼩于枢纽的及节点放到另⼀个链中，最后把两条链以及枢纽连接成⼀条链。

PHP四种排序算法实现及效率分析【冒泡排序,插⼊排序,选择排序和快速排序】本⽂实例讲述了PHP四种排序算法实现及效率分析。

分享给⼤家供⼤家参考，具体如下：PHP的四种基本排序算法为：冒泡排序、插⼊排序、选择排序和快速排序。

下⾯是我整理出来的算法代码：1. 冒泡排序：思路：对数组进⾏多轮冒泡，每⼀轮对数组中的元素两两⽐较，调整位置，冒出⼀个最⼤的数来。

//简单版：function bubbleSort($arr){$n = count($arr);for($i=1;$i<$n;$i++) { //冒泡的轮数(最多$n-1轮)for($j=0;$j<$n-1;$j++) { //每⼀轮冒泡(两两⽐较，⼤者后移)if($arr[$j] > $arr[$j+1]) { //前者⼤于后者，交换位置$tmp = $arr[$j];$arr[$j] = $arr[$j+1];$arr[$j+1] = $tmp;}}}return $arr;}//改进版：function bubbleSort($arr){$n = count($arr);for($i=1;$i<$n;$i++) { //冒泡的轮数(最多$n-1轮)$flag = 0; //是否发⽣位置交换的标志for($j=0;$j<$n-$i;$j++) { //每⼀轮冒泡(两两⽐较，⼤者后移)if($arr[$j] > $arr[$j+1]) { //前者⼤于后者，交换位置$tmp = $arr[$j];$arr[$j] = $arr[$j+1];$arr[$j+1] = $tmp;$flag = 1;}}if($flag == 0) { //没有发⽣位置交换，排序已完成break;}}return $arr;}为了提⾼冒泡排序算法的效率，主要需要改进的地⽅有：（1）减少冒泡的轮数：当⼀轮冒泡排序中没有发⽣位置交换时表⽰数组已排好序了，应⽴即退出循环。

PHP冒泡排序、快速排序算法详细解释及原理PHP冒泡排序、快速排序算法详细解释及原理2010-12-14 18：11PHP冒泡排序算法，完美解释By Svein Joe 2009年7月18日php/**本示例文件可直接运行，如需要看结果请将其放在你的网站根目录下，并访问你的网站/BubbleSort.php*这是一个很常见的排序算法，它的名字叫冒泡排序，这是一种最简单的排序算法。

*本算法可对数字进行排序，也可以对字符串进行排序*看懂它的好处：你可以很牢固地掌握循环的用法。

*以"//"开头的行为注释行(不包括"//"之前的部分)，以"/*"开头，并以"*/"结尾的若干行也是注释，注释语句是不会被执行的。

**@param传入的参数为一个待排序的数组$str*@return返回参数为排序完成后的数组$str*/function BubbleSort($str)//定义一个名为BubbleSort的函数，它有一个参数叫$str,这个参数必须是一个数组，这个数组里包含需要排序的一系列字符。

{for($i=0；$i count($str)；$i++)//count($str)的功能为统计数组中的元素数量，并返回这个数量值//第一层循环，外层循环，由于冒泡排序的原理为，每次都找最小(或每次都找最大，本例是演示每次都找最小的情况)的那个字符，找出一个最小("大")的字符算一次循环{for($j=count($str)-2；$j=$i；$j--)//内层循环，本次循环控制找最小("大")数的操作，由于每次要找出最大的数，必须拿一个数和每一个数对比，所以也是一个内层的循环操作{if($str[$j+1]$str[$j])//比较，是$j+1位置的字符大，还是$j位置的字符比较大,如果$j位置的字符比较大，那么交换$str[$j+1]和$str[$j]以保证排列在前面的字符更小{$tmp=$str[$j+1]；//交换两个位置的东西，需要三个空位才能完成，就像交换一杯可乐和一杯牛奶需要另一个空杯子一样，$tmp可以说就是空杯子$str[$j+1]=$str[$j]；//类似，有一杯牛奶，一杯可乐，我们想用牛奶杯装可乐，可乐杯装牛奶的话，就得进行这样的操作…$str[$j]=$tmp；//整个交换的过程可以描述为：先将牛奶倒入空杯，再将可乐倒入牛奶杯，然后再将原来空杯里的牛奶倒入可乐杯}}//内层循环每执行一次，就会多找出一个"最小"的字符(除了前面循环中已经找过了的)}//数组里有N个字符的话，循环就重复N-1次，这样才能完成排序return$str；//将排序后的结果返回，返回后跳出函数体，$str变量在内存中消失，而BubbleSort($str)的值就是$str所返回的值}//函数体定义完成标志我们称之为end of function BubbleSort($str)$str=array(3,6,1,5,9,0,4,6,11)；//组出一个存放随机序列的若干数字的数组print_r(BubbleSort($str))；//调用函数体┃基本原理┃：两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。

php实现快速排序的三种方法php实现快速排序的三种方法三种php快速排示例，第一种效率低但最简单最容易理解，第二个是算法导论上提供的单向一次遍历找中值方法，第三种是双向遍历找中值经典快排算法。

下面是店铺为大家带来的php实现快速排序的三种方法，欢迎阅读。

方法一：该方法比较直观，但损失了大量的空间为代价，使用了效率较低的.merge函数。

在三种方法中效率最低。

最坏情况下算法退化为(O(n*n))代码如下:function quick_sort($array) {if(count($array) <= 1) return $array;$key = $array[0];$rightArray = array();$leftArray = array();for($i = 1; $i < count($array); $i++) {if($array[$i] >= $key) {$rightArray[] = $array[$i];} else {$leftArray[] = $array[$i];}}$leftArray = quick_sort($leftArray);$rightArray = quick_sort($rightArray);return array_merge($leftArray, array($key), $rightArray);}方法二：该算法来自算法导论，叫作Nico Lomuto方法（感兴趣goole上有详细说明）使用最经典的单方向一次遍历找到中值。

但这种算法在最坏情况下（例如值相同的数组，需要n-1次划分，每一次划分需要O(n) 时间去掉一个元素）最坏情况下为O(n*n) 代码如下:function quick_sort(&$array, $start, $end) {if ($start >= $end) return;$mid = $start;for ($i = $start + 1; $i <= $end; $i++) {if ($array[$i] < $array[$mid]) {$mid++;$tmp = $array[$i];$array[$i] = $array[$mid];$array[$mid] = $tmp;}}$tmp = $array[$start];$array[$start] = $array[$mid];$array[$mid] = $tmp;quick_sort($array, $start, $mid - 1);quick_sort($array, $mid + 1, $end);}方法三：该方法基本上是教科书式的常见写法，首先从左向右遍历小于中间元素的跳过，同时从右向左遍历遇到大的元素跳过，然后如果没有交叉着交换两边值，继续循环，直到找到中间点。