java排序学习笔记

前面写了js的排序实现,总得玩玩java的哈。

同样,冒泡、选择、快速(这三个之前实现过也写过文章)、堆排序,然后做比较。

主要遇到的难点:

- -||想轻松点写个封装计时的逻辑,不想每调用一个排序就要写一个计时代码。想想,还是javascript写起来方便;

java的话,我想到的方法是写一个抽象类:抽象出排序方法,实现一个排序计时方法(该方法调用了抽象排序,但在先后排序时加入计时代码[感觉像是aop操作]);

接着所有排序类都继承这个抽象类,并实现排序方法,调用的时候直接调用继承的排序计时方法,这样就不用写多余的代码了。(不过这还搞继承,有点。。。不知道有啥高招呢?)

下面是展示各排序代码:

冒泡:

 1 public class BubbleSort extends SortAbstract{
 2
 3     public static void main(String[] args) {
 4         int[] a = {1,8,5,6,3,7,5,4,8,9,12,2};
 5         new BubbleSort().sort(a);
 6         for(int c : a){
 7             System.out.println(c);
 8         }
 9     }
10     public void sort(int[] array){
11         if(array.length == 0)return ;
12         for(int i=0;i<array.length-1;i++){//i是计数标记
13             for(int j=0;j<array.length-i-1;j++){//注意终止条件的判断,冒泡的亮点在于从头到尾一对一对比较
14                 if(array[j]>array[j+1]){
15                     swap(array, j, j+1);
16                 }
17             }
18         }
19     }
20     public static void swap(int[] array,int i,int j){
21         int temp = array[i];
22         array[i] = array[j];
23         array[j] = temp;
24     }
25 }

选择:

 1 public class ChooseSort extends SortAbstract{
 2     public static void main(String[] args) {
 3         int[] a = {1,8,5,6,3,7,5,4,8,9,12,2};
 4         new ChooseSort().sort(a);
 5         for(int c : a){
 6             System.out.println(c);
 7         }
 8     }
 9
10     public  void sort(int[] array){
11         if(array.length == 0)return ;
12         for(int i=0;i<array.length-1;i++){
13             for(int j=i+1;j<array.length;j++){
14                 if(array[i]>array[j]){
15                     swap(array, i, j);
16                 }
17             }
18         }
19     }
20
21    public  static void swap(int[] array,int i,int j){
22         int temp = array[i];
23         array[i] = array[j];
24         array[j] = temp;
25     }
26 }

快速:

 1 public class QuickSort extends SortAbstract{
 2     public static void qSort(int[] num,int low,int high){
 3         if(low<high){
 4             int pivotloc = partition(num,low,high);
 5             qSort(num, low, pivotloc-1);
 6             qSort(num, pivotloc+1, high);
 7         }
 8     }
 9     public  void sort(int[] array){
10         qSort(array, 0, array.length-1);
11     }
12     public static int partition(int[] num,int low,int high){
13         int mid = num[low];
14         int pivotkey = num[low];
15         while(low<high){
16             while(low<high&&num[high]>=pivotkey){
17                 --high;
18             }
19             num[low] = num[high];
20             while(low<high&&num[low]<=pivotkey){
21                 ++low;
22             }
23             num[high]=num[low];
24         }
25         num[low] = mid;
26         return low;
27     }
28     /**
29      * @param args
30      */
31     public static void main(String[] args) {
32         // TODO Auto-generated method stub
33         int[] num = {9,18,-8,-6,-57,5,62,0};
34         qSort(num, 0, num.length-1);
35         for(int i=0;i<num.length;i++){
36             System.out.println(num[i]);
37         }
38     }
39
40 }

堆:

 1 public class HeapSort extends SortAbstract {
 2     public void sort(int[] array){
 3         if(array.length<=1){
 4             return;
 5         }
 6         int len = array.length;
 7         for(int i=len/2+1;i>=0;i--){//初始最大堆 无序数组,由最右一个非子节点开始。这里len/2 +1 没想明白
 8             maxHeapify(array, i, len);
 9         }
10         for(int i = len-1; i>0; i-- ){
11             swap(array, 0, i); //每次将堆根节点与尾部交换,然后逻辑上数组放弃掉尾部,实际有点像尾部冒泡
12             maxHeapify(array, 0, --len); //从顶部开始顶堆调整
13         }
14     }
15     public static int getLeft(int index){
16         return index*2+1;
17     }
18     public static int getRight(int index){
19         return (index+1)*2;
20     }
21     public static void swap(int[] array, int i, int j){
22         int temp = array[i];
23         array[i] = array[j];
24         array[j] = temp;
25     }
26     public static void maxHeapify(int[] array, int index, int len){
27         if(array.length==0 || len<=1){
28             return;
29         }
30         int largest;
31         int left = getLeft(index);
32         int right = getRight(index);
33         if(left<len&&array[index]<array[left]){
34             largest = left;
35         }else{
36             largest = index;
37         }
38         if(right<len && array[right]>array[largest]){
39             largest = right;
40         }
41         if(largest!=index){
42             swap(array, largest, index); //交换两个位置的元素,并递归调用调整交换的孩子节点
43             maxHeapify(array, largest, len);
44         }
45     }
46     public static void main(String[] args){
47         int[] a = {1,8,5,6,3,7,5,4,8,9,12,2};
48         new HeapSort().sort(a);
49         for(int c : a){
50             System.out.println(c);
51         }
52     }
53 }

计时抽象类:

1 public abstract class SortAbstract {
2     public abstract void sort(int[] array);
3     public  void runWithTimer(int[] array){
4         Date start = new Date();
5         this.sort(array);
6         Date end = new Date();
7         System.out.println("排序时间:(ms)"+(end.getTime()-start.getTime()));
8     }
9 }

测试用例:

 1 public class SortTestMain {
 2     public static void main(String[] args){
 3         int[] small = {6,44,33,2,3,5,2,1,7,9,8,14};
 4         BubbleSort bubbleSort = new BubbleSort();
 5         ChooseSort chooseSort = new ChooseSort();
 6         QuickSort quickSort = new QuickSort();
 7         HeapSort heapSort = new HeapSort();
 8         System.out.println("冒泡排序:");
 9         //int[] smallUse = small.clone();
10         bubbleSort.runWithTimer(small.clone());
11         System.out.println("选择排序:");
12         chooseSort.runWithTimer(small.clone());
13         System.out.println("快速排序:");
14         quickSort.runWithTimer(small.clone());
15         System.out.println("堆排序:");
16         heapSort.runWithTimer(small.clone());
17
18         System.out.println("对a[10000]排序:");
19         int[] big = new int[10000];
20         for(int i=0; i<10000; i++){
21             big[i] = (int)Math.floor(Math.random()*100001);
22         }
23         System.out.println("冒泡排序:");
24         //int[] smallUse = small.clone();
25         bubbleSort.runWithTimer(big.clone());
26         System.out.println("选择排序:");
27         chooseSort.runWithTimer(big.clone());
28         System.out.println("快速排序:");
29         quickSort.runWithTimer(big.clone());
30         System.out.println("堆排序:");
31         heapSort.runWithTimer(big.clone());
32     }
33 }

测试结果:

结论:

  几个元素的排序,基本很快。只有当数据开始多时,堆和快速开始展现出优势。

java排序学习笔记,布布扣,bubuko.com

时间: 2024-10-01 22:32:26

java排序学习笔记的相关文章

[原创]java WEB学习笔记95:Hibernate 目录

本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱好者,互联网技术发烧友 微博:伊直都在0221 QQ:951226918 -----------------------------------------------------------------------------------------------------------------

黑马程序员--java基础学习笔记5

黑马程序员--java基础学习笔记6 一.笔记内容概述: 数组-第二种定义格式.数组-常见操作-遍历-最值-选择排序-冒泡排序-排序位置置换代码提取.数组-排序的性能问题.数组-常见功能-查找-折半查找.进制转换-查表法-整合. 二.常用内容介绍: 1.数组初始化的三种方式: int[] arr = new int[3]; int[] arr = new int[]{1,2,3}; int[] arr = {1,2,3}; 2.查表法: 如果数据中出现了对应关系,而且对应关系的一方是有序的数字编

java nio学习笔记(一)

位置保留,待用 java nio学习笔记(一),布布扣,bubuko.com

JAVA基础学习笔记(2)

看了几天的视频了,都没时间来写下学习笔记,今天来写下第二次的学习笔记,前几天看的给忘记了,就写最新看到的吧 主要内容:1.类的变量与函数(方法) 2.对象的存储方式 3.新建一个对象及对象的赋值与调用 4.空对象 5.匿名对象 1.类的变量与函数(方法) class Dog      //类名 { String name;  //变量的声明 int age; String color; void bark()   //方法的定义(返回值为空,不带参数) { System.out.println(

《深入Java虚拟机学习笔记》- 第4章 网络移动性

Java虚拟机学习笔记(四)网络移动性 <深入Java虚拟机学习笔记>- 第4章 网络移动性,布布扣,bubuko.com

《深入Java虚拟机学习笔记》- 第7章 类型的生命周期

一.类型生命周期的开始 如图所示 初始化时机 所有Java虚拟机实现必须在每个类或接口首次主动使用时初始化: 以下几种情形符合主动使用的要求: 当创建某个类的新实例时(或者通过在字节码中执行new指令,或者通过不明确的创建.反射.克隆和反序列化): 当调用某个类的静态方法时(即在字节码中执行invokestatic指令): 当使用某个类或接口的静态字段,或者对该字段赋值时(用final修饰的静态字段除外,它被初始化为一个编译时常量表达式): 当调用Java API中的某些反射方法: 当初始化某个

《深入Java虚拟机学习笔记》- 第13章 逻辑运算

<深入Java虚拟机学习笔记>- 第13章 浮点运算 <深入Java虚拟机学习笔记>- 第13章 逻辑运算,布布扣,bubuko.com

《深入Java虚拟机学习笔记》- 第12章 整数运算

Java虚拟机提供几种进行整数算术运算的操作码,他们执行基于int和long类型的运算.当byte.short和char类型值参与算术运算时,首先会将它们转换为int类型.这些操作码都不会抛出异常,溢出在这里通常可以被忽略. 整数加法 操作码 操作数 说明 iadd (无) 从栈中弹出两个int类型数,相加,然后将所得int类型结果压回栈 ladd (无) 从栈中弹出两个long类型数,相加,然后将所得long类型结果压回栈 将一个常量与局部变量相加 操作码 操作数 说明 iinc vindex

《深入Java虚拟机学习笔记》- 第2章 平台无关

Java虚拟机学习笔记(二)平台无关 <深入Java虚拟机学习笔记>- 第2章 平台无关,布布扣,bubuko.com