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

本文目录一览：

• 1、Java简单算法问题
• 2、java算法问题，请大神帮帮忙
• 3、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) {

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. 将另一序列剩下的所有元素