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

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 ArrangeMent{
	/**
	 *  冒泡排序和归并排序
	*/
	static String Path="D:/largeW.txt";
	static String bubbleSortDesPath="src/largeW_bubble.txt";	//冒泡排序后结果的存放位置
	static String mergeSortDesPath="src/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, "gb2312");
			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)/1000+"秒");
			//把冒泡排序的结果写到文本文件
			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)/1000+"秒");
			//把归并排序的结果写到文本文件
			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,"gb2312"));
		 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++];
		 }
	} 
}

由于数据繁多.挑选出前面的4060个数据进行处理.