第三周作业——冒泡排序和归并排序（运行归并算法）

主要是运行归并排序：

package exercise3;

		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.List;

		public class mergeSort {
			 
			private static BufferedReader bufferedreader;  
					
			public static void main(String[] args) throws IOException{	
			
				bufferedreader = new BufferedReader(new InputStreamReader(new FileInputStream(new File("自定\\Desktop\\largeW.txt")), "gb2312"));   
				String getData="";  
				int num=0;  
				List<Integer> list=new ArrayList<Integer>();  
				while((getData=bufferedreader.readLine())!=null){  
					num=num+1;  
					list.add(Integer.parseInt(getData.trim()));  
			    }  
			    Integer[] dataArray=(Integer[])list.toArray(new Integer[num]);  
			    long timeStart=System.currentTimeMillis(); 
//			    bubbleSort(dataArray);  冒泡算法的实现
			    mergeSort(dataArray,0,1);
			    long timeEnd=System.currentTimeMillis(); 
			    write(dataArray); 
	           System.out.println("largeW.txt文本中总共有："+num+"个数据！！！对现在的我们来说好吓人啊~~~ OoO\n"+"该数据冒泡排序所花费的时间是：\n"+(timeEnd-timeStart)*1000000+"纳秒  \n 哈哈！吓到了吧，那么鬼长！我故意的，你咬我啊!(胡一菲的话真是好用*o*)");	     
			}
			
			 /**
		    　*　<pre>
		    　*　二路归并
		    　*　原理：将两个有序表合并和一个有序表
		    　*　</pre>
		    　*　@param　a
		    　*　@param　s
		    　*　第一个有序表的起始下标
		    　*　@param　m
		    　*　第二个有序表的起始下标
		    　*　@param　t
		    　*　第二个有序表的结束小标	    　*　
		    　*/
		    private static void merge(Integer[]a,int s,int m,int t){
		    	Integer[] tmp=new Integer[t-s+1];
		        int i=s,j=m,k=0;
		        while(i<m&&j<=t){
		            if(a[i]<=a[j]){
		                tmp[k]=a[i];
		                k++;
		                i++;
		            }else{
		                tmp[k]=a[j];
		                j++;
		                k++;
		            }
		        }
		        while(i<m){
		            tmp[k]=a[i];
		            i++;
		            k++;
		        }
		 
		        while(j<=t){
		            tmp[k]=a[j];
		            j++;
		            k++;
		        }
		        System.arraycopy(tmp,0,a,s,tmp.length);
		    }
		 
		    /**
		    　*　
		    　*　@param　a
		    　*　@param　s
		    　*　@param　len
		    　*　每次归并的有序集合的长度
		    　*/
		    public static void mergeSort(Integer[]a,int s,int len){
		    	Integer size=a.length;
		        int mid=size/(len<<1);
		        int c=size&((len<<1)-1);
		        //　-------归并到只剩一个有序集合的时候结束算法-------//
		        if(mid==0)
		            return;
		        //　------进行一趟归并排序-------//
		        for(int i=0;i<mid;++i){
		            s=i*2*len;
		            merge(a,s,s+len,(len<<1)+s-1);
		        }
		        //　-------将剩下的数和倒数一个有序集合归并-------//
		        if(c!=0)
		            merge(a,size-c-2*len,size-c,size-1);
		        //　-------递归执行下一趟归并排序------//
		        mergeSort(a,0,2*len);
		    }
		    
		    //冒泡算法的排序	 
//			private static void bubbleSort(Integer[] dataArray) throws IOException{
//			        Integer[] arr=(Integer[]) dataArray;  
//			        int temp=0;  
//			         for(int i=0;i<arr.length;i++){  
//			             for(int j=i+1;j<arr.length;j++){  
//			                 if(arr[i]>arr[j]){  
//			                    temp=arr[i];  
//			                    arr[i]=arr[j];  
//			                    arr[j]=temp;  
//			                 }  
//			             }  
//			         }  
//			    }  
			 
			 public static void  write(Integer[] arr) throws IOException{  
		         System.out.println("排序后的文件已经创建，保存在:\n 自定\\Desktop\\largeW_merge.txt");  
		        // File file=null;        
		         File file =new File("自定\\Desktop\\largeW_merge.txt");          
		         if(!file.exists()){  
		             file.createNewFile();  
		         }  
		         FileOutputStream fos=new FileOutputStream(file);  
		         BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(fos,"gb2312"));  
		         for(int i=0;i<arr.length;i++){  
		             writer.write(arr[i].toString()+"\r\n");  
		             writer.flush();  
		         }  
		         fos.close();  
		         writer.close();  
		    }  	
}

排序后的结果：