长度为N的数组升序排序
一，冒泡排序
public class BubbleSort {
private double[] data;
public BubbleSort(double[] data) {
this.data = data;
}
public void sort(){
for(int p = data.length - 1 ; p > 0 ; p--){
for(int i = 0 ; i < p ; i++){
if(data[i] > data[i+1] ){
double tmp = data[i];
data[i] = data[i+1];
data[i+1] = tmp;
}
}
}
}
public void display(){
for(int i = 0 ; i < data.length ; i++){
System.out.print(data[i]+" ");
}
System.out.print("\n");
}
public static void main(String[] args) {
double[] data = {Math.random(),Math.random(),Math.random(),Math.random()};
BubbleSort bubbleSort = new BubbleSort(data);
bubbleSort.display();
bubbleSort.sort();
bubbleSort.display();
}
}
0.4125010895286405 0.1682061731460387 0.5946448214944792 0.2760597727054087
0.1682061731460387 0.2760597727054087 0.4125010895286405 0.5946448214944792
比较次数：第一次比较N-1次，第二次比较N-2次，总比较次数为(N-1) + (N-2) +...+ 1 = (N-1)*N/2
交换次数：如果数组本身为降序排序，则需交换(N-1)*N/2次，如果数组本身为升序排序，则需交换0次，如果数据是随机的，大约需要交换(N-1)*N/4次
时间复杂度：(N-1)*N/2 + (N-1)*N/4，总得来说为O(N*N)
二，选择排序
public class SelectSort {
private double[] data;
public SelectSort(double[] data){
this.data = data;
}
public void sort(){
for(int i = 0 ; i < data.length ; i++){
int flag = i;
for(int j = i + 1 ; j < data.length ; j++){
if( data[j] < data[flag]){
flag = j;
}
}
double tmp = data[i];
data[i] = data[flag];
data[flag] = tmp;
}
}
public void display(){
for(int i = 0 ; i < data.length ; i++){
System.out.print(data[i]+" ");
}
System.out.print("\n");
}
public static void main(String[] args) {
double[] data = {Math.random(),Math.random(),Math.random(),Math.random()};
SelectSort selectSort = new SelectSort(data);
selectSort.display();
selectSort.sort();
selectSort.display();
}
}
0.8992760265680794 0.36366208723355853 0.5105026583966352 0.27067878126430966
0.27067878126430966 0.36366208723355853 0.5105026583966352 0.8992760265680794
比较次数：第一次比较N-1次，第二次比较N-2次，总比较次数为(N-1) + (N-2) +...+ 1 = (N-1)*N/2
交换次数：如果数组本身为降序排序，则需交换N次，如果数组本身为升序排序，则需交换0次，如果数据是随机的，大约需要交换N/2次
时间复杂度：(N-1)*N/2 + N/2，总得来说为O(N*N)，但是会比冒泡排序快
三，插入排序
public class InsertSort {
private double[] data;
public InsertSort(double[] data) {
this.data = data;
}
public void sort(){
for(int i = 1 ; i < data.length ; i++){
double tmp = data[i];
int insertPoint = i;
while(insertPoint > 0 && data[insertPoint-1] > tmp){
data[insertPoint] = data[insertPoint-1];
--insertPoint;
}
if(insertPoint < i){
data[insertPoint] = tmp;
}
}
}
public void display(){
for(int i = 0 ; i < data.length ; i++){
System.out.print(data[i]+" ");
}
System.out.print("\n");
}
public static void main(String[] args) {
double[] data = {Math.random(),Math.random(),Math.random(),Math.random()};
InsertSort insertSort = new InsertSort(data);
insertSort.display();
insertSort.sort();
insertSort.display();
}
}
0.25855304984386873 0.5035006863323077 0.8986028814892651 0.724194607320699
0.25855304984386873 0.5035006863323077 0.724194607320699 0.8986028814892651
比较次数：第一次比较1次，第二次比较2次，总比较次数为1+2+...+(N-1)= (N-1)*N/2，每一趟排序发现插入点之前，平均只有一半的数据进行了比较，所以总的比较次数为：(N-1)*N/4
交换次数：交换次数小于比较次数，并且插入排序的交换比冒泡排序和选择排序要快
时间复杂度：(N-1)*N/4 + (N-1)*N/4，总得来说为O(N*N)，但是会比选择排序快
如果数组是基本有序的，即每个数据项只需移动1次或不需要移动，那么插入排序的时间复杂度将变为O(N)，这无疑是非常快的
四，表排序：
主要是利用了有序链表的特性，将数组中的所有数据插入到有序链表中，它们将自动按顺序排列，然后再顺次取出链表中的所有数据，把它们放到数组中，数组便排好序了
public class SortedList {
private class Data{
private double d;
private Data next = null;
Data(double d){
this.d = d;
}
}
private Data first = null;
public void insert(double d){
Data data = new Data(d);
Data pre = null;
Data cur = first;
while(cur != null && (data.d > cur.d)){
pre = cur;
cur = cur.next;
}
if(pre == null)
first = data;
else
pre.next = data;
data.next = cur;
}
public double deleteFirst() throws Exception{
if(first == null)
throw new Exception("empty!");
Data temp = first;
first = first.next;
return temp.d;
}
}
public class ListSort {
private double[] data;
private SortedList sl;
public ListSort(double[] data){
this.data = data;
sl = new SortedList();
}
public void sort() throws Exception{
for(int i = 0 ; i< data.length ; i++){
sl.insert(data[i]);
}
for(int i = 0 ; i< data.length ; i++){
data[i] = sl.deleteFirst();
}
}
public void display(){
for(int i = 0 ; i < data.length ; i++){
System.out.print(data[i]+" ");
}
System.out.print("\n");
}
public static void main(String[] args) throws Exception{
double[] data = {Math.random(),Math.random(),Math.random(),Math.random()};
ListSort ls = new ListSort(data);
ls.display();
ls.sort();
ls.display();
}
}
0.6379262500544237 0.18329827548195576 0.8408253367598466 0.6213596557610592
0.18329827548195576 0.6213596557610592 0.6379262500544237 0.8408253367598466
比较次数：将数据插入链表平均需要比较N/2次
交换次数：将数组数据放入链表，再将链表数据放回数组，总共需移动2N次
时间复杂度：N/2 + 2N，总得来说为O(N)
虽然排序速度比上面3种排序方式要快，但是需要大约2倍的内存空间，数组和链表同时存在于内存中