public class Test {
//定義第一個靜態整數類型的集合用於存儲最終的數字結果
private static ArrayList<Integer> integers = new ArrayList<>();
//定義第二個靜態整數類型的集合用於存儲最終的數字結果
private static ArrayList<Integer> integers2 = new ArrayList<>();
//先創建一個靜態鍵盤錄入掃描的對象
private static Scanner scanner = new Scanner(System.in);
//定義主方法
public static void main(String[] args) {
//定義一個死循環
while (true){
//提示用戶輸入，並接收
System.out.println("請輸入小寫字母a或b或c或d");
String s = scanner.nextLine();
//用switch單只匹配
switch (s){
//當輸入的值是「a」時，為基數
case "a":
//調用方法
ArrayList<Integer> cardinalNumber = isCardinalNumber();
//列印集合
System.out.println("100以內的基數有："+cardinalNumber);
break;
//當輸入的值是「b」時，為偶數
case "b":
//調用方法
ArrayList<Integer> evenNumbers = isEvenNumbers();
//列印集合
System.out.println("100以內的偶數有："+evenNumbers);
break;
//當輸入的值是「c」時，為質數
case "c":
//調用方法
ArrayList<Integer> primeNumber = isPrimeNumber();
//列印集合
System.out.println("100以內的質數有："+primeNumber);
break;
//當輸入的值是「d」時，為合數
case "d":
//調用方法
ArrayList<Integer> totalNumber = isTotalNumber();
//列印集合
System.out.println("100以內的合數有："+totalNumber);
break;
//當輸入的值是「ac」時，為即是基數又是質數
case "ac":
//調用方法
ArrayList<Integer> cardinalNumberAndPrimeNumber = ();
//列印集合
System.out.println("100以內的即是基數又是質數有："+cardinalNumberAndPrimeNumber);
break;
default:
System.out.println("您只可以輸入一下小寫字母：a，b，c，d，ac");
}
}
}
/**
* 封裝方法，判斷是否是基數
* @return
*/
public static ArrayList<Integer> isCardinalNumber(){
//先清空集合
integers.clear();
//定義for循環遍歷到所有的100以內的整數
for (int i = 0; i <= 100; i++) {
//判斷出所有的基數並保存到集合中
if (i % 2 != 0){
integers.add(i);
}
}
return integers;
}
/**
* 封裝方法：是否是偶數
* @return
*/
public static ArrayList<Integer> isEvenNumbers(){
//先清空集合
integers.clear();
//定義for循環遍歷到所有的100以內的整數
for (int i = 0; i <= 100; i++) {
//判斷出所有的偶數並保存到集合中
if (i % 2 == 0)integers.add(i);
}
return integers;
}
/**
* 封裝方法：是否是質數
* @return
*/
public static ArrayList<Integer> isPrimeNumber(){
//先清空集合
integers.clear();
//定義外循環遍歷到2到100的數，1直接跳過
for(int i = 2 ; i <= 100;i++) {
//1、定義一個標記
boolean flag = true;
//定義內循環，Math.squart()取i平方根，對其它數取余能整除就不是質數。固定演算法
for(int j = 2; j <= (int)Math.sqrt(i); j++) {
if(i % j == 0) {
//2、更改標記
flag = false;
break;
}
}
//3、得結論
if(flag) {
integers.add(i);
}
}
return integers;
}
/**
* 封裝方法：是否是合數
* @return
*/
public static ArrayList<Integer> isTotalNumber(){
//先清空集合
integers.clear();
//定義外循環遍歷到2到100的數，1直接跳過
for(int i = 2 ; i <= 100;i++) {
//1、定義標記
boolean flag = false;
//定義內循環。能被1或自身或其它數整除就是合數
for(int j = 2; j < i; j++) {
if(i % j == 0) {
//2、更改標記
flag = true;
break;
}
}
//3、得結論
if(flag) {
integers.add(i);
}
}
return integers;
}
/**
* 封裝方法：即是基數又是質數
* @return
*/
public static ArrayList<Integer> (){
//先選出基數
ArrayList<Integer> cardinalNumber = isCardinalNumber();
//再從集合中選出質數
//定義外循環遍歷集合
for (Integer integer : cardinalNumber) {
//1、定義一個標記
boolean flag = true;
//定義內循環，Math.squart()取i平方根，對其它數取余能整除就不是質數。固定演算法
for(int j = 2; j <= (int)Math.sqrt(integer); j++) {
if(integer % j == 0) {
//2、更改標記
flag = false;
break;
}
}
//3、得結論
if(flag) {
integers2.add(integer);
}
}
return integers2;
}
//最後就是不用說了吧。自己組合。從已有的集合中選數字就行。這樣能避免復雜的判斷出現的錯誤
}
2. java程序1到200的質數。代碼如下
一個好的演算法，要經的起推敲，不要只求結果
importjava.util.ArrayList;
importjava.util.List;
publicclassPrimes{
publicstaticvoidmain(String[]args){
//求素數
List<Integer>primes=getPrimes(200);
//輸出結果
for(inti=0;i<primes.size();i++){
Integerprime=primes.get(i);
System.out.printf("%8d",prime);
if(i%10==9){
System.out.println();
}
}
}
/**
*求n以內的所有素數
*
*@paramn
*范圍
*
*@returnn以內的所有素數
*/
privatestaticList<Integer>getPrimes(intn){
List<Integer>result=newArrayList<Integer>();
result.add(2);
for(inti=3;i<=n;i+=2){
if(!divisible(i,result)){
result.add(i);
}
}
returnresult;
}
/**
*判斷n是否能被整除
*
*@paramn
*要判斷的數字
*@paramprimes
*包含素數的列表
*
*@return如果n能被primes中任何一個整除，則返回true。
*/
privatestaticbooleandivisible(intn,List<Integer>primes){
for(Integerprime:primes){
if(n%prime==0){
returntrue;
}
}
returnfalse;
}
}
3. 要求用JAVA編程輸出3---100以間的所有素數。
最有效率的演算法，請看下面
package number;
import java.util.HashMap;
import java.util.Map;
/**
* 查找小於某個數的所有素數。
* 最簡單的方法就是試除法，將該數N用小於等於N的平方根的所有素數去試除，若均無法整除，則N為素數。
* @author Owner
*
*/
public class CheckPrime {
/**
* 用來保存所有已查找到的素數，為後面驗證N為素數時提供小於N的平方根的素數。
*/
private static Map<String, CheckPrime> primeMap = new HashMap<String, CheckPrime>();
private int value;
private boolean isPrime = true;
public boolean isPrime(){
if(value < 4)
// 如果小於4，則一定為素數。
isPrime = true;
else {
// 獲取小於等於平方根的最小正整數。
int sqrtValue = Integer.parseInt(String.valueOf(Math.sqrt((double)value)).replaceAll("\\..*", ""));
for(int i = sqrtValue; i > 1; i --){
// 獲取下雨平方根的所有素數進行判斷
CheckPrime subPrime = primeMap.get(i + "");
if(subPrime != null){
if(this.value % subPrime.value == 0){
// 如果能被某個素數整除，則為質數，跳出循環
isPrime = false;
break;
}
}
}
}
return isPrime;
}
public static void savePrime(int primeValue){
CheckPrime prime = new CheckPrime();
prime.value = primeValue;
primeMap.put("" + primeValue, prime);
System.out.println(primeValue);
}
public static void main(String[] args) {
for(int i = 2; i < 100; i ++){
CheckPrime prime = new CheckPrime();
prime.value = i;
if(prime.isPrime())
CheckPrime.savePrime(i);
}
}
}
4. JAVA:輸出1-100之間的所有質數，寫出一種可用演算法步驟，開頭已給出
從1到50循環
然後讓每一個數循環除23456789
如果這8次除的結果都不是整數或者=1，那麼為質數
如果這8次除的結果有整數且不等於1，那麼為合數，跳出此次循環
進行下一循環
演算法不是最好，不過簡單易懂
希望有幫助
5. 去哪兒網java開發面試經驗牛客
以下是某位求職者面經，僅供參考：
一面:
1.自我介紹
2.直接上手紅黑樹和平衡二叉樹區別
3.紅黑樹的旋轉
2node節點插入和3node節點插入時候旋轉的情況 簡述偽代碼
4.問項目情況。大概半小時 5.concurrenthashmap
結構分析。 刪除和獲取操作過程描述。就是segment. Entry.
除了value 為volatile 其餘都是final.
刪除和獲取操作等等。例如：刪除操作是將entry要刪除的節點的前半部分鏈表進行復制，並指向當前刪除節點的後面節點。（因為next是final的，不可以進行修改，只有entry的表頭可以修改）
不詳述了。
6.索引的優缺點 什麼時候索引不起作用？ 在什麼地方可以使用索引？
7.jvm
多態原理。invokestatic invokeinterface
等指令。常量池中的符號引用 找到直接引用。在堆中找到實例對象，獲取到偏移量，由偏移量在方法表中指出調用的具體方法。介面是在方法表中進行掃描）等等扯了半天
8.os: 頁面調度演算法 幾種 分別說一下 LRU FIFO 最佳適應演算法
9.內存管理： 固定分區 動態分區 段 頁 都講講 （哈哈）
10.自己實現一下LRU演算法
8.怎麼學習。看過什麼書
二面：
1.自我介紹
2.項目中與app移動端 的json格式設計
3.hashmap的缺點 具體提現在哪裡？
4.Collections.sort()
的原理---本質上調用的是Arrays.sort() 內部是 使用的歸並排序 接著寫了一下歸並（輔助數組的歸並，和手搖演算法的歸並）
5.一個字元串數組，現給定一個string去進行找出對應的數組中字元串的下標 （可以有容錯，但兩字元串長度必須一致，容錯為2）
例如：
["hello","hj","abc"]
key=「hellg" 返回下角標0
6.jvm參數調優 jvm堆的大小調優
MaxTureningShelod newratio -xxs -xxm -persize
7.圖的 prime
演算法
kruskal
演算法
dijkstra演算法 解決什麼問題？ 分別寫一下
偽代碼
8.設計模式： 單例模式（懶漢餓漢） 工廠方法模式 觀察者模式 責任鏈模式
9.項目 又問了一些
10.平時怎麼學習？
三面：
1.自我介紹
2.自己優缺點
3.目前有幾個offer
4.工作地點要求
5.在校實驗室做項目，你認為最大的收獲是什麼
6.評價一下自己的大學生活
7.講了一下福利 之類的
現場書面offer沒了，所以只好等等郵寄，不過還好給了一個布偶紀念品
6. java教師工作量計演算法
/**
* 我寫了一個 希望 有用
*
* 如果 哪位高手 有興趣
* 幫忙 實現 一下 Teacher 類中的 private void checkClassRepeat() 方法 感謝！！
*/
==================================第一個類 TypeValue
package org.wood.teacher;
/**
* 創建 各種系數常量
* @author Administrator
*
*/
public interface TypeValue {
/**
* 理論課系數 1.2
*/
double COURSE_TYPE_THEORY_VALUE = 1.2;
/**
* 實訓課系數 0.8
*/
double COURSE_TYPE_PRACTISE_VALUE = 0.8;
/**
* 班級系數
*/
/**
* 小於40人 系數1
*/
double CLASS_TYPE_STUDENT_NUMBER_UNDER_40_VALUE = 1.0;
/**
* 大於等於40人且小於80人 系數1.1
*/
double CLASS_TYPE_STUDENT_NUMBER_BETWEEN_40_AND_80_VALUE = 1.1;
/**
* 大於等於80人且小於100人 系數1.2
*/
double CLASS_TYPE_STUDENT_NUMBER_BETWEEN_80_AND_100_VALUE = 1.2;
/**
* 大於等於100人 系數1.3
*/
double CLASS_TYPE_STUDENT_NUMBER_ABOVE_100_VALUE = 1.3;
/**
* 職稱系數
*/
/**
* 助教 系數1
*/
double LEVEL_TYPE_ASISITANT_VALUE = 1.0;
/**
* 講師 系數1.2
*/
double LEVEL_TYPE_DOCENT_VALUE = 1.2;
/**
* 副教授 系數1.5
*/
double LEVEL_TYPE_ASSOCIATE_PROFESSOR_VALUE = 1.5;
/**
* 正教授 系數2
*/
double LEVEL_TYPE_PROFESSOR_VALUE = 2.0;
/**
* 理論課重復系數
*/
/**
* 重復課系數
*/
double REPEAT_COURSE_VALUE = 0.8;
/**
* 非重復課 系數
*/
double UNREPEAT_COURSE_VALUE = 1;
}
==================================第二個類 Class類
package org.wood.teacher;
/**
* 班級類 包含
* 班級號 classId
* 班級課程類別(courseName)：如java，c++，.net或其他
* 班級人數(studentNumber)
* 班級理論課時間(theoryTime)
* 班級實訓（實踐）課時間(practiseTime)
* 班級是不是重復的 repeat(如果是重復的，計算該班級的工作量時，使用的系數與重復的不一樣)
* repeat屬性，比較特殊，需要在統計該班的工作量之前，確定該班是否是重復了。
* repeat=true; 重復的
* repeat=false; 班級非重復的
*
* 核心方法 calculateClassWorkload
* 該方法 用來計算 帶此班的老師的工作量，有一個參數，就是老師的職稱系數。
*
* 如：30(理論課天數)*1.2（理論課系數）*1.1（60人,學生人數系數）*1.2（職稱系數）*1(非重復系數，人多的班級) + 10(實踐天數)*0.8（實踐課系數）*1.1（60人，學生人數系數）*1.2（職稱系數）
*
* 30(理論課天數)*1.2（理論課系數）*1.1（60人,學生人數系數）*1.2（職稱系數）*0.8(重復系數，人少的班級) + 10(實踐天數)*0.8（實踐課系數）*1.1（60人，學生人數系數）*1.2（職稱系數）
* @author Administrator
*
*/
public class Class {
private int classId;
// 班級課程類別
private String courseName;
// 班級人數
private int studentNumber;
// 班級理論課時間
private int theoryTime;
// 班級實訓（實踐）課時間
private int practiseTime;
private boolean repeat;
public Class() {
super();
}
public Class(int classId, String courseName, int studentNumber,
int theoryTime, int practiseTime) {
super();
this.classId = classId;
this.courseName = courseName;
this.studentNumber = studentNumber;
this.theoryTime = theoryTime;
this.practiseTime = practiseTime;
}
/**
* 計算班級工作量 參數 為 老師的 職稱系數
*
* @param teacherLevlValue(參數為 該老師的 職稱的系數）
* @return
*/
public double calculateClassWorkload(double teacherLevelValue) {
/**
* 判斷是否是重復的課程
*/
if (this.repeat) {
System.out.println(this.courseName+" "+this.classId+"班，重復了！");
System.out.println(
this.theoryTime+" * "
+ TypeValue.COURSE_TYPE_THEORY_VALUE+" * "
+()+" * "
+teacherLevelValue+" * "
+TypeValue.REPEAT_COURSE_VALUE +"(重復系數) + "
+this.practiseTime+" * "
+ TypeValue.COURSE_TYPE_PRACTISE_VALUE+" * "
+()+" * "
+teacherLevelValue);
/**
* 重復的班級 工作量演算法
* 30(理論課天數)*1.2（理論課系數）*1.1（60人,學生人數系數）*1.2（職稱系數）*0.8(重復系數，人少的班級) + 10(實踐天數)*0.8（實踐課系數）*1.1（60人，學生人數系數）*1.2（職稱系數）
*/
return this.theoryTime
* TypeValue.COURSE_TYPE_THEORY_VALUE
* ()
* teacherLevelValue
* TypeValue.REPEAT_COURSE_VALUE
+ this.practiseTime
* TypeValue.COURSE_TYPE_PRACTISE_VALUE
* ()
* teacherLevelValue;
} else {
// System.out.println(this.classId+"班，非重復！");
System.out.println(
this.theoryTime+" * "
+ TypeValue.COURSE_TYPE_THEORY_VALUE+" * "
+()+" * "
+teacherLevelValue+" * "
+TypeValue.UNREPEAT_COURSE_VALUE +"(非重復系數) + "
+this.practiseTime+" * "
+ TypeValue.COURSE_TYPE_PRACTISE_VALUE+" * "
+()+" * "
+teacherLevelValue);
/**
* 非重復的班級的 工作量的演算法
* 30(理論課天數)*1.2（理論課系數）*1.1（60人,學生人數系數）*1.2（職稱系數）*1(非重復系數，人多的班級) + 10(實踐天數)*0.8（實踐課系數）*1.1（60人，學生人數系數）*1.2（職稱系數）
*/
return this.theoryTime
* TypeValue.COURSE_TYPE_THEORY_VALUE
* ()
* teacherLevelValue
* TypeValue.UNREPEAT_COURSE_VALUE
+ this.practiseTime
* TypeValue.COURSE_TYPE_PRACTISE_VALUE
* ()
* teacherLevelValue;
}
}
/**
* 獲取班級 人數系數
*
* @return
*/
private double () {
if (this.studentNumber > 0 && this.studentNumber < 40) {
return TypeValue.CLASS_TYPE_STUDENT_NUMBER_UNDER_40_VALUE;
} else if (this.studentNumber >= 40 && this.studentNumber < 80) {
return TypeValue.CLASS_TYPE_STUDENT_NUMBER_BETWEEN_40_AND_80_VALUE;
} else if (this.studentNumber >= 80 && this.studentNumber < 100) {
return TypeValue.CLASS_TYPE_STUDENT_NUMBER_BETWEEN_80_AND_100_VALUE;
} else if (this.studentNumber >= 100) {
return TypeValue.CLASS_TYPE_STUDENT_NUMBER_ABOVE_100_VALUE;
}
return -1;
}
public int getClassId() {
return classId;
}
public void setClassId(int classId) {
this.classId = classId;
}
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}
public int getStudentNumber() {
return studentNumber;
}
public void setStudentNumber(int studentNumber) {
this.studentNumber = studentNumber;
}
public int getTheoryTime() {
return theoryTime;
}
public void setTheoryTime(int theoryTime) {
this.theoryTime = theoryTime;
}
public int getPractiseTime() {
return practiseTime;
}
public void setPractiseTime(int practiseTime) {
this.practiseTime = practiseTime;
}
public boolean isRepeat() {
return repeat;
}
public void setRepeat(boolean repeat) {
this.repeat = repeat;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((courseName == null) ? 0 : courseName.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Class other = (Class) obj;
if (courseName == null) {
if (other.courseName != null)
return false;
} else if (!courseName.equals(other.courseName))
return false;
return true;
}
}
==================================第三個類 Teacher類
package org.wood.teacher;
import java.util.ArrayList;
import java.util.List;
/**
* 教師類 包含教室的 姓名，職稱（級別）信息
*
* 核心方法 計算該教師的工作量(多個班級的工作量的和) calculateWorkload();
*
* @author Administrator
*
*/
public class Teacher {
/**
* 姓名
*/
private String name;
/**
* 職稱/級別 助教、講師、副教授、正教授
*/
private String level;
/**
* 老師 所帶領的班級的集合
*
*/
private List<Class> classes = new ArrayList<Class>();
public Teacher() {
super();
}
public Teacher(String name, String level) {
super();
this.name = name;
this.level = level;
}
/**
* addClass(Class clas) 添加 老師帶的班級 到 老師帶班集合
*
* @param clas
*/
public void addClass(Class clas) {
this.classes.add(clas);
}
/**
* 計算教師的工作量(workload)
*
* @return
*/
public double calculateWorkload() {
/**
* 獲取教師的級別系數
*/
double levlValue = getTeacherLevlValue();
System.out.println("職稱系數："+levlValue);
/**
* 檢測 教師 所帶領的 班級
* 如果 有班級是 重復的，將人數最少的班級 的重復屬性 賦值為 true
*/
checkClassRepeat();
/**
* 計算 工作量
* 結合 教師的 職稱
*/
double sum=getSum(levlValue);
return sum;
}
private double getSum(double levlValue) {
double sum=0.0;
for(Class c:this.classes){
sum+=c.calculateClassWorkload(levlValue);
System.out.println("SUM:---->"+sum);
}
return sum;
}
/**
* 檢測 教師 所帶領的 班級
* 如果 有班級是 重復的，將人數最少的班級 的重復屬性 賦值為 true
*/
private void checkClassRepeat() {
/**
* 此方法 沒有實現，請高手 實現
*
* 我的想法是遍歷 List<Class> classes 集合，比較集合中的對象，
* 如果有對象是相同的（我重寫了Class的equals()方法，只要課程名相同，就表示兩個班相同）
* 則將 班級人數少的班級的重復 屬性 賦值為true(默認為false)---->計算班級的工作量是用到 該屬性 做判斷
*
* 我遇到的問題是，如果一個老師 帶的重復的班級 有3個或三個以上(如:3個java班)，我的邏輯就有點亂了，沒理過來
* 請高手幫忙!!
*
* 現在只能 手動地設置 某個班級 為重復的，從而進行計算
*/
}
/**
* 獲取教師的 職稱系數方法
* 通過 教師的 職稱 確定的 教師的 職稱系數
* @return
*/
private double getTeacherLevlValue() {
// 助教、講師、副教授、正教授
if ("助教".equals(this.level)) {
return TypeValue.LEVEL_TYPE_ASISITANT_VALUE;
} else if ("講師".equals(this.level)) {
return TypeValue.LEVEL_TYPE_DOCENT_VALUE;
} else if ("副教授".equals(this.level)) {
return TypeValue.LEVEL_TYPE_ASSOCIATE_PROFESSOR_VALUE;
} else if ("正教授".equals(this.level)) {
return TypeValue.LEVEL_TYPE_PROFESSOR_VALUE;
}
return -1;
}
/**
* 計算教師的收入
*
* @param perWorkloadPrice(單價)
* @return
*/
public double calculateIncome(double perWorkloadPrice) {
return calculateWorkload()*perWorkloadPrice;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
public List<Class> getClasses() {
return classes;
}
public void setClasses(List<Class> classes) {
this.classes = classes;
}
}
==================================第四個類 測試類 TestCal類
package org.wood.teacher;
public class TestCal {
public static void main(String[] args) {
/**
* 職稱/級別 助教、講師、副教授、正教授
*/
Teacher teacher=new Teacher("張三","講師");
/**
* 構建 班級1 對象
* 班級2 java課 60人 30天理論 10天實踐
*/
Class class01=new Class(1,"java",35,30,10);
class01.setRepeat(true);
/**
* 構建 班級2 對象
* 班級2 java課 60人 30天理論 10天實踐
*/
Class class02=new Class(2,"java",60,30,10);
class02.setRepeat(false);
/**
* 將1,2班 添加到教室 帶班列表
*/
teacher.addClass(class01);
teacher.addClass(class02);
/**
* 計算工作量
*/
double result=teacher.calculateWorkload();
System.out.println("R:"+result);
/**
* 單個班級 java02 班 測試數據
* 30(理論課天數)*1.2（理論課系數）*1.1（60人,學生人數系數）*1.2（職稱系數）*1(非重復系數，人多的班級) + 10(實踐天數)*0.8（實踐課系數）*1.1（60人，學生人數系數）*1.2（職稱系數）
* 理論數據： 30 * 1.2 * 1.1 * 1.2 * 1 + 10 * 0.8 * 1.1 * 1.2 =58.08
* 程序數據： 30 * 1.2 * 1.1 * 1.2 * 1.0 + 10 * 0.8 * 1.1 * 1.2 =58.080000000000005(double類型數據不精確存儲)
*/
/**
* 兩個班級 java01 java02 班 共同 測試數據
* java 1班，重復了！
* 30 * 1.2 * 1.0 * 1.2 * 0.8(重復系數) + 10 * 0.8 * 1.0 * 1.2
*
* java 2班
* 30 * 1.2 * 1.1 * 1.2 * 1.0(非重復系數) + 10 * 0.8 * 1.1 * 1.2
*
* 程序數據結果：R:102.24000000000001
*
*/
}
}
/**
*
*實現了Teacher 類中的 private void checkClassRepeat() 方法 就可以
*自動判斷 哪一個 班級是重復的
* 但是 現在 我未能實現此方法
* 只能 像測試類中的 那樣， 手動地 設置 該班級 是否是重復班級
*/
7. java代碼求指點,只是計算100--200內的素數,卻怎麼都弄不出來
只能被1和它自己本身所整除的數成為素數或質數，以下為三種求N以內素數的演算法。
一、從1至N全部遍歷，當這個數只能被1和n整除它就是素數。
/**
* 列印自然數n以內的素數
*/
public void printPrime(int n){
//是否為質數
boolean isPrime;
for (int i = 1; i <= n; i++) {
isPrime = true;
for (int j = 2; j < i; j++) {
//若能除盡，則不為質數
if ((i % j) == 0) {
isPrime = false;
break;
}
}
//如果是質數，則列印
if (isPrime) {
System.out.println(i);
}
}
}
二、篩數法求素數
篩數法求素數的基本思想是：把從1開始的、某一范圍內的正整數從小到大順序排列， 1不是素數，首先把它篩掉。剩下的數中選擇最小的數是素數，然後去掉它的倍數。依次類推，直到篩子為空時結束。
public void printPrimes(int n){
//定義arr數組來表示篩選出來的素數
boolean arr[] = new boolean[n];
//arr數組坐標i不是素數的話就令arr[i]=false
for(int k=2;k<N;K++){< p>
if(!arr[k]){
for(int i=2*k;i< p>
arr[i] =false;
}
}
}
//把求的素數放入數組a中。
for(int i=1;i<N;I++){< p>
if(arr[i]){
System.out.println(i);
}
}
}
三、6N±1法求素數
任何一個自然數，總可以表示成為如下的形式之一：
6N，6N+1，6N+2，6N+3，6N+4，6N+5 (N=0，1，2，…)
顯然，當N≥1時，6N，6N+2，6N+3，6N+4都不是素數，只有形如6N+1和6N+5的自然數有可能是素數。所以，除了2和3之外，所有的素數都可以表示成6N±1的形式(N為自然數)。
根據上述分析，我們只對形如6 N±1的自然數進行篩選，這樣就可以大大減少篩選的次數，從而進一步提高程序的運行效率和速度。
以下代碼需要自然數大於10 。
public int[] getPrimes(int n){
int []a = new int[200];
int k=0;
int num = 5;
a[0]=1;a[1]=2;a[2]=3;a[3]=5;a[4]=7;
for(int i=3;i< p>
for(int j=0;j<2;j++){
k = 2*(i+j)-1;
if((k<n)&&k%5==0?false:k%7==0?false:true){< p>
a[num] = k;
num++;
}
}
}
return a;
}
8. java語言：請輸入一個整數，並判斷他是否為素數 急！！ 正在考試
1. 根據概念判斷:
如果一個正整數只有兩個因子, 1和p，則稱p為素數.
public boolean isPrime(int n)
{
if(n < 2) return false;
for(int i = 2; i < n; ++i)
if(n%i == 0) return false;
return true;
}
時間復雜度O(n).
2. 改進, 去掉偶數的判斷
public boolean isPrime(int n)
{
if(n < 2) return false;
if(n == 2) return true;
if(n%2==0) return false;
for(int i = 3; i < n; i += 2)
if(n%i == 0) return false;
return true;
}
時間復雜度O(n/2), 速度提高一倍.
3. 進一步減少判斷的范圍
定理: 如果n不是素數, 則n有滿足1< d<=sqrt(n)的一個因子d.
證明: 如果n不是素數, 則由定義n有一個因子d滿足1< d< n.
如果d大於sqrt(n), 則n/d是滿足1< n/d<=sqrt(n)的一個因子.
public boolean isPrime(int n)
{
if(n < 2) return false;
if(n == 2) return true;
if(n%2==0) return false;
for(int i = 3; i*i <= n; i += 2)
if(n%i == 0) return false;
return true;
}
時間復雜度O(Math.sqrt(n)/2), 速度提高O((n-Math.sqrt(n))/2).
4. 剔除因子中的重復判斷.
定理: 如果n不是素數, 則n有滿足1< d<=Math.sqrt(n)的一個"素數"因子d.
證明: I1. 如果n不是素數, 則n有滿足1< d<=Math.sqrt(n)的一個因子d.
I2. 如果d是素數, 則定理得證, 演算法終止.
I3. 令n=d, 並轉到步驟I1.
由於不可能無限分解n的因子, 因此上述證明的演算法最終會停止.
// primes是遞增的素數序列: 2, 3, 5, 7, ...
// 更准確地說primes序列包含1->Math.sqrt(n)范圍內的所有素數
public boolean isPrime(int primes[], int n)
{
if(n < 2) return false;
for(int i = 0; primes[i]*primes[i] <= n; ++i)
if(n%primes[i] == 0) return false;
return true;
}
5. 構造素數序列primes: 2, 3, 5, 7, ...
由4的演算法我們知道, 在素數序列已經被構造的情況下, 判斷n是否為素數效率很高;
下面程序可以輸出素數表.
public class ShowPrimeNumber{
public static int[] getPrimeNums(int maxNum){
int[] primeNums = new int[maxNum/2+1];
int sqrtRoot;
int cursor = 0;
boolean isPrime;
for(int i=2;i<=maxNum;i++){
sqrtRoot = (int)Math.sqrt(i); //取平方根
isPrime = true;
for(int j=0;j< cursor;j++){
if(primeNums[j]>sqrtRoot)
break;
if(i%primeNums[j]==0){
isPrime = false;
break;
}
}
if(isPrime){
primeNums[cursor++] = i;
}
}
int[] result = new int[cursor];
System.array(primeNums,0,result,0,cursor);
return result;
}
public static void main(String[] args) throws Exception{
int maxNum = Integer.parseInt(args[0]);
int[] primeNums = getPrimeNums(maxNum);
System.out.println("共"+primeNums.length+"個素數");
for(int i=0;i< primeNums.length;i++){
System.out.print(primeNums[i]+",\t");
}
}
}
6.(在素數表中)二分查找
Arrays.BinarySearch方法:
該方法用於在指定數組中查找給定的值，採用二分法實現，所以要求傳入的數組已經是排序了的。
該方法的基本語法格式為：
Static int binarySearch(byte[] a, byte key)
該方法返回數據中key元素所在的位置，如果沒有key元素，則返回key應插入的位置：-（insertion point-1），如數組中的第一個元素就大於key，返回-1。
註：數組的數據類型可以是int[] byte[] short[] float[] long[] double[] char[] Object[]類型。
9. 怎樣判斷一個數是否為素數(在C語言或JAVA里)
關於素數的判定
所謂「篩選法」指的是「埃拉托色尼(Eratosthenes)篩法」。他是古希臘的著名數學家。他採取的方法是，在一張紙上寫上1到100全部整數，然後逐個判斷它們是否是素數，找出一個非素數，就把它挖掉，最後剩下的就是素數。
具體做法如下：
<1> 先將1挖掉(因為1不是素數)。
<2> 用2去除它後面的各個數，把能被2整除的數挖掉，即把2的倍數挖掉。
<3> 用3去除它後面的各數，把3的倍數挖掉。
<4> 分別用4、5…各數作為除數去除這些數以後的各數。這個過程一直進行到在除數後面的數已全被挖掉為止。例如找1～50的素數，要一直進行到除數為47為止（事實上，可以簡化，如果需要找1～n范圍內素數表，只需進行到除數為n^2(根號n)，取其整數即可。例如對1～50，只需進行到將50^2作為除數即可。）
如上演算法可表示為：
<1> 挖去1;
<2> 用剛才被挖去的數的下一個數p去除p後面各數，把p的倍數挖掉;
<3> 檢查p是否小於n^2的整數部分（如果n=1000, 則檢查p<31?），如果是，則返回(2)繼續執行，否則就結束;
<4> 紙上剩下的數就是素數。
#include <stdio.h>
#include <math.h>
int main(void)
{
int i;
int j;
int a[101]; // 為直觀表示，各元素與下標對應，0號元素不用
for (i = 1; i <= 100; i++) // 數組各元素賦值
a[i] = i;
for (i = 2; i < sqrt(100); i++) // 外循環使i作為除數
for (j = i + 1; j <= 100; j++) // 內循環檢測除數i之後的數是否為i的倍數
{
if (a[i] != 0 && a[j] != 0) // 排除0值元素
if (a[j] % a[i] == 0)
a[j] = 0; // i後數若為i的倍數，剛將其置0(挖去)
}
int n = 0; // 對輸出素數計數, 以控制換行顯示
for (i = 2; i <= 100; i++) // 輸出素數
{
if (a[i] != 0)
{
printf("%-5d", a[i]); // 輸出數組中非0元素(未挖去的數)
n++;
}
if (n == 10)
{
printf("\n"); // 每行10個輸出
n = 0;
}
}
printf("\n");
return 0;
}
運行結果(VC):
=================================================
2 3 5 7 11 13 17 19 23 29
31 37 41 43 47 53 59 61 67 71
73 79 83 89 97
=================================================
10. 寫出求最大支撐樹的演算法，既此支撐樹有可能的最大開銷。
Prime演算法或kruskal演算法