数组中元素的排序（常用的冒泡排序选择排序快速排序）

Posted 2022-09-21 lxz123

1.冒泡排序（以从小到大为例）

【分析】：冒泡排序的思想就是，两两进行比较，第一个元素和第二个元素进行比较，如果第一个元素比第二个元素大，则这两个元素交换位置，然后第二个元素和第三个元素进行比较，如果第二个元素比第三个元素大，交换位置，依次类推，知道到最后一个元素。在比较的时候，每进行一轮比较，就可以找到当前这一轮的最大值， 我们可以将每一轮找到的最大值放到最后，知道最终剩下两个值，比较完之后，就可以将当前数列的数据按照从小到大的顺序排列好。

以：a=[  2 ,  6  ,8  ,9  ,1  ,2 ]  数列为例。

第一轮： 2    6   8   9   1   2　　　　　　　第二轮： 2　　 6　　 8　　 1 　　2　　　　　　 第三轮：2　　6　　1　　2　　　　第四轮：1　　2　　 2　　　　第五轮：1　　 2

 　　　　2   6    8   9   1   2　　　　　　　　　　　2　　  6　　 8 　　1 　　2　　　　　　　　　　 2 　   1　　6　　2　　　　　　　　1 　   2　　2

　　　　 2   6    8   9   1   2　　　　　　　　　　　2 　　 6     　1　　8　　 2　　　　　　　　　　  2　　1　　2　　6

　　　　 2   6   8    1   9   2　　　　　　　　　　　2　　  6　　 1　　2　　 8　　　　　　　　　　

　　　 　2  6    8   1   2   9

代码：

var arr = [ 2 ,  6  ,8  ,9  ,1  ,2 ];

function bubbleSort(arr)

　　//确定轮数

　　for (var i = 0; i < arr.length; i++)

　　　　//每一轮数值比较

　　　　for (var j = i; j < arr.length-1; j++)

　　　　　　//谁小谁放在前面

　　　　　　if (arr[i] > arr[i + 1])

　　　　　　　　var temp = arr[i];

　　　　　　　　arr[i] = arr[i + 1];

　　　　　　　　arr[i + 1] = temp;

　　　　　　

　　　　

　　

　　return arr;

console.log(bubbleSort(arr));

 

运行结果：  [1, 2, 2, 6, 8, 9]

 

2. 选择排序（从小到大排序）

【分析】：选择排序，遵循的是打擂台的游戏。冠军只有一个，主要与每个人进行比，最后胜出者为冠军。第一个人和后面的每个人都要打，谁小谁就放在最前面，然后第二个人和后面的每个人都要打，谁小，谁就是次二，依次类推。

还是以：a=[  2 ,  6  ,8  ,9  ,1  ,2 ]  数列为例。　　

第一轮： 2 　　6　　8　　9　　1　　2　　　　第二轮：6　　8　　9　　2　　2　　　　第三轮：8　　9　　6　　2　　　　第四轮:   8　　9　　6　　　　第五轮：8　　9

　　　　 2　　 6　　8　　9　　1　　2　　　　　　　　6　　8　　9　　2　　2　　　　　　　　6　　9　　8　　2　　　　　　　　6　　9　　8　　

　　　　 2　　 6　    8　    9　　1　　2　　　　　　　　2　　8　　9　　6　　2　　　　　　　　2　　9　　8　　6

　　　    1　     6　　 8　    9　    2　　2　　　　　　　　2　　8　　9　　6　　2

　　　    1 　　6 　    8　　9　　2　　2

代码： 

arr =[ 2 ,  6  ,8  ,9  ,1  ,2 ];

function chooseSort(arr)

　　// 确定轮数

　　for (var i = 0; i < arr.length-1; i++)

　　　　// 每一轮都和第一个进行比较

　　　　for (var j = i + 1; j < arr.length; j++)

　　　　　　// 谁小谁放在前面

　　　　　　if (arr[i] > arr[j])

　　　　　　　　var temp = arr[i];

　　　　　　　　arr[i] = arr[j];

　　　　　　　　arr[j] = temp;

　　　　　　

　　　　

　　

　　return arr;

console.log(chooseSort(arr));

 

运行结果：  [1, 2, 2, 6, 8, 9]。

 

3. 快速排序（从小到大排序）

【分析】：将偏中间的数作为基准值，小于它的放在数组的左边，大于它的放在数组的右边，一轮比完之后，我们再将左边的左边的作为一个数组，右边的作为一个数组，然后分别找中间的技术，再按上面的方法进行计算（也就是递归），直到数组中剩下一个元素（也是循环结束的终止条件）。

 

 代码：

arr = [2, 6, 8, 9, 1, 2];

function quickSort(arr)

　　if(arr.length <= 1)

　　　　return arr;

　　

　　var midIndex = parseInt(arr.length / 2);

　　var midValue = arr[midIndex];

　　var leftArr = [];

　　var rightArr = [];

　　for(var i=0;i< arr.length;i++)

　　　　if( i== midIndex)

　　　　　　continue;

　　　　

　　　　if(arr[i] < midValue)

　　　　　　leftArr.push(arr[i]);

　　　　else

　　　　　　rightArr.push(arr[i]);

　　　　

　　

　　return quickSort(leftArr).concat(midValue).concat(quickSort(rightArr));

console.log(quickSort(arr));

运行结果：  [1, 2, 2, 6, 8, 9]。

4.常见的还有希尔排序和插入排序，在这里就不做详细的介绍的。