本文目录一览：
Java简单算法问题
初步做了一个出来，但是效率并不是很高，前100个计算速度还可以，但是往后就很慢了。如果什么时候有空的话可以再看看，先给你代码吧，不知道能不能帮上你
public class AlisandaNumber {
private static final int MAX_INDEX = 1000; // 可以先把这个常量改为1-6，验证正确性
public static void main(String[] args) {
int a = 0;
int index = 0;
while(index MAX_INDEX) {
a += 6; // 每次循环自增6，由题目规律可知A是6的倍数
boolean breakOut = false;
// 最大的约数为此数的平方根，因为如果是两个平方根相乘的话，剩下的就只有1了
int maxNum = (int) Math.ceil(Math.sqrt(a));
p:
for(int p = 1; p = maxNum; p ++) {
if(a % p != 0) {
continue; // 如果不是约数的话，没必要考虑，下同
}
// 最大约数为平方根的相反数，原理同上
maxNum = (int) Math.ceil(Math.sqrt(a / p));
for(int q = -1; q = -maxNum; q --) { // q和r必为负数
if(a % q != 0) {
continue;
}
int r = a / (p * q);
int nonZero = p * q + p * r + q * r;
if (nonZero == 0) {
continue;
}
if((a == p * q * r) (a == (p * q * r) / (nonZero))) {
index ++;
breakOut = true;
break p; // 跳出外层循环
}
}
}
if(breakOut) {
System.out.println(String.format("第%d个压力山大数是%d", index, a));
}
}
}
}
java算法问题，请大神帮帮忙
其实都很容易的，关键是你要理解heap的含义。完整代码如下：
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
public class Assessment1 {
public static void main(String[] args) {
// DO NOT EDIT THIS METHOD
Framework FW = new Framework();
FW.parseArgs(args);
int[] heap = FW.getHeap();
int testType = FW.getTestType();
Test test = new Test();
if (testType == 0) // Test for heap
FW.parseResult(test.isHeap(heap));
else if (testType == 1) // Test for smallest values
FW.parseResult(test.smallest3(heap));
}
}
/**
* This class allow for the safe initialisation of your code in the automated
* system You MUST NOT modify this class
*/
class Framework {
private int[] heap;
private int testType;
public int[] getHeap() {
return heap;
}
public int getTestType() {
return testType;
}
private void loadHeap(String filePath) {
ListInteger list = new LinkedListInteger();
try {
BufferedReader fR = new BufferedReader(new FileReader(filePath));
String tmp;
while ((tmp = fR.readLine()) != null) {
list.add(Integer.parseInt(tmp));
}
} catch (Exception e) {
e.printStackTrace();
System.out.println("Data set missing!");
System.exit(1);
}
heap = new int[list.size()];
int i = 0;
for (Integer val : list) {
heap[i] = val;
i++;
}
}
public void parseArgs(String[] args) {
String split[];
for (String arg : args) {
split = arg.split("=", 2);
if (split[0].equalsIgnoreCase("-dataset"))
loadHeap(split[1]);
else if (split[0].equalsIgnoreCase("-testtype"))
testType = Integer.parseInt(split[1]);
}
}
public void parseResult(boolean bool) {
if (bool == true)
System.out.println(1);
else
System.out.println(0);
}
public void parseResult(int[] intArray) {
boolean first = true;
for (int i : intArray) {
if (!first)
System.out.print(",");
else
first = false;
System.out.print(i);
}
}
}
class Test {
/**
* Will receive an integer heap array, method will return true or false
* depending on whether the array is believed to be a valid heap or not
*
* @param heap
* 0-based integer array
* @return true if integer array is a heap, else false
*/
public boolean isHeap(int[] heap) {
if(heap == null || heap.length == 0){
return false;
}
int[] ary = new int[heap.length];
for(int i = 0; i heap.length; i++){
ary[i] = heap[i];
}
Arrays.sort(ary);
for(int i = 0; i heap.length; i++){
if(ary[i] != heap[i]){
return false;
}
}
return true;
}
/**
* Will receive an integer heap array, method will return the 3 smallest
* values within the heap
*
* @param heap
* @return The smallest 3 elements within the heap, ordered ascending
*/
public int[] smallest3(int[] heap) {
// TODO You must implement this method
//这里其实应该先检查辖heap == null?如果heap不够3个元素呢？
int[] smallest = new int[3];
//用Math.min(heap.length, 3)防止heap不够3个元素的情况。如果不够3个，剩下的其他元//素为0，例如heap为1 5，那么返回数组为 0 1 5
for(int i = 0; i Math.min(heap.length, 3); i++){
smallest[i] = heap[i];
}
Arrays.sort(smallest);
return smallest;
}
}
java十大算法
算法一：快速排序算法
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。
算法步骤：
1 从数列中挑出一个元素，称为 "基准"（pivot），
2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
算法二：堆排序算法
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
堆排序的平均时间复杂度为Ο(nlogn) 。
算法步骤：
创建一个堆H[0..n-1]
把堆首（最大值）和堆尾互换
3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置
4. 重复步骤2，直到堆的尺寸为1
算法三：归并排序
归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
算法步骤：
1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针达到序列尾
5. 将另一序列剩下的所有元素