计科1111-1114班第二次实验作业（算法基本功 与 综合思考）

1）算法基本功——快速排序

    对文件 largeW.txt（下载链接）中的数据，应用快速排序算法进行排序，并与冒泡排序、归并排序进行时间比较。体验算法复杂度对设计算法的影响。

package ceshi;


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;


public class test {
static int len=0;
public static void bubbleSort(String bssz[]) throws IOException
{
int comp=0;
String a=" ";
 for(int i =0;i <len-1;i++)
 {  
       for(int j =i+1;j<len;j++)
       {  
           comp=bssz[i].compareTo(bssz[j]);  
           if(comp>0)
           {  
               a=bssz[i];  
               bssz[i]=bssz[j];  
               bssz[j]=a;  
           }  


       } 
 }
 FileWriter fw =new FileWriter("F:\\largeW_bubble.txt");  
          BufferedWriter writer =new BufferedWriter(fw);  
          for(int i=0;i<len;i++){  
              writer.write(bssz[i]+"\r");  
              writer.newLine();
          }  
 writer.flush();
 writer.close();
}
public static void partition(String[] arr,int head,int tail) throws IOException{  
       if(head < tail){  
           int mid = (head+tail )/2;  
           partition(arr,head,mid);
           partition(arr,mid+1,tail);
           mergeSort(arr,head,tail,mid);  
       }  
   }  
         
 
   public static void mergeSort(String[] arr,int head,int tail,int mid) throws IOException{  
       String[] tArr = new String[tail];
       int tArrIndex = 0;  
       int part1ArrIndex = head;
       int part2ArrIndex = mid+1;
       int l;  
             
       while((part1ArrIndex <= mid)&&(part2ArrIndex <= tail)){ 
           l = arr[part1ArrIndex].compareTo(arr[part2ArrIndex]);
           if(l < 0){  
               tArr[tArrIndex ++] = arr[part1ArrIndex ++];  
           }  
           else{  
               tArr[tArrIndex ++] = arr[part2ArrIndex ++];  
           }  
       }  
             
       while(part1ArrIndex < mid){  
           tArr[tArrIndex ++] = arr[part1ArrIndex ++];  
       }  
             
       while(part2ArrIndex < mid){  
           tArr[tArrIndex ++] = arr[part2ArrIndex ++];  
       }  
       
       FileWriter fw1=new FileWriter("F:\\largeW_merge.txt");  
       BufferedWriter writer1=new BufferedWriter(fw1);  
       for(int i=0;i<len;i++){  
           writer1.write(arr[i]+"\r");  
           writer1.newLine();
       }  
writer1.flush();
writer1.close();


      
   }  


   public static int Partition(int a[],int p,int r){
int x=a[r-1];
int i=p-1;
int temp;
   for(int j=p;j<=r-1;j++){
    if(a[j-1]<=x){
    // swap(a[j-1],a[i-1]);
    i++;
    temp=a[j-1];
    a[j-1]=a[i-1];
    a[i-1]=temp;


}
   }
   //swap(a[r-1,a[i+1-1]);
   temp=a[r-1];
   a[r-1]=a[i+1-1];
   a[i+1-1]=temp;
   
   return i+1;


}

public static void QuickSort(int a[],int p,int r) throws IOException{

if(p<r){
int q=Partition(a,p,r);
QuickSort(a,p,q-1);
QuickSort(a,q+1,r);

}
    FileWriter fw1=new FileWriter("F:\\largeW_quick.txt");  
      BufferedWriter writer1=new BufferedWriter(fw1);  
      for(int i=0;i<len;i++){  
          writer1.write(a[i]+"\r");  
          writer1.newLine();
      }  
writer1.flush();
writer1.close();

}




         
public static void main(String args[]) throws IOException
{
BufferedReader ip = new BufferedReader(new FileReader("F:\\largeW.txt"));
while((ip.readLine())!=null)
{
len++;
}
ip.close();
        
String[] sz=new String[len];
FileReader FR1 =new FileReader("F:\\largeW.txt");  
        BufferedReader BR1=new BufferedReader(FR1);  
        String a=" ";
    int t=0;
        while((a=BR1.readLine()) !=null){  
            sz[t]=a;  
            t++;  
        }  
      
        long startTime =System.currentTimeMillis();
        bubbleSort(sz);  
        long endTime =System.currentTimeMillis();
        System.out.println("冒泡排序运行时间： "+(endTime -startTime) +"ms");  
          
        
        long startTime1=System.currentTimeMillis();
        partition(sz,0,len-1);  
        long endTime1=System.currentTimeMillis();
        System.out.println("归并排序运行时间： "+(endTime1-startTime1)+"ms");  
        
        int in[]=new int[len];
        for(int q=0;q<len;q++)
        {
        in[q]=Integer.parseInt(sz[q]);
        }
        long startTime2=System.currentTimeMillis();
       QuickSort(in,1,len-1); 
       long endTime2=System.currentTimeMillis();
       System.out.println("快速排序运行时间： "+(endTime1-startTime1)+"ms"); 
      
     
}
}

由于数据过多，运行了很久都还没出结果，所以就不上传结果了。

经小型数据测试，代码可行。

2）经典算法面试题（至少选择其中1道题并作答，有自己的思考与理解）

1.有一个整数数组，请求出两两之差绝对值最小的值，记住，只要得出最小值即可，不需要求出是哪两个数。

答：先进行排序，得到一个有序数列a[]，然后a[0]减a[1]，a[1]-a[2]，……一直下去。

虽然这不是一个最快的方法，但我的能力之内只能想到这样。

2.在排序数组中，找出给定数字的出现次数，比如 [1, 2, 2, 2, 3] 中2的出现次数是3次。

答：可以先用二分法先确定一个区间，然后在区间里遍历比较，用给定的数字减去待遍历的数据，小于的时候继续查找，等于0时计数器count+1，大于的时候结束，输出count。