本文目录一览：

Java简单算法问题
java算法问题，请大神帮帮忙
java十大算法

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) {
        List<Integer> list = new LinkedList<Integer>();
        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）。 算法步骤：

从数列中挑出一个元素，称为 "基准"（pivot）
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

算法二：堆排序算法

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序的平均时间复杂度为Ο(nlogn) 。 算法步骤：

创建一个堆H[0..n-1]
把堆首（最大值）和堆尾互换
把堆的尺寸缩小1，并调用shift_down(0)，目的是把新的数组顶端数据调整到相应位置
重复步骤2，直到堆的尺寸为1

算法三：归并排序

归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 算法步骤：

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
设定两个指针，最初位置分别为两个已经排序序列的起始位置
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针达到序列尾
将另一序列剩下的所有元素

java算法求助（java算法教程）