第三周作业

来源：互联网发布：fastboot软件多大编辑：程序博客网时间：2024/05/26 15:56

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class Sort {
/**
* @param data：数组
* @param firstBegin：第一个有序表的起始下标
* @param secBegin：第二个有序表的起始下标
* @param secEnd：第二个有序表的终止下标
*/
private static void merge (Object[] data, int firstBegin, int secBegin, int secEnd) {
Object[] temp = new Object[secEnd - firstBegin + 1];
int i = firstBegin, j = secBegin, current = 0;
//第一个有序表的当前匹配下标在[firstBegin, secBegin)
//第二个有序表的当前匹配下标在[secBegin, secEnd]
while (i < secBegin && j <= secEnd) {
if ((Integer)data[i] <= (Integer)data[j]) {
temp[current] = data[i];
current++;
i++;
} else {
temp[current] = data[j];
current++;
j++;
}
}
//第一个有序表的当前匹配下标在[firstBegin, secBegin)，则将后面的元素直接添加在temp表的后面，无序再进行比较
while (i < secBegin) {
temp[current] = data[i];
current++;
i++;
}
//第二个有序表的当前匹配下标在[secBegin, secEnd]，则将后面的元素直接添加在temp表的后面，无序再进行比较
while (j <= secEnd) {
temp[current] = data[j];
current++;
j++;
}
//将匹配好的数据覆盖回data表中原来的位置
System.arraycopy(temp, 0, data, firstBegin, temp.length);
}
/**
* @param data:数据数组
* @param length：每个有序表的长度
*/
private static void mergeSort(Object[] data, int length) {
if (data.length / length == 1) {
return;
}
/**
* size:当前两个有序表的总个数
* compareTime:每两个相邻的有序表比较为一次，总共的比较次数
* remainder:表示两个有序表总数按照size来划分，最终剩下的个数
*/
int size = length * 2;
int compareTimes = data.length / size;
int remainder = data.length % size;
int firstBegin=0, secBegin=0, secEnd=0;
for (int i=0; i<compareTimes; i++) {
firstBegin = i * size;
secBegin = firstBegin + length;
secEnd = secBegin + length- 1;
merge(data, firstBegin, secBegin, secEnd);
}
//如果剩余的个数不为0，则将剩余的元素加入最后的一个有序表中进行排序
if (remainder != 0) {
secEnd = data.length - 1;
secBegin = data.length - remainder;
merge(data, firstBegin, secBegin, secEnd);
}
mergeSort(data, length*2);
}
/**
* 获取文件的数据
*/
private static List<Integer> getData() {
BufferedReader reader;
List<Integer> data = null;
try {
File file = new File("src/largeW.txt");
reader = new BufferedReader(new FileReader(file));
data = new ArrayList<Integer>();
String temp = reader.readLine();
while (temp != null) {
data.add(Integer.valueOf(temp.trim()));
temp = reader.readLine();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return data;
}
/**
* 冒泡排序
*/
private static long bubbleSort(List<Integer> data) {
long beginTime = System.currentTimeMillis();
int amount = data.size();
for (int i=0; i<amount-1; i++) {
for (int j=0; j<amount-i-1; j++) {
if (data.get(j) < data.get(j+1)) {
int temp = data.get(j);
data.set(j, data.get(j+1));
data.set(j+1, temp);
}
}
}
long endTime = System.currentTimeMillis();
return endTime-beginTime;
}
/**
* function：
* 0：代表冒泡排序
* 1：代表归并排序
*/
private static void write2File(Object[] data, int function) {
FileWriter output = null;
try {
if (function == 0) {
output = new FileWriter(new File("src/largeW_bubble.txt"));
} else {
output = new FileWriter(new File("src/largeW_merge.txt"));
}
for (int i=0; i<data.length; i++) {
Integer integer = (Integer)data[i];
output.write(integer + "\n");
}
output.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
output.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
long beginTime, stopTime;
List<Integer> dataList = getData();
Object[] dataArray = dataList.toArray();
//冒泡排序
beginTime = System.currentTimeMillis();
bubbleSort(dataList);
stopTime = System.currentTimeMillis();
System.out.println("冒泡排序总用时：" + (stopTime - beginTime));
write2File(dataList.toArray(), 0);
//归并排序
beginTime = System.currentTimeMillis();
mergeSort(dataArray, 1);
stopTime = System.currentTimeMillis();
System.out.println("归并排序总用时：" + (stopTime - beginTime));
write2File(dataArray, 1);
}
}

0 0