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