算法（1）

---恢复内容开始---

从开始准备学编程就一直听算法算法。算法个毛东西？今天开始我就开始准备接触算法

算法那么首先就是排序：

排序大概份四种排序：

　　交换排序： 包括冒泡排序，快速排序。

选择排序： 包括直接选择排序，堆排序。

插入排序： 包括直接插入排序，希尔排序。

合并排序： 合并排序。

1.冒泡

从最开始的冒泡算法开始。

何为冒泡

---恢复内容结束---

从开始准备学编程就一直听算法算法。算法个毛东西？今天开始我就开始准备接触算法

算法那么首先就是排序：

排序大概份四种排序：

　　交换排序： 包括冒泡排序，快速排序。

选择排序： 包括直接选择排序，堆排序。

插入排序： 包括直接插入排序，希尔排序。

合并排序： 合并排序。

1.冒泡

从最开始的冒泡算法开始。

何为冒泡  好比一个

50

80

90

20

从底层开始算起冒泡，20小于90，20冒泡上来，90沉下去  50，80，20，90

20小于80 重复 50，20，80，90

90大于80，不需要交换，20小于50交换：20，50，80，90

排序成功

java代码实现：

1. package com.xiaoqiang.sort;
2. import java.util.Arrays;
3. public class Sort {
4. public static void main(String[] args) {
5. //原始数据
6. int a[] = new int[10000];
7. for (int i = 0; i < 10000; i++) {
8. a[i]=(int) (Math.random()*100000);
9. }
10. //排序
11. System.out.println(Arrays.toString(a));
12. mp(a);
13. System.out.println(Arrays.toString(a));
14. }
15. private static  void mp(int[] a) {
16. //冒泡算法
17. //首先遍历
18. long starTime=System.currentTimeMillis();
19. int temp;
20. //第一层循环
21. for (int i = 0; i < a.length-1; i++) {
22. //length-1比较次数
23. //j>i:从后往前的下标一定大于从前往后的下标，否则就超越了
24. for(int j=a.length-1;j>i;j--){
25. //如果前面一个数大于后面一个数则交换
26. if (a[j-1]>a[j]) {
27. temp=a[j-1];
28. a[j-1]=a[j];
29. a[j]=temp;
30. }
31. }
32. }
33. long endTime=System.currentTimeMillis();
34. System.out.println(endTime-starTime);
35. }
36. }

运算时间：725ms

Array.sort();

自带数组排序算法：7ms巨大的差距

冒泡算法被打爆的体无完肤

快速排序：

快速排序也是一种交换算法，那么快速排序算法怎么会这么快呢？

left指针 right指针 base参照数字

思想就是通过第一遍等的遍历找到切割点，

第一步：取出参照数20

第二步：从右往左找一直找到比20小的数然后把这个数字赋值给left

此时数组为：10，40，50，10，60，

第三步：从数组的左开始找一直找到比20大的数40 赋值到right

此时数组为：10，40，50，40，60，

left和right指针分别为前后的40。

第四步：重复“第二,第三“步骤，直到left和right指针重合，

最后将（base）插入到40的位置，

此时数组值为： 10，20，50，40，60，至此完成一次排序。

第五步：此时20已经潜入到数组的内部，20的左侧一组数都比20小，20的右侧作为一组数都比20大，

以20为切入点对左右两边数按照"第一，第二，第三，第四"步骤进行，最终快排大功告成。

下面是自己实现的快速排序算法的实现：

1. // 快速排序算法
2. // 输入数组以及数组的第一个数序号和最后一个数序号
3. public static void quick_sort(int s[], int l, int r) {
4. if (l < r) {
5. // Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
6. int i = l, j = r, x = s[l];
7. while (i < j) {
8. while (i < j && s[j] >= x)
9. // 从右向左找第一个小于x的数
10. j--;
11. if (i < j)
12. s[i++] = s[j];
13. while (i < j && s[i] < x)
14. // 从左向右找第一个大于等于x的数
15. i++;
16. if (i < j)
17. s[j--] = s[i];
18. }
19. s[i] = x;
20. quick_sort(s, l, i - 1); // 递归调用
21. quick_sort(s, i + 1, r);
22. }
23. }

时间大概是5ms左右跟java封装的排序算法差不多效率。