java基礎演算法

1. 新手初學java有必要去學習數據結構與演算法嗎

還是有些必要的，大公司筆試面試基本都是靠計算機網路及數據結構與演算法。
建議找些基礎的演算法如排序查找等入門就可以了，java新人用不到多深層次的演算法，
新人初學Java的話建議還是講基礎知識弄通弄透比較好。

2. 關於java新聞網站的演算法

問:新聞網站，如新浪網站，比如說國際足球頻道，每天會有跟新。請問這塊在代碼設計的地方，是從資料庫中讀取5條最新的（按照日期）還是說做一個程序由編輯強制置頂?
答:是從資料庫中讀取5條最新的（按照日期）

問:如果是論壇，需要把點擊最高的新聞自動排到前面，這個怎麼處理，需要用到servletcontext嗎 ?
答:讀取點擊最高的新聞記錄(你想讀取幾條就幾條),然後放到網頁上去,就怎麼回事.......跟你平時放其他數據沒什麼區別,都是根據條件取數據而已.

3. java演算法背包溢出最小值

java演算法背包溢出最小值最小值-1,即最小值+(-1),即1-0000加1-1111,變成0-1111。

最大值＋1，即0-1111加0-0001，變成1-0000，即最小值最小值－1，即最小值＋（－1)，即1-0000加1-1111，變成0-1111，即最大值正數區間和負數區間形成了循環，正數區間最大值＋1，就進入了負數區間，負數區間最大值＋1，就進入了正數區間。

基本信息

數據結構與演算法課程是電子科技大學於2018年02月26日首次在中國大學MOOC開設的慕課課程、國家精品在線開放課程。該課程授課教師為林劼、戴波、劉震、周益民。據2021年3月中國大學MOOC官網顯示，該課程已開課7次。

數據結構與演算法課程共6個模塊，包括緒論、線性表、查找、排序、遞歸與分治、樹與二叉樹、圖論與貪心演算法、動態規劃等內容。

數據結構與演算法課程是計算機科學與技術的學科基礎課程，也是是計算機圖形學、計算機網路、編譯原理、計算機操作系統等後續課程的基礎理論之一，其應用范圍也早已擴展到圖像處理與模式識別、海量數據挖掘、科學數據處理、復雜網路分析等許多計算機前沿領域。

4. java有哪些垃圾回收演算法

常用的垃圾回收演算法有：
(1).引用計數演算法：
給對象中添加一個引用計數器，每當有一個地方引用它時，計數器值就加1；當引用失效時，計數器值就減1；任何時刻計數器都為0的對象就是不再被使用的，垃圾收集器將回收該對象使用的內存。
引用計數演算法實現簡單，效率很高，微軟的COM技術、ActionScript、Python等都使用了引用計數演算法進行內存管理，但是引用計數演算法對於對象之間相互循環引用問題難以解決，因此java並沒有使用引用計數演算法。
(2).根搜索演算法：
通過一系列的名為「GC Root」的對象作為起點，從這些節點向下搜索，搜索所走過的路徑稱為引用鏈(Reference Chain)，當一個對象到GC Root沒有任何引用鏈相連時，則該對象不可達，該對象是不可使用的，垃圾收集器將回收其所佔的內存。
主流的商用程序語言C#、java和Lisp都使用根搜素演算法進行內存管理。
在java語言中，可作為GC Root的對象包括以下幾種對象：
a. java虛擬機棧(棧幀中的本地變數表)中的引用的對象。
b.方法區中的類靜態屬性引用的對象。
c.方法區中的常量引用的對象。
d.本地方法棧中JNI本地方法的引用對象。
java方法區在Sun HotSpot虛擬機中被稱為永久代，很多人認為該部分的內存是不用回收的，java虛擬機規范也沒有對該部分內存的垃圾收集做規定，但是方法區中的廢棄常量和無用的類還是需要回收以保證永久代不會發生內存溢出。
判斷廢棄常量的方法：如果常量池中的某個常量沒有被任何引用所引用，則該常量是廢棄常量。
判斷無用的類：
(1).該類的所有實例都已經被回收，即java堆中不存在該類的實例對象。
(2).載入該類的類載入器已經被回收。
(3).該類所對應的java.lang.Class對象沒有任何地方被引用，無法在任何地方通過反射機制訪問該類的方法。
Java中常用的垃圾收集演算法：
(1).標記-清除演算法：
最基礎的垃圾收集演算法，演算法分為「標記」和「清除」兩個階段：首先標記出所有需要回收的對象，在標記完成之後統一回收掉所有被標記的對象。
標記-清除演算法的缺點有兩個：首先，效率問題，標記和清除效率都不高。其次，標記清除之後會產生大量的不連續的內存碎片，空間碎片太多會導致當程序需要為較大對象分配內存時無法找到足夠的連續內存而不得不提前觸發另一次垃圾收集動作。
(2).復制演算法：
將可用內存按容量分成大小相等的兩塊，每次只使用其中一塊，當這塊內存使用完了，就將還存活的對象復制到另一塊內存上去，然後把使用過的內存空間一次清理掉。這樣使得每次都是對其中一塊內存進行回收，內存分配時不用考慮內存碎片等復雜情況，只需要移動堆頂指針，按順序分配內存即可，實現簡單，運行高效。
復制演算法的缺點顯而易見，可使用的內存降為原來一半。
(3).標記-整理演算法：
標記-整理演算法在標記-清除演算法基礎上做了改進，標記階段是相同的標記出所有需要回收的對象，在標記完成之後不是直接對可回收對象進行清理，而是讓所有存活的對象都向一端移動，在移動過程中清理掉可回收的對象，這個過程叫做整理。
標記-整理演算法相比標記-清除演算法的優點是內存被整理以後不會產生大量不連續內存碎片問題。
復制演算法在對象存活率高的情況下就要執行較多的復制操作，效率將會變低，而在對象存活率高的情況下使用標記-整理演算法效率會大大提高。
(4).分代收集演算法：
根據內存中對象的存活周期不同，將內存劃分為幾塊，java的虛擬機中一般把內存劃分為新生代和年老代，當新創建對象時一般在新生代中分配內存空間，當新生代垃圾收集器回收幾次之後仍然存活的對象會被移動到年老代內存中，當大對象在新生代中無法找到足夠的連續內存時也直接在年老代中創建。

5. java中冒泡排序演算法的詳細解答以及程序

實例說明

用冒泡排序方法對數組進行排序。

實例解析

交換排序的基本思想是兩兩比較待排序記錄的關鍵字，發現兩個記錄的次序相反時即進行交換，直到沒有反序的記錄為止。

應用交換排序基本思想的主要排序方法有冒泡排序和快速排序。

冒泡排序

將被排序的記錄數組 R[1..n] 垂直排列，每個記錄 R[i] 看做是重量為 R[i].key 的氣泡。根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組 R 。凡掃描到違反本原則的輕氣泡，就使其向上「漂浮」。如此反復進行，直到最後任何兩個氣泡都是輕者在上，重者在下為止。

(1) 初始， R[1..n] 為無序區。

(2) 第一趟掃描，從無序區底部向上依次比較相鄰的兩個氣泡的重量，若發現輕者在下、重者在上，則交換二者的位置。即依次比較 (R[n],R[n-1]) 、 (R[n-1],R[n-2]) 、 … 、 (R[2],R[1]); 對於每對氣泡 (R[j+1],R[j]), 若 R[j+1].key<R[j].key, 則交換 R[j+1] 和 R[j] 的內容。

第一趟掃描完畢時，「最輕」的氣泡就飄浮到該區間的頂部，即關鍵字最小的記錄被放在最高位置 R[1] 上。

(3) 第二趟掃描，掃描 R[2..n]。掃描完畢時，「次輕」的氣泡飄浮到 R[2] 的位置上 …… 最後，經過 n-1 趟掃描可得到有序區 R[1..n]。

注意：第 i 趟掃描時， R[1..i-1] 和 R[i..n] 分別為當前的有序區和無序區。掃描仍是從無序區底部向上直至該區頂部。掃描完畢時，該區中最輕氣泡漂浮到頂部位置 R[i] 上，結果是 R[1..i] 變為新的有序區。

冒泡排序演算法

因為每一趟排序都使有序區增加了一個氣泡，在經過 n-1 趟排序之後，有序區中就有 n-1 個氣泡，而無序區中氣泡的重量總是大於等於有序區中氣泡的重量，所以整個冒泡排序過程至多需要進行 n-1 趟排序。

若在某一趟排序中未發現氣泡位置的交換，則說明待排序的無序區中所有氣泡均滿足輕者在上，重者在下的原則，因此，冒泡排序過程可在此趟排序後終止。為此，在下面給出的演算法中，引入一個布爾量 exchange, 在每趟排序開始前，先將其置為 FALSE 。若排序過程中發生了交換，則將其置為 TRUE 。各趟排序結束時檢查 exchange, 若未曾發生過交換則終止演算法，不再進行下趟排序。

具體演算法如下：

void BubbleSort(SeqList R){
//R(1..n) 是待排序的文件，採用自下向上掃描，對 R 做冒泡排序
int i,j;
Boolean exchange; // 交換標志
for(i=1;i<n;i++){ // 最多做 n-1 趟排序
exchange=FALSE; // 本趟排序開始前，交換標志應為假
for(j=n-1;j>=i;j--) // 對當前無序區 R[i..n] 自下向上掃描
if(R[j+1].key<R[j].key){ // 交換記錄
R[0]=R[j+1]; //R[0] 不是哨兵，僅做暫存單元
R[j+1]=R[j];
R[j]=R[0];
exchange=TRUE; // 發生了交換，故將交換標志置為真
}
if(!exchange) // 本趟排序未發生交換，提前終止演算法
return;
} //endfor( 外循環 )
}//BubbleSort

publicclassBubbleSort{

publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
List<Integer>lstInteger=newArrayList<Integer>();
lstInteger.add(1);
lstInteger.add(1);
lstInteger.add(3);
lstInteger.add(2);
lstInteger.add(1);
for(inti=0;i<lstInteger.size();i++){
System.out.println(lstInteger.get(i));
}
System.out.println("排序之後-----------------");
lstInteger=sortList(lstInteger);
for(inti=0;i<lstInteger.size();i++){
System.out.println(lstInteger.get(i));
}

}

publicstaticList<Integer>sortList(List<Integer>lstInteger){
inti,j,m;
booleanblChange;
intn=lstInteger.size();

for(i=0;i<n;i++){
blChange=false;
for(j=n-1;j>i;j--){
if(lstInteger.get(j)<lstInteger.get(j-1)){
m=lstInteger.get(j-1);
lstInteger.set(j-1,lstInteger.get(j));
lstInteger.set(j,m);
blChange=true;
}
}
if(!blChange){
returnlstInteger;
}
}
returnlstInteger;
}
}
歸納注釋

演算法的最好時間復雜度:若文件的初始狀態是正序的,一趟掃描即可完成排序。所需的關鍵字比較次數C和記錄移動次數M均達到最小值，即C(min)=n-1,M(min)=0。冒泡排序最好的時間復雜度為O(n)。

演算法的最壞時間復雜度:若初始文件是反序的，需要進行n-1趟排序。每趟排序要進行n-1次關鍵字的比較(1<=i<=n-1),且每次比較都必須移動記錄3次。在這種情況下，比較和移動次數均達到最大值，即C(max)=n(n-1)/2=O(n^2)，M(max)=3n(n-1)/2=O(n^2)。冒泡排序的最壞時間復雜度為O(n^2)。

演算法的平均時間復雜度為O(n^2)。雖然冒泡排序不一定要進行n-1趟，但由於它的記錄移動次數較多，故平均時間性能比直接插入排序要差得多。

演算法穩定性：冒泡排序是就地排序，且它是穩定的。

演算法改進：上述的冒泡排序還可做如下的改進，①記住最後一次交換發生位置lastExchange的冒泡排序(該位置之前的相鄰記錄均已有序)。下一趟排序開始時，R[1..lastExchange-1]是有序區，R[lastExchange..n]是無序區。這樣，一趟排序可能使當前有序區擴充多個記錄，從而減少排序的趟數。②改變掃描方向的冒泡排序。冒泡排序具有不對稱性。能一趟掃描完成排序的情況，只有最輕的氣泡位於R[n]的位置，其餘的氣泡均已排好序，那麼也只需一趟掃描就可以完成排序。如對初始關鍵字序列12、18、42、44、45、67、94、10就僅需一趟掃描。需要n-1趟掃描完成排序情況，當只有最重的氣泡位於R[1]的位置，其餘的氣泡均已排好序時，則仍需做n-1趟掃描才能完成排序。比如對初始關鍵字序列：94、10、12、18、42、44、45、67就需7趟掃描。造成不對稱性的原因是每趟掃描僅能使最重氣泡「下沉」一個位置，因此使位於頂端的最重氣泡下沉到底部時，需做n-1趟掃描。在排序過程中交替改變掃描方向，可改進不對稱性

6. Java的排序演算法有哪些

排序： 插入，冒泡，選擇，Shell,快速排序