第3周==冒泡排序与归并排序

package sort;
import java.io.File ;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Scanner;
public class Sort{
    public static void main(String args[]) throws Exception{// 异常抛出，不处理
// 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "LargeW.txt") ;// 声明File对象
// 第2步、通过子类实例化父类对象
        Reader input = null ;// 准备好一个输入的对象
        input = new FileReader(f)  ;// 通过对象多态性，进行实例化
// 第3步、进行读操作
        char c[] = new char[1024] ;// 所有的内容都读到此数组之中
        int len = input.read(c) ;// 读取内容
        Reader reader = new InputStreamReader(new FileInputStream(f));
        StringBuffer stringbuffer = new StringBuffer();
        ArrayList list = new ArrayList();
        int num;
        while ((num = reader.read()) != -1) {
            if ( ((char) num) != '\n' ) {
                stringbuffer.append((char) num);
            }else{
                int size = stringbuffer.length();
                stringbuffer.deleteCharAt(size-1);
                String line = new String(stringbuffer);
                line = line.trim();
                list.add(line);
                stringbuffer.delete(0, size);
            }
        }
        int[] a = new int[list.size()-1];
        for(int i=0;i<list.size()-1;i++){
            int int_num = Integer.valueOf((String) list.get(i));
            a[i] = int_num;
        }
        bubble_sort sort = new bubble_sort();
        int[] has_sort = sort.bubble_sort(a);
        System.out.println("排序之后的排列：");
        for(int i=0;i<has_sort.length;i++){
            System.out.println(has_sort[i]);
        }
        int b = 0;
        PrintStream out= new PrintStream("d:" + File.separator + "largeW_bubble.txt");
        for(int i=0;i<has_sort.length;i++){
            out.println(has_sort[i]);
        }
        out.close();
// 第4步、关闭输出流
        input.close() ;// 关闭输出流  
        System.out.println("冒泡排序结束！");
        mergeSort ms = new mergeSort();
        int[] ms_sort = ms.mergeSort(a);
        System.out.println("排序之后的排列：");
        PrintStream out1= new PrintStream("d:" + File.separator + "largeW_merge.txt");
        for (int i = 0; i < ms_sort.length; i++) {  
            System.out.println(ms_sort[i] );  
        }  
        for(int i=0;i<ms_sort.length;i++){
            out.println(ms_sort[i]);
        }
        out1.close();
        input.close();
        System.out.println("归并排序结束！");
    }    

}

冒泡排序算法程序：

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */


package sort;
public class bubble_sort {
    int[] bubble_sort(int[] unsorted){
        for (int i = 0; i < unsorted.length; i++)
        {
            for (int j = i; j < unsorted.length; j++)
            {
                if (unsorted[i] > unsorted[j])
                {
                    int temp = unsorted[i];
                    unsorted[i] = unsorted[j];
                    unsorted[j] = temp;
                }
            }
        }
        return unsorted;
    }
}

归并排序算法程序：

package sort;
public class mergeSort {
  
   int[] mergeSort(int[] data) {  
        sort(data, 0, data.length - 1);
        return data;
    }  
  
    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);  
        //print(data);  
    }  
    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++];  
        }  
    }   
}

冒泡排序运行时间时间                                                          总的运行时间