排序算法,快速排序與冒泡排序

時間 2019-11-16

標籤排序算法快速排序冒泡排序简体版

原文原文鏈接

用java實現排序算法.

在算法的實現過程當中是用的ArrayList.從該類的實現方面來看,對算法的執行效率也是有影響的.在這裏僅僅記錄如下本身的學習過程及結果.java

1,快速排序算法

代碼的實現以下,該類是一個測試類方法 quickSortMethod()就是快速排序的實現,他的實現使用的是一個遞歸算法,api

ArrayList的實現是一個數組,並且數組的大小是10,若是元素大於10個就會申請新的空間,大小爲原來的1.5倍, int newCapacity = oldCapacity + (oldCapacity >> 1);從底層的代碼能夠看出他爲了提升效率使用移位來提升效率.數組

爲了進可能的減小arrayList的數據機構的影響,這裏使用foreach遍歷數組.因爲這裏測試的數據比較大,而ArrayLIst的初始大小爲10,並且每次增加爲原來的二倍,讓後把舊的數據複製到新的數組裏面.dom

總之這樣來寫一個算法多少是有些影響的.學習

 1 package com.test.sort;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Arrays;
 5 import java.util.List;
 6 
 7 public class QuickSort {
 8 
 9     public List quickSortMethod(List<Integer> parentList){//quickSort
10         List<Integer> leftList = new ArrayList<Integer>();
11         List<Integer> rightList = new ArrayList<Integer>();
12         List<Integer> resultList ;
13         if (parentList.size() <= 1) {
14             return parentList;
15         }
16         Integer qInteger = parentList.get(0);
17         Boolean first = true;
18         for (Integer temp : parentList) {
19             if(first) {
20                 first = !first;
21                 continue;
22             }
23             if (temp > qInteger) {
24                 rightList.add(temp);
25             }else {
26                 leftList.add(temp);
27             }
28             
29         }
30         resultList = this.quickSortMethod(leftList);
31         resultList.add(qInteger);
32         resultList.addAll(this.quickSortMethod(rightList));
33         return resultList;   
35     }
36     
37     public static void main(String[] args) {
38         List<Integer> results;
39         QuickSort qSort = new QuickSort();
40         List<Integer> list = new ArrayList();
41         int elemCount = 100000;
42         for(int i = 0; i<elemCount; i++) {
43             list.add((int) (Math.random()*elemCount));
44         }
45         Long startTime = System.currentTimeMillis();
46         results = qSort.quickSortMethod(list);
47         Long endTime = System.currentTimeMillis();
48         Long totalTime =  endTime - startTime;
49         System.out.println(startTime);
50         System.out.println(endTime);
51         System.out.println("quick Sort Time = " + totalTime );
52         //qSort.log(results);
53         
54         //bubble Sort
55         startTime = System.currentTimeMillis();
56         results = qSort.bubbleSort(list);
57         endTime = System.currentTimeMillis();
58         totalTime =  endTime - startTime;
59         System.out.println(startTime);
60         System.out.println(endTime);
61         System.out.println("dubble sort Time = " + totalTime );
62         //qSort.log(results);        
63     }
64     
65     
66     public List bubbleSort(List<Integer> parentList) {
67         if (parentList == null || parentList.size() == 0) {
68             System.err.println("List isn't elem");
69             return null;
70         }
71         
72         for (int i = 0,listSize = parentList.size(); i < listSize; i++) {
73             for(int j = 0; j < listSize - i - 1; j++){
74                 if (parentList.get(j) > parentList.get(j+1)) {
75                     int temp = parentList.get(j);
76                     parentList.set(j, parentList.get(j+1));
77                     parentList.set(j+1, temp);
78                 }
79             }
80         }
81         return parentList;
82     }
83     
84     public void log(List<Integer> parentList){
85         for (Integer  elem: parentList) {
86             System.out.println(elem);
87         }
88         System.out.println("==================================");
89     }
90 }