導航:首頁 > 源碼編譯 > java面試常考演算法組合

java面試常考演算法組合

發布時間:2022-08-19 21:27:10

java編程常見面試題目,要求正確答案

第一,談談final, finally, finalize的區別。

final?修飾符(關鍵字)如果一個類被聲明為final,意味著它不能再派生出新的子類,不能作為父類被繼承。因此一個類不能既被聲明為 abstract的,又被聲明為final的。將變數或方法聲明為final,可以保證它們在使用中不被改變。被聲明為final的變數必須在聲明時給定初值,而在以後的引用中只能讀取,不可修改。被聲明為final的方法也同樣只能使用,不能重載finally?再異常處理時提供 finally 塊來執行任何清除操作。如果拋出一個異常,那麼相匹配的 catch 子句就會執行,然後控制就會進入 finally 塊(如果有的話)。

finalize?方法名。Java 技術允許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去之前做必要的清理工作。這個方法是由垃圾收集器在確定這個對象沒有被引用時對這個對象調用的。它是在 Object 類中定義的,因此所有的類都繼承了它。子類覆蓋 finalize() 方法以整理系統資源或者執行其他清理工作。finalize() 方法是在垃圾收集器刪除對象之前對這個對象調用的。

第二,Anonymous Inner Class (匿名內部類) 是否可以extends(繼承)其它類,是否可以implements(實現)interface(介面)?

匿名的內部類是沒有名字的內部類。不能extends(繼承) 其它類,但一個內部類可以作為一個介面,由另一個內部類實現。

第三,Static Nested Class 和 Inner Class的不同,說得越多越好(面試題有的很籠統)。

Nested Class (一般是C++的說法),Inner Class (一般是JAVA的說法)。Java內部類與C++嵌套類最大的不同就在於是否有指向外部的引用上。具體可見http: //www.frontfree.net/articles/services/view.ASP?id=704&page=1

註: 靜態內部類(Inner Class)意味著1創建一個static內部類的對象,不需要一個外部類對象,2不能從一個static內部類的一個對象訪問一個外部類對象

第四,&和&&的區別。

&是位運算符。&&是布爾邏輯運算符。

第五,HashMap和Hashtable的區別。

都屬於Map介面的類,實現了將惟一鍵映射到特定的值上。

HashMap 類沒有分類或者排序。它允許一個 null 鍵和多個 null 值。

Hashtable 類似於 HashMap,但是不允許 null 鍵和 null 值。它也比 HashMap 慢,因為它是同步的。

第六,Collection 和 Collections的區別。

Collections是個java.util下的類,它包含有各種有關集合操作的靜態方法。
Collection是個java.util下的介面,它是各種集合結構的父介面。

第七,什麼時候用assert。

斷言是一個包含布爾表達式的語句,在執行這個語句時假定該表達式為 true。如果表達式計算為 false,那麼系統會報告一個 AssertionError。它用於調試目的:

assert(a > 0); // throws an AssertionError if a <= 0

斷言可以有兩種形式:

assert Expression1 ;
assert Expression1 : Expression2 ;

Expression1 應該總是產生一個布爾值。
Expression2 可以是得出一個值的任意表達式。這個值用於生成顯示更多調試信息的 String 消息。
斷言在默認情況下是禁用的。要在編譯時啟用斷言,需要使用 source 1.4 標記:

Javac -source 1.4 Test.java

要在運行時啟用斷言,可使用 -enableassertions 或者 -ea 標記。
要在運行時選擇禁用斷言,可使用 -da 或者 -disableassertions 標記。
要系統類中啟用斷言,可使用 -esa 或者 -dsa 標記。還可以在包的基礎上啟用或者禁用斷言。

可以在預計正常情況下不會到達的任何位置上放置斷言。斷言可以用於驗證傳遞給私有方法的參數。不過,斷言不應該用於驗證傳遞給公有方法的參數,因為不管是否啟用了斷言,公有方法都必須檢查其參數。不過,既可以在公有方法中,也可以在非公有方法中利用斷言測試後置條件。另外,斷言不應該以任何方式改變程序的狀態。

第八,GC是什麼? 為什麼要有GC? (基礎)。

GC是垃圾收集器。Java 程序員不用擔心內存管理,因為垃圾收集器會自動進行管理。要請求垃圾收集,可以調用下面的方法之一:

System.gc()
Runtime.getRuntime().gc()

第九,String s = new String("xyz");創建了幾個String Object?

兩個對象,一個是「xyx」,一個是指向「xyx」的引用對象s。

第十,Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

Math.round(11.5)返回(long)12,Math.round(-11.5)返回(long)-11;

第十一,short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?

short s1 = 1; s1 = s1 + 1;有錯,s1是short型,s1+1是int型,不能顯式轉化為short型。可修改為s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正確。

第十二,sleep() 和 wait() 有什麼區別? 搞線程的最愛

sleep()方法是使線程停止一段時間的方法。在sleep 時間間隔期滿後,線程不一定立即恢復執行。這是因為在那個時刻,其它線程可能正在運行而且沒有被調度為放棄執行,除非(a)「醒來」的線程具有更高的優先順序,(b)正在運行的線程因為其它原因而阻塞。

wait()是線程交互時,如果線程對一個同步對象x 發出一個wait()調用,該線程會暫停執行,被調對象進入等待狀態,直到被喚醒或等待時間到。

第十三,Java有沒有goto?

Goto?java中的保留字,現在沒有在java中使用。

第十四,數組有沒有length()這個方法? String有沒有length()這個方法?

數組沒有length()這個方法,有length的屬性。
String有有length()這個方法。

第十五,Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?

方法的重寫Overriding和重載Overloading是Java多態性的不同表現。重寫Overriding是父類與子類之間多態性的一種表現,重載Overloading是一個類中多態性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和參數,我們說該方法被重寫 (Overriding)。子類的對象使用這個方法時,將調用子類中的定義,對它而言,父類中的定義如同被「屏蔽」了。如果在一個類中定義了多個同名的方法,它們或有不同的參數個數或有不同的參數類型,則稱為方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型。

第十六,Set里的元素是不能重復的,那麼用什麼方法來區分重復與否呢? 是用==還是equals()? 它們有何區別?

Set里的元素是不能重復的,那麼用iterator()方法來區分重復與否。equals()是判讀兩個Set是否相等。

equals()和==方法決定引用值是否指向同一對象equals()在類中被覆蓋,為的是當兩個分離的對象的內容和類型相配的話,返回真值。

第十七,給我一個你最常見到的runtime exception。

ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, , DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException

第十八,error和exception有什麼區別?

error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內存溢出。不可能指望程序能處理這樣的情況。

exception 表示一種設計或實現問題。也就是說,它表示如果程序運行正常,從不會發生的情況。

第十九,List, Set, Map是否繼承自Collection介面?

List,Set是

Map不是。

第二十,abstract class和interface有什麼區別?

聲明方法的存在而不去實現它的類被叫做抽象類(abstract class),它用於要創建一個體現某些基本行為的類,並為該類聲明方法,但不能在該類中實現該類的情況。不能創建abstract 類的實例。然而可以創建一個變數,其類型是一個抽象類,並讓它指向具體子類的一個實例。不能有抽象構造函數或抽象靜態方法。Abstract 類的子類為它們父類中的所有抽象方法提供實現,否則它們也是抽象類為。取而代之,在子類中實現該方法。知道其行為的其它類可以在類中實現這些方法。

介面(interface)是抽象類的變體。在介面中,所有方法都是抽象的。多繼承性可通過實現這樣的介面而獲得。介面中的所有方法都是抽象的,沒有一個有程序體。介面只可以定義static final成員變數。介面的實現與子類相似,除了該實現類不能從介面定義中繼承行為。當類實現特殊介面時,它定義(即將程序體給予)所有這種介面的方法。然後,它可以在實現了該介面的類的任何對象上調用介面的方法。由於有抽象類,它允許使用介面名作為引用變數的類型。通常的動態聯編將生效。引用可以轉換到介面類型或從介面類型轉換,instanceof 運算符可以用來決定某對象的類是否實現了介面。

第二十一,abstract的method是否可同時是static,是否可同時是native,是否可同時是synchronized?

都不能

第二十二,介面是否可繼承介面? 抽象類是否可實現(implements)介面? 抽象類是否可繼承實體類(concrete class)?

介面可以繼承介面。抽象類可以實現(implements)介面,抽象類是否可繼承實體類,但前提是實體類必須有明確的構造函數。

第二十三,啟動一個線程是用run()還是start()?

啟動一個線程是調用start()方法,使線程所代表的虛擬處理機處於可運行狀態,這意味著它可以由JVM調度並執行。這並不意味著線程就會立即運行。run()方法可以產生必須退出的標志來停止一個線程。

第二十四,構造器Constructor是否可被override?

構造器Constructor不能被繼承,因此不能重寫Overriding,但可以被重載Overloading。

第二十五,是否可以繼承String類?

String類是final類故不可以繼承。

第二十六,當一個線程進入一個對象的一個synchronized方法後,其它線程是否可進入此對象的其它方法?

不能,一個對象的一個synchronized方法只能由一個線程訪問。

第二十七,try {}里有一個return語句,那麼緊跟在這個try後的finally {}里的code會不會被執行,什麼時候被執行,在return前還是後?

會執行,在return前執行。

第二十八,編程題: 用最有效率的方法算出2乘以8等於幾?

有C背景的程序員特別喜歡問這種問題。

2 << 3

第二十九,兩個對象值相同(x.equals(y) == true),但卻可有不同的hash code,這句話對不對?

不對,有相同的hash code。

第三十,當一個對象被當作參數傳遞到一個方法後,此方法可改變這個對象的屬性,並可返回變化後的結果,那麼這里到底是值傳遞還是引用傳遞?

是值傳遞。Java 編程語言只由值傳遞參數。當一個對象實例作為一個參數被傳遞到方法中時,參數的值就是對該對象的引用。對象的內容可以在被調用的方法中改變,但對象的引用是永遠不會改變的。

第三十一,swtich是否能作用在byte上,是否能作用在long上,是否能作用在String上?

switch(expr1)中,expr1是一個整數表達式。因此傳遞給 switch 和 case 語句的參數應該是 int、 short、 char 或者 byte。long,string 都不能作用於swtich。

第三十二,編程題: 寫一個Singleton出來。

Singleton模式主要作用是保證在Java應用程序中,一個類Class只有一個實例存在。

一般Singleton模式通常有幾種種形式:

第一種形式: 定義一個類,它的構造函數為private的,它有一個static的private的該類變數,在類初始化時實例話,通過一個public的getInstance方法獲取對它的引用,繼而調用其中的方法。

public class Singleton {
private Singleton(){}
//在自己內部定義自己一個實例,是不是很奇怪?
//注意這是private 只供內部調用
private static Singleton instance = new Singleton();
//這里提供了一個供外部訪問本class的靜態方法,可以直接訪問
public static Singleton getInstance() {
return instance;
}
}

第二種形式:

public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//這個方法比上面有所改進,不用每次都進行生成對象,只是第一次
//使用時生成實例,提高了效率!
if (instance==null)
instance=new Singleton();
return instance; }
}

其他形式:

定義一個類,它的構造函數為private的,所有方法為static的。

一般認為第一種形式要更加安全些

第三十三 Hashtable和HashMap

Hashtable繼承自Dictionary類,而HashMap是Java1.2引進的Map interface的一個實現

HashMap允許將null作為一個entry的key或者value,而Hashtable不允許

還有就是,HashMap把Hashtable的contains方法去掉了,改成containsvalue和containsKey。因為contains方法容易讓人引起誤解。

最大的不同是,Hashtable的方法是Synchronize的,而HashMap不是,在多個線程訪問Hashtable時,不需要自己為它的方法實現同步,而HashMap就必須為之提供外同步。

Hashtable和HashMap採用的hash/rehash演算法都大概一樣,所以性能不會有很大的差異。

❷ java演算法面試題:排序都有哪幾種方法

一、冒泡排序
[java] view plain
package sort.bubble;
import java.util.Random;
/**
* 依次比較相鄰的兩個數,將小數放在前面,大數放在後面
* 冒泡排序,具有穩定性
* 時間復雜度為O(n^2)
* 不及堆排序,快速排序O(nlogn,底數為2)
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for(int i = 0 ; i < 10 ; i++){
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for(int i : sort){
System.out.print(i+" ");
}
buddleSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for(int i : sort){
System.out.print(i+" ");
}
}
/**
* 冒泡排序
* @param sort
*/
private static void buddleSort(int[] sort){
for(int i=1;i<sort.length;i++){
for(int j=0;j<sort.length-i;j++){
if(sort[j]>sort[j+1]){
int temp = sort[j+1];
sort[j+1] = sort[j];
sort[j] = temp;
}
}
}
}
}
二、選擇排序
[java] view plain
package sort.select;
import java.util.Random;
/**
* 選擇排序
* 每一趟從待排序的數據元素中選出最小(或最大)的一個元素,
* 順序放在已排好序的數列的最後,直到全部待排序的數據元素排完。
* 選擇排序是不穩定的排序方法。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
selectSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 選擇排序
* @param sort
*/
private static void selectSort(int[] sort){
for(int i =0;i<sort.length-1;i++){
for(int j = i+1;j<sort.length;j++){
if(sort[j]<sort[i]){
int temp = sort[j];
sort[j] = sort[i];
sort[i] = temp;
}
}
}
}
}
三、快速排序
[java] view plain
package sort.quick;
/**
* 快速排序 通過一趟排序將要排序的數據分割成獨立的兩部分, 其中一部分的所有數據都比另外一部分的所有數據都要小,
* 然後再按此方法對這兩部分數據分別進行快速排序, 整個排序過程可以遞歸進行,以此達到整個數據變成有序序列。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20 };
System.out.print("排序前的數組為:");
for (int data : sort) {
System.out.print(data + " ");
}
System.out.println();
quickSort(sort, 0, sort.length - 1);
System.out.print("排序後的數組為:");
for (int data : sort) {
System.out.print(data + " ");
}
}
/**
* 快速排序
* @param sort 要排序的數組
* @param start 排序的開始座標
* @param end 排序的結束座標
*/
public static void quickSort(int[] sort, int start, int end) {
// 設置關鍵數據key為要排序數組的第一個元素,
// 即第一趟排序後,key右邊的數全部比key大,key左邊的數全部比key小
int key = sort[start];
// 設置數組左邊的索引,往右移動判斷比key大的數
int i = start;
// 設置數組右邊的索引,往左移動判斷比key小的數
int j = end;
// 如果左邊索引比右邊索引小,則還有數據沒有排序
while (i < j) {
while (sort[j] > key && j > start) {
j--;
}
while (sort[i] < key && i < end) {
i++;
}
if (i < j) {
int temp = sort[i];
sort[i] = sort[j];
sort[j] = temp;
}
}
// 如果左邊索引比右邊索引要大,說明第一次排序完成,將sort[j]與key對換,
// 即保持了key左邊的數比key小,key右邊的數比key大
if (i > j) {
int temp = sort[j];
sort[j] = sort[start];
sort[start] = temp;
}
//遞歸調用
if (j > start && j < end) {
quickSort(sort, start, j - 1);
quickSort(sort, j + 1, end);
}
}
}
[java] view plain
/**
* 快速排序
*
* @param a
* @param low
* @param high
* voidTest
*/
public static void kuaisuSort(int[] a, int low, int high)
{
if (low >= high)
{
return;
}
if ((high - low) == 1)
{
if (a[low] > a[high])
{
swap(a, low, high);
return;
}
}
int key = a[low];
int left = low + 1;
int right = high;
while (left < right)
{
while (left < right && left <= high)// 左邊向右
{
if (a[left] >= key)
{
break;
}
left++;
}
while (right >= left && right > low)
{
if (a[right] <= key)
{
break;
}
right--;
}
if (left < right)
{
swap(a, left, right);
}
}
swap(a, low, right);
kuaisuSort(a, low, right);
kuaisuSort(a, right + 1, high);
}
四、插入排序
[java] view plain
package sort.insert;
/**
* 直接插入排序
* 將一個數據插入到已經排好序的有序數據中,從而得到一個新的、個數加一的有序數據
* 演算法適用於少量數據的排序,時間復雜度為O(n^2)。是穩定的排序方法。
*/
import java.util.Random;
public class DirectMain {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
directInsertSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 直接插入排序
*
* @param sort
*/
private static void directInsertSort(int[] sort) {
for (int i = 1; i < sort.length; i++) {
int index = i - 1;
int temp = sort[i];
while (index >= 0 && sort[index] > temp) {
sort[index + 1] = sort[index];
index--;
}
sort[index + 1] = temp;
}
}
}
順便添加一份,差不多的
[java] view plain
public static void charuSort(int[] a)
{
int len = a.length;
for (int i = 1; i < len; i++)
{
int j;
int temp = a[i];
for (j = i; j > 0; j--)//遍歷i之前的數字
{
//如果之前的數字大於後面的數字,則把大的值賦到後面
if (a[j - 1] > temp)
{
a[j] = a[j - 1];
} else
{
break;
}
}
a[j] = temp;
}
}
把上面整合起來的一份寫法:
[java] view plain
/**
* 插入排序:
*
*/
public class InsertSort {
public void sort(int[] data) {
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
}
private void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
五、順便貼個二分搜索法
[java] view plain
package search.binary;
public class Main {
public static void main(String[] args) {
int[] sort = {1,2,3,4,5,6,7,8,9,10};
int mask = binarySearch(sort,6);
System.out.println(mask);
}
/**
* 二分搜索法,返回座標,不存在返回-1
* @param sort
* @return
*/
private static int binarySearch(int[] sort,int data){
if(data<sort[0] || data>sort[sort.length-1]){
return -1;
}
int begin = 0;
int end = sort.length;
int mid = (begin+end)/2;
while(begin <= end){
mid = (begin+end)/2;
if(data > sort[mid]){
begin = mid + 1;
}else if(data < sort[mid]){
end = mid - 1;
}else{
return mid;
}
}
return -1;
}
}

❸ 希音java面試有演算法嗎

有。常見的如下:
一是字元串,如果IDE沒有代碼自動補全功能,所以你應該記住下面的這些方法。
二是鏈表,在Java中,鏈表的實現非常簡單,每個節點Node都有一個值val和指向下個節點的鏈接next。鏈表兩個著名的應用是棧Stack和隊列Queue。
三是樹,這里的樹通常是指二叉樹,每個節點都包含一個左孩子節點和右孩子節點。
四是排序,五是遞歸vs.迭代。
六是動態規劃,動態規劃是解決下面這些性質類問題的技術:一個問題可以通過更小子問題的解決方法來解決(即問題的最優解包含了其子問題的最優解,也就是最優子結構性質)。
有些子問題的解可能需要計算多次(也就是子問題重疊性質)。子問題的解存儲在一張表格里,這樣每個子問題只用計算一次。需要額外的空間以節省時間。爬台階問題完全符合上面的四條性質,因此可以用動態規劃法來解決。

❹ java實現幾種常見排序演算法

下面給你介紹四種常用排序演算法:

1、冒泡排序

特點:效率低,實現簡單

思想(從小到大排):每一趟將待排序序列中最大元素移到最後,剩下的為新的待排序序列,重復上述步驟直到排完所有元素。這只是冒泡排序的一種,當然也可以從後往前排。

❺ java面試題 很急 謝謝

2, 歸並排序(merge sort)體現了分治的思想,即將一個待排序數組分為兩部分,對這兩個部分進行歸並排序,排序後,再對兩個已經排序好的數組進行合並。這種思想可以用遞歸方式很容易實現。歸並排序的時間復雜度為O(nlogn),空間復雜度為O(n)。

實現代碼如下:
#include <stdio.h>
#include "common.h"
void merge(int data[], int p, int q, int r)
{
int i, j, k, n1, n2;
n1 = q - p + 1;
n2 = r - q;
int L[n1];
int R[n2];
for(i = 0, k = p; i < n1; i++, k++)
L[i] = data[k];
for(i = 0, k = q + 1; i < n2; i++, k++)
R[i] = data[k];
for(k = p, i = 0, j = 0; i < n1 && j < n2; k++)
{
if(L[i] > R[j])
{
data[k] = L[i];
i++;
}
else
{
data[k] = R[j];
j++;
}
}
if(i < n1)
{
for(j = i; j < n1; j++, k++)
data[k] = L[j];
}
if(j < n2)
{
for(i = j; i < n2; i++, k++)
data[k] = R[i];
}
}
void merge_sort(int data[], int p, int r)
{
if(p < r)
{
int q = (p + r) / 2;
merge_sort(data, p, q);
merge_sort(data, q + 1, r);
merge(data, p, q, r);
}
}

void test_merge_sort()
{
int data[] = {44, 12, 145, -123, -1, 0, 121};
printf("-------------------------------merge sort----------------------------\n");
out_int_array(data, 7);
merge_sort(data, 0, 6);
out_int_array(data, 7);
}

int main()
{
test_merge_sort();
return 0;
}

4.對於有n個結點的線性表(e0,e1,…,en-1),將結點中某些數據項的值按遞增或遞減的次序,重新排列線性表結點的過程,稱為排序。排序時參照的數據項稱為排序碼,通常選擇結點的鍵值作為排序碼。

若線性表中排序碼相等的結點經某種排序方法進行排序後,仍能保持它們在排序之前的相對次序,稱這種排序方法是穩定的;否則,稱這種排序方法是不穩定的。

在排序過程中,線性表的全部結點都在內存,並在內存中調整它們在線性表中的存儲順序,稱為內排序。在排序過程中,線性表只有部分結點被調入內存,並藉助內存調整結點在外存中的存放順序的排序方法成為外排序。

下面通過一個表格簡單介紹幾種常見的內排序方法,以及比較一下它們之間的性能特點。

排序方法
簡介
平均時間
最壞情況
輔助存儲
是否穩定

簡單排序
選擇排序
反復從還未排好序的那部分線性表中選出鍵值最小的結點,並按從線性表中選出的順序排列結點,重新組成線性表。直至未排序的那部分為空,則重新形成的線性表是一個有序的線性表。
O( )
O( )
O(1)
不穩定

直接插入排序
假設線性表的前面I個結點序列e0,e1,…,en-1是已排序的。對結點在這有序結點ei序列中找插入位置,並將ei插入,而使i+1個結點序列e0,e1,…,ei也變成排序的。依次對i=1,2,…,n-1分別執行這樣的插入步驟,最終實現線性表的排序。
O( )
O( )
O(1)
穩定

冒泡排序
對當前還未排好序的范圍內的全部結點,自上而下對相鄰的兩個結點依次進行比較和調整,讓鍵值大的結點往下沉,鍵值小的結點往上冒。即,每當兩相鄰比較後發現它們的排列順序與排序要求相反時,就將它們互換。
O( )
O( )
O(1)
穩定

希爾排序
對直接插入排序一種改進,又稱「縮小增量排序」。先將整個待排序列分割成為若乾子序列分別進行直接插入排序,待整個序列中的記錄「基本有序」時,再對全體記錄進行一次直接插入排序。
kn ln n
O( )
O(logn)
不穩定

快速排序
對冒泡排序的一種本質的改進。通過一趟掃視後,使待排序序列的長度能大幅度的減少。在一趟掃視後,使某個結點移到中間的正確位置,並使在它左邊序列的結點的鍵值都比它的小,而它右邊序列的結點的鍵值都不比它的小。稱這樣一次掃視為「劃分」。每次劃分使一個長序列變成兩個新的較小子序列,對這兩個小的子序列分別作同樣的劃分,直至新的子序列的長度為1使才不再劃分。當所有子序列長度都為1時,序列已是排好序的了。
O(nlogn)
O( )
O(logn)
不穩定

堆排序
一種樹形選擇排序,是對直接選擇排序的有效改進。一個堆是這樣一棵順序存儲的二叉樹,它的所有父結點(e[i])的鍵值均不小於它的左子結點(e[2*i+1])和右子結點(e[2*i+2])的鍵值。初始時,若把待排序序列的n個結點看作是一棵順序存儲的二叉樹,調整它們的存儲順序,使之成為一個堆,這時堆的根結點鍵值是最大者。然後將根結點與堆的最後一個結點交換,並對少了一個結點後的n-1結點重新作調整,使之再次成為堆。這樣,在根結點得到結點序列鍵值次最大值。依次類推,直到只有兩個結點的堆,並對它們作交換,最後得到有序的n個結點序列。
O(nlogn)
O(nlogn)
O(1)
不穩定

歸並排序
將兩個或兩個以上的有序子表合並成一個新的有序表。對於兩個有序子表合並一個有序表的兩路合並排序來說,初始時,把含n個結點的待排序序列看作有n個長度都為1的有序子表所組成,將它們依次兩兩合並得到長度為2的若干有序子表,再對它們作兩兩合並……直到得到長度為n的有序表,排序即告完成。
O(nlogn)
O(nlogn)
O(n)
穩定

後面根據各種排序演算法,給出了C語言的實現,大家在復習的時候可以做下參考。

u 選擇排序

void ss_sort(int e[], int n)

{ int i, j, k, t;

for(i=0; i< n-1; i++) {

for(k=i, j=i+1; j<n; j++)

if(e[k]>e[j]) k=j;

if(k!=i) {

t=e[i]; e[i]=e[k]; e[k]=t;

}

}

}

u 直接插入排序

void si_sort(int e[], int n)

{ int i, j, t;

for(i=0; i< n; i++) {

for(t=e[i], j=i-1; j>=0&&t<e[j]; j--)

e[j+1]=e[j];

e[j+1]=t;

}

}

u 冒泡排序

void sb_sort(int e[], int n)

{ int j, p, h, t;

for(h=n-1; h>0; h=p) {

for(p=j=0; j<h; j++)

if(e[j]>e[j+1]) {

t=e[j]; e[j]=e[j+1]; e[j+1]=t;

p=j;

}

}

}

u 希爾排序

void shell(int e[], int n)

{ int j, k, h, y;

for(h=n/2; h>0; h=h/2)

for(j=h; j<n; j++) {

y=e[j];

for(k=j-h; k>0&&y<e[k]; k-=h)

e[k+h]=e[k];

e[k+h]=y;

}

}

u 堆排序

void sift(e, n, s)

int e[];

int n;

int s;

{ int t, k, j;

t=e[s];

k=s; j=2*k+1;

while(j<n) {

if(j<n-1&&e[j]<e[j+1])

j++;

if(t<e[j]) {

e[k]=e[j];

k=j;

j=2*k+1;

}else break;

}

e[k]=t;

}

void heapsorp (int e[], int n)

{ int i, k, t;

for(i=n/2-1; i>=0; i--)

sift(e, n, i);

for(k=n-1; k>=1; k--) {

t=e[0]; e[0]=e[k]; e[k]=t;

sift(e, k, 0);

}

}

u 快速排序

void r_quick(int e[], int low, int high)

{ int i, j, t;

if(low<high) {

i=low; j=high; t=e[low];

while(i<j) {

while (i<j&&e[j]>t) j--;

if(i<j) e[I++]=e[j];

while (i<j&&e[i]<=t) i++;

if(I<j) e[j--]=e[i];

}

e[i]=t;

r_quick(e,low,i-1);

r_quick(w,i+1,high);

}

}

另外,外排序是對大型文件的排序,待排序的記錄存儲在外存中,在排序過程中,內存只存儲文件的一部分記錄,整個排序過程需進行多次的內外存間的交換。

*** 查找

查找就是在按某種數據結構形式存儲的數據集合中,找出滿足指定條件的結點。

按查找的條件分類,有按結點的關鍵碼查找、關鍵碼以外的其他數據項查找或其他數據項的組合查找等。按查找數據在內存或外存,分內存查找和外存查找。按查找目的,查找如果只是為了確定指定條件的結點存在與否,成為靜態查找;查找是為確定結點的插入位置或為了刪除找到的結點,稱為動態查找。

這里簡單介紹幾種常見的查找方法。

u 順序存儲線性表的查找

這是最常見的查找方式。結點集合按線性表組織,採用順序存儲方式,結點只含關鍵碼,並且是整數。如果線性表無序,則採用順序查找,即從線性表的一端開始逐一查找。而如果線性表有序,則可以使用順序查找、二分法查找或插值查找。

u 分塊查找

分塊查找的過程分兩步,先用二分法在索引表中查索引項,確定要查的結點在哪一塊。然後,再在相應塊內順序查找。

u 鏈接存儲線性表的查找

對於鏈接存儲線性表的查找只能從鏈表的首結點開始順序查找。同樣對於無序的鏈表和有序的鏈表查找方法不同。

u 散列表的查找

散列表又稱雜湊表,是一種非常實用的查找技術。它的原理是在結點的存儲位置和它的關鍵碼間建立一個確定的關系,從而讓查找碼直接利用這個關系確定結點的位置。其技術的關鍵在於解決兩個問題。

I. 找一個好的散列函數

閱讀全文

與java面試常考演算法組合相關的資料

熱點內容
c語言執行命令行是非同步還是同步 瀏覽:382
用表情命令別人的成語 瀏覽:880
EDA編譯和綜合的區別 瀏覽:673
python密碼排序教學 瀏覽:554
虛擬雲主機試用虛擬代理伺服器 瀏覽:756
androidfastjson下載 瀏覽:437
藍牙傳送安裝包在哪個文件夾 瀏覽:834
百度python爬蟲入門 瀏覽:767
一指禪怎麼用app 瀏覽:461
linux查找後綴 瀏覽:274
反編譯人員 瀏覽:832
電梯里的雲伺服器 瀏覽:78
龍書鯨書虎書編譯原理 瀏覽:753
華為手機怎麼沒有伺服器了 瀏覽:936
能夠反編譯游戲的手機工具 瀏覽:813
電腦里有些文件夾不顯示出 瀏覽:896
聚商銀行app怎麼轉賬 瀏覽:637
愛邦網站伺服器有什麼好處 瀏覽:775
mpv源碼編譯 瀏覽:873
pdf復制限制 瀏覽:442