冒泡排序 交换排序

//相邻的两个元素比较，将大的放到最右边 int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp;
} } } return array; }
public static void main(String[] args) {
int[] array = { 25, 36, 21, 45, 98, 13}; System.out.println(Arrays.toString(array)); BubbleSort.bubbleSort(array);// 调用快速排序的方法 System.out.println(Arrays.toString(array));// 打印排序后的数组元素 }
1. public class TestMain { 2.
3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. }
/** * @param args */
public static void main(String[] args) { // TODO Auto-generated method stub Integer[] list={34,3,53,2,23,7,14,10}; QuicSort qs=new QuicSort(); qs.quick(list); for(int i=0;i<list.length;i++){ System.out.print(list[i]+" "); } System.out.println();
5 3 8 9 3 4 array.Length=6
I0
1
J 0 358934
1 358934
2 358934
3 358394
4 358349
353489
I=0 时 将最大的数放到了最后边
2
3
4
6
334589 334589
；i=1 时 将倒数第二大的数放到了倒数第二的位置
所以在实际生活中作用不大，一般的语言（比如 java，c++，c）都有实现好的排序算法 比如 c 语言中的 qsort（采用快速排序），c++的 stl 里面的 sort（采用多种方式混合式排序） java 里面的 sort 方法（也是混合式排序，元素少的时候用了冒泡，元算多的时候用了归并 排序）
list[low] = tmp;
//中轴记录到尾
14.
return low;
//返回中轴的位置
15. }
递归形式的分治排序算法：
[html] view plaincopy
1. public void _quickSort(Integer[] list, int low, int high) {
2.
if (low < high) {
6.
}
7.
}
[html] view plaincopy
1. public void quick(Integer[] str) {
2.
if (str.length > 0) { //查看数组是否为空
3.
_quickSort(str, 0, str.length - 1);
4.
}
5.
}
编写测试方法：
[html] view plaincopy
选择排序和冒泡排序都是基于元素交换的，因此你的分类错误 冒泡排序基本思想：每次将最重的一个沉入海底 选择排序基本思想：每次扫描最重的一个与第一个交换
并且，选择和冒泡的时间复杂度是一样的（都是 O(N^2)） 应用交换排序基本思想的主要排序方法有：冒泡排序（Bubble sort）和快速排序（Quick sort）。 交换排序 所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交 换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。 下面是 java 语言实现一个交换排序的函数： public class BubbleSort {
[html] view plaincopy
1. public int getMiddle(Integer[] list, int low, int high) {
2.
int tmp = list[low]; //数组的第一个作为中轴
3.
while (low < high) {
4.
while (low < high && list[high] > tmp) {
}
看一下打印结果吧：
2 3 7 10 14 23 34 53
这样就排序好了，快速排序是对冒泡排序的一种改进，平均时间复杂度是 O(nlogn)。
快速排序的基本思想：
通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一 部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序。
先看一下这幅图：
把整个序列看做一个数组，把第零个位置看做中轴，和最后一个比，如果比它小交换，比它 大不做任何处理；交换了以后再和小的那端比，比它小不交换，比他大交换。这样循环往复， 一趟排序完成，左边就是比中轴小的，右边就是比中轴大的，然后再用分治法，分别对这两 个独立的数组进行排序。
3.
int middle = getMiddle(list, low, high); //将 list 数组进行一分为
二
4.
_quickSort(list, low, middle - 1);
//对低字表进行递归排序
百度文库
5.
_quickSort(list, middle + 1, high);
//对高字表进行递归排序
public static int[] 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]){
也就是两两比较，以数组为例，比较过程： 第一轮：数组下标为 0 的元素与 1 的元素相比，25<36,正序，指针后移，36>21 反序，交换 36 和 21，指针后移，36<45 正序，指针后移，45<98 正序，指针后移，98>13 反序，交换 98 和 13，最后 98 位于为底端，也就是数组的末尾。比较次数为(n-1) 第二轮：还是从数组下标为 0 开始两两比较，在第一比较后的结果 98 就不参与比较，比较 次数为(n-2); ......
java 实现快速排序
javalistinteger 算法数据结构 string
分类： 算法 2012-02-23 11:49 19506 人阅读 评论(9) 收藏 举报
说来感到惭愧，昨天看别人的博客上面一一讲了一些算法，其实这些算法在大学都学 过，不过几乎全部忘记了。虽然现在做 java 上层开发基本上用不到算法，但是还是感觉算 法是一种思想，是一种灵魂，所以又不仅翻开了严蔚敏老师的数据结构，一个一个把以前忘 记的算法实现一遍。
当然算法是要学习的，这些算法自己都要理解，用的时候呢，就用现成的就好了，如果有特 殊需求的排序，当然你可以自己实现比较器 不谢 请叫我红领巾
快速排序的基本思想 通过一趟排序将待排记录分割成独立两部分，其中一部分记录的关键字均比另一部分记录的 关键小，则可以分别对这两部分记录继续进行排序，以达到这个序列有序。
5.
high--;
6.
}
7.
list[low] = list[high]; //比中轴小的记录移到低端
8.
while (low < high && list[low] < tmp) {
9.
low++;
10.
}
11.
list[high] = list[low]; //比中轴大的记录移到高端
12.
}
13.