第三周作业——冒泡排序和归并排序

冒泡排序：程序如下

import java.io.IOException;
import java.util.List;

public class Sort {
	
	public static void main(String[] args) throws IOException {
		Sort bubble = new Sort();
		List<Integer> content = FileUtils.readerFileByBufferedReader("F:/大学专业/大三/算法概论/largeW.txt") ;//从工具类中读出数据
//		for(int a:content){
//			System.out.println(a);
//		}
		int num=0;
		Integer[]DataArray = (Integer[]) content.toArray(new Integer[num]);
		long start = System.currentTimeMillis();//开始时间
		bubbleSort(DataArray);
		long end = System.currentTimeMillis();//结束时间
		long time = end - start;
		System.out.println("冒泡排序的时间为："+time);
		
//	FileUtils.writerFileByBufferedWriter("F:/大学专业/大三/算法概论/largeW_bubble.txt", content, false) ;
	}
	public static void  bubbleSort(Integer[] Array){
		Integer[]NumsArray =(Integer[]) Array;
		int temp = 0;
		for( int i=0;i<NumsArray.length-1;i++){
			for(int j=0;j<NumsArray.length-i-1;j++){
				if(NumsArray[j]>NumsArray[j+1]){
					temp = NumsArray[j];
					NumsArray[j] = NumsArray[j+1];
					NumsArray[j+1] = temp;
				}
			}
			System.out.println(NumsArray[i]);
		}
	}
	
}

运行的时间：

归并排序：

 /** 
     * @param data：数组 
     * @param firstBegin：第一个有序表的起始下标 
     * @param secBegin：第二个有序表的起始下标 
     * @param secEnd：第二个有序表的终止下标 
     */  
    private static void merge (Object[] data, int firstBegin, int secBegin, int secEnd) {  
        Object[] temp = new Object[secEnd - firstBegin + 1];  
        int i = firstBegin, j = secBegin, current = 0;  
          
        //第一个有序表的当前匹配下标在[firstBegin, secBegin)  
        //第二个有序表的当前匹配下标在[secBegin, secEnd]  
        while (i < secBegin && j <= secEnd) {  
            if ((Integer)data[i] <= (Integer)data[j]) {  
                temp[current] = data[i];  
                current++;  
                i++;  
            } else {  
                temp[current] = data[j];  
                current++;  
                j++;  
            }  
        }  
          
        //第一个有序表的当前匹配下标在[firstBegin, secBegin)，则将后面的元素直接添加在temp表的后面，无序再进行比较  
        while (i < secBegin) {  
            temp[current] = data[i];  
            current++;  
            i++;  
        }  
          
        //第二个有序表的当前匹配下标在[secBegin, secEnd]，则将后面的元素直接添加在temp表的后面，无序再进行比较  
        while (j <= secEnd) {  
            temp[current] = data[j];  
            current++;  
            j++;  
        }  
          
        //将匹配好的数据覆盖回data表中原来的位置  
        System.arraycopy(temp, 0, data, firstBegin, temp.length);  
    }  
  
    /** 
     * @param data:数据数组 
     * @param length：每个有序表的长度 
     */  
    private static void  mergeSort(Object[] data, int length) {  
        if (data.length / length == 1) {  
            return;  
        }  
        /** 
         * size:当前两个有序表的总个数 
         * compareTime:每两个相邻的有序表比较为一次，总共的比较次数 
         * remainder:表示两个有序表总数按照size来划分，最终剩下的个数 
         */  
        int size = length * 2;  
        int compareTimes = data.length / size;  
        int remainder = data.length % size;  
        int firstBegin=0, secBegin=0, secEnd=0;  
          
        for (int i=0; i<compareTimes; i++) {  
            firstBegin = i * size;  
            secBegin = firstBegin + length;  
            secEnd = secBegin + length- 1;  
            merge(data, firstBegin, secBegin, secEnd);  
        }  
          
        //如果剩余的个数不为0，则将剩余的元素加入最后的一个有序表中进行排序  
        if (remainder != 0) {  
            secEnd = data.length - 1;  
            secBegin = data.length - remainder;  
            merge(data, firstBegin, secBegin, secEnd);  
        }  
          
        mergeSort(data, length*2);  
    }  
      

运行结果为：