冒泡排序与归并排序

         在数据结构和算法中，我们都会学习到各种排序的方法，但不同的方法其运行时间和效率也是有区别的。本文将冒泡排序和归并排序作为对比，观察两种算法的效率。

冒泡排序代码实现：

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.List;

public class bubbleSort {
	public static void main(String []args) throws IOException{		 
		FileInputStream fis=new FileInputStream("E:/largeW.txt");
		InputStreamReader dis=new InputStreamReader(fis);
		BufferedReader reader=new BufferedReader(dis);
		String s =null;
		String []strs =null;
		int []data;
		int count =0;
		List<String> strList = new ArrayList<String>();
		
		while((s=reader.readLine())!=null){
			count++;
			strList.add(s);   
			//向动态数组中添加从文件largeW.txt中读取的数据
		}
			data = new int[strList.size()];			
			for (int i = 0; i < strList.size(); i++) {
				data[i] = Integer.parseInt(strList.get(i).trim());	
				//将strList中的String类型数据转化为int型数据并存放到data数组中			
			}
			long startTime=System.currentTimeMillis(); //获取排序开始时的时间
			for(int j =1;j <data.length;j++){          //冒泡排序
				for(int k =j+1;k <data.length;k++){
					if(data[j] > data[k]){
					int t;
					t =data[j];
					data[j] =data[k];
					data[k] =t;					
				}					
				}				
				//System.out.println(data[j]);				
			}
			long endTime=System.currentTimeMillis();   //获取排序结束后的时间
			OutputStreamWriter outputStream = new OutputStreamWriter(new FileOutputStream("E:/largeW_bubble.txt")); 
			for(int i = 1;i < data.length;i++){				
			     outputStream.write(data[i]+" ");	
			     //将排好序的数组存放到文件largeW_bubble.txt中			 
				 System.out.println(data[i]);
			}
			outputStream.close();
		System.out.println("总共有数据："+count+"条");
		System.out.println("排序时间为： "+(endTime-startTime)+"ms");
		dis.close();
	}
	
}

冒泡排序时间：

归并排序代码实现：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.List;

public class mergeSort {
	public static void main(String []args) throws IOException{		 
		FileInputStream fis=new FileInputStream("E:/largeW.txt");
		InputStreamReader dis=new InputStreamReader(fis);
		BufferedReader reader=new BufferedReader(dis);
		String s =null;
		String []strs =null;
		int []data;
		int count =0;
		List<String> strList = new ArrayList<String>();
		while((s=reader.readLine())!=null){
			count++;
			strList.add(s);
		}
			data = new int[strList.size()];			
			for (int i = 0; i < strList.size(); i++) {
				data[i] = Integer.parseInt(strList.get(i).trim());				
			}
			long startTime=System.currentTimeMillis();
			mergeSort(data);
			long endTime=System.currentTimeMillis();
			OutputStreamWriter outputStream = new OutputStreamWriter(new FileOutputStream("E:/largeW_merge.txt"));
	        System.out.println("排序后的数组：");
	        for (int i = 0; i < data.length; i++) { 
	        	outputStream.write(data[i]+" ");
	            System.out.println(data[i]);  
	        }
	        outputStream.close();	       
	        System.out.println("排序时间为： "+(endTime-startTime)+"ms");
	}
	public static void mergeSort(int[] data) {  
        sort(data, 0, data.length - 1);  
    }  
  
    public static void sort(int[] data, int left, int right) {  
        if (left >= right)  
            return;  
        // 找出中间索引  
        int center = (left + right) / 2;  
        // 对左边数组进行递归  
        sort(data, left, center);  
        // 对右边数组进行递归  
        sort(data, center + 1, right);  
        // 合并  
        merge(data, left, center, right);        
    }  
    public static void merge(int[] data, int left, int center, int right) {  
        // 临时数组  
        int[] tmpArr = new int[data.length];  
        // 右数组第一个元素索引  
        int mid = center + 1;  
        // third 记录临时数组的索引  
        int third = left;  
        // 缓存左数组第一个元素的索引  
        int tmp = left;  
        while (left <= center && mid <= right) {  
            // 从两个数组中取出最小的放入临时数组  
            if (data[left] <= data[mid]) {  
                tmpArr[third++] = data[left++];  
            } else {  
                tmpArr[third++] = data[mid++];  
            }  
        }  
        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）  
        while (mid <= right) {  
            tmpArr[third++] = data[mid++];  
        }  
        while (left <= center) {  
            tmpArr[third++] = data[left++];  
        }  
        // 将临时数组中的内容拷贝回原数组中  
        // （原left-right范围的内容被复制回原数组）  
        while (tmp <= right) {  
            data[tmp] = tmpArr[tmp++];  
        }  
    }  
}

归并排序时间：

     理论上，冒泡排序的时间复杂度为O(n²)，而归并排序的时间复杂度为O(n)。实际运行结果也表明，归并排序的效率要比冒泡排序效率高得多。