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

1.冒泡排序和归并排序

package co;
import java.io.BufferedReader;  
import java.io.BufferedWriter;  
import java.io.File;  
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.Date;  
import java.util.List;  
  
public class ArangeMent{  
    /** 
     *  冒泡排序和归并排序 
    */  
    static String Path="e:/123.txt";  
    static String bubbleSortDesPath="e:/largeW_bubble.txt";    //冒泡排序后结果的存放位置  
    static String mergeSortDesPath="e:/largeW_merge.txt";      //归并排序后结果的存放位置  
    public static void main(String[] args) {  
        try {  
            File file=new File(Path);  
            FileInputStream fis=new FileInputStream(file);  
            InputStreamReader reader=new InputStreamReader(fis, "utf-8");  
            BufferedReader bufferedreader=new BufferedReader(reader);   
            String nums="";  
            int num=0;  
            List<Integer> list=new ArrayList<Integer>();  
            while((nums=bufferedreader.readLine())!=null){  
                num=num+1;  
                list.add(Integer.parseInt(nums.trim()));  
            }  
            Integer[] NumsArray=(Integer[])list.toArray(new Integer[num]);  
            //开始冒泡排序  
            long timeStart=System.currentTimeMillis();  //开始冒泡排序计时  
            bubbleSort(NumsArray);  
            long timeEnd=System.currentTimeMillis();    //冒泡排序计时结束   
            System.out.println("冒泡排序所花费的时间是："+(timeEnd-timeStart)+"毫秒");  
            //把冒泡排序的结果写到文本文件  
            ResultSortWriteTxt(NumsArray,0);  
            //开始归并排序  
            NumsArray=(Integer[])list.toArray(new Integer[num]);//为了防止冒泡排序之后的数组对归并排序产生影响，所以重新赋值  
            Integer[] num1=new Integer[NumsArray.length];  
            timeStart=System.currentTimeMillis();       //开始归并排序计时  
            Integer[] result  = mergeSort(NumsArray,0, NumsArray.length - 1,num1);   
            timeEnd=System.currentTimeMillis();     //归并排序计时结束  
            System.out.println("归并排序所花费的时间是："+(timeEnd-timeStart)+"毫秒");  
            //把归并排序的结果写到文本文件  
            ResultSortWriteTxt(result,1);  
            System.out.println("文本中总共有："+num+"条数据!");  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
    /** 
     * 冒泡排序 
     * @param NumsArray 
     * @throws IOException  
    */  
    public static void bubbleSort(Integer[] Array)throws IOException{  
        Integer[] NumsArray=(Integer[]) Array;  
        int temp=0;  
         for(int i=0;i<NumsArray.length;i++){  
             for(int j=i+1;j<NumsArray.length;j++){  
                 if(NumsArray[i]>NumsArray[j]){  
                    temp=NumsArray[i];  
                    NumsArray[i]=NumsArray[j];  
                    NumsArray[j]=temp;  
                 }  
             }  
            // System.out.println(NumsArray[i]);//输出每次用冒泡排序后的结果  
         }  
    }  
    /** 
     * 把排序的结果写到文本文件 
     * @param NumsArray 
     * @throws IOException 
    */  
    public static void  ResultSortWriteTxt(Integer[] NumsArray,int whichSort) throws IOException{  
         //循环输出冒泡排序后的数据到文本文件  
         File file=null;  
         if(whichSort==0){              //冒泡排序是表示0  
             file =new File(bubbleSortDesPath);  
         }else if(whichSort==1){        //归并排序是表示1  
             file =new File(mergeSortDesPath);  
         }  
         if(!file.exists()){  
             file.createNewFile();  
         }  
         FileOutputStream fos=new FileOutputStream(file);  
         BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(fos,"utf-8"));  
         for(int i=0;i<NumsArray.length;i++){  
             //System.out.println(NumsArray[i]);  
             bw.write(NumsArray[i].toString()+"\r\n");  
             bw.flush();                    //每写入一次字节流数据刷新一次  
         }  
         fos.close();  
         bw.close();  
    }  
    /** 
     * 归并排序 
     * @param Array 
     */  
     private static Integer[] mergeSort(Integer[] num, int s, int t, Integer[] num1) {  
            int temp;  
            Integer[] num2 = new Integer[t + 1];  
            if (s == t){  
             num1[s] = num[s];  
            }else {  
             temp = (s + t) / 2;  
             mergeSort(num, s, temp, num2);         //左半部分递归调用  
             mergeSort(num, temp + 1, t, num2);     //右半部分递归调用  
             merg(num2, s, temp, t, num1);          //由num2去归并，返回的值放到num1中,num1赋新值，其实就是更新num2,然后让num2再去归并，返回新的num1  
            }  
            return num1;  
     }  
     //有序表的合并  
     private static void merg(Integer[] num2, int l, int m, int n, Integer[] num1) {  
         int i, j, k;  
         i = l;  
         j = m + 1;  
         k = l;  
         while (i <= m && j <= n) {  
             if (num2[i] < num2[j]){  
              num1[k++] = num2[i++];  
             }else{  
              num1[k++] = num2[j++];  
             }  
          }  
         while (i <= m) {  
             num1[k++] = num2[i++];  
          }  
         while (j <= n) {  
             num1[k++] = num2[j++];  
         }  
    }   
}