1. 面試java程序員時被問到：如果你要寫一個俄羅斯方塊的游戲，每種方塊你會考慮用什麼數據結構怎麼答
可以設想長條橫著和豎著的情況，一個塊可以由4*4的二維數組組成。其中由0表示空白，1表示有塊。另外網上還有「88行俄羅斯方塊」的大牛寫的示例，是又把這個二進制數組轉換成了一個相應的整數，空間效率很高。
2. 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. 找一個好的散列函數
3. 關於JAVA和數據結構的問題
編程語言大同小異，基本的邏輯操作都是一樣的。比如與或，if，while這些。
但是java是面向對象，c是面向程序。我先學的c，後學的java，怎麼都轉不過來。現在習慣用java了，又不會用c了。
其實吧，沒必要學c。如果你java學的好，那麼一般的函數調用，參數傳遞和邏輯語句都應該會了吧。這樣接觸一門新的語言就不是啥難事了。編程重要的是思想，
個人覺得初學編程的時候最難的就是邏輯操作。還有參數和函數的調用。這些都會了之後，不用專門學某種編程，都觸類旁通了（匯編除外）。
我學了c之後自學java，現在用的最好的是java，然後可以重構別人的asp，c#,不會寫但是都可以看懂了，看多了就會寫了
4. Java數據結構編程題目
自己參考下吧，希望對你有用！
//用單鏈表來實現多項式的加法，代碼如下
public class Polynomial {
private Monomial first; // 首項
// 添加單項式
public void append(Monomial monomial) {
if (monomial == null) {
// do nothing
} else if (first == null) {
first = monomial;
} else {
Monomial current = first;
while (current != null) {
// 提示:如果指數相同，則相加
if (current.index == monomial.index) {
current.coefficient += monomial.coefficient;
break;
} else if (current.next == null) { // 否則直接把此項扔到最後
current.next = monomial;
break;
}
current = current.next;
}
}
}
public void append(int c, int i) {
append(new Monomial(c, i));
}
public String toString() {//toString()方法就是把對象轉換成String類型
//比如一個Integer對象的toString方法就是把這個對象表示的整數轉化成字元串，133就成了"133"。
StringBuffer sb = new StringBuffer();
Monomial current = first;
while (current.next != null) {
sb.append("(" + current.coefficient + "x^" + current.index
+ ") + ");
current = current.next;
}
sb.append("(" + current.coefficient + "x^" + current.index + ")");
return sb.toString();
}
// 兩個多項式相加
public Polynomial add(Polynomial p2) {
Polynomial result = new Polynomial();
Monomial current = this.first;
while (current != null) {
result.append(current.coefficient, current.index); // 提示:注意這里
current = current.next;
}
current = p2.first;
while (current != null) {
result.append(current.coefficient, current.index);
current = current.next;
}
return result;
}
public static void main(String[] args) {
//構造多項式p1的每一項
Polynomial p1 = new Polynomial();
p1.append(3, 4);
p1.append(-6, 2);
p1.append(5, 1);
p1.append(-10, 0);
System.out.println("p1: " + p1);
//構造多項式p2的每一項
Polynomial p2 = new Polynomial();
p2.append(2, 5);
p2.append(-6, 2);
p2.append(5, 1);
System.out.println("p2: " + p2);
Polynomial result = p1.add(p2);
System.out.println("p1+p2= " + result);
}
}
/**
* 這是一個內部類
* 單項式的表示
*/
class Monomial {
int coefficient; // 系數
int index; // 指數
Monomial next; // 後繼結點
public Monomial() {
}
public Monomial(int c, int i) {
this.coefficient = c;
this.index = i;
}
}
5. java開發面試難嗎應該注意啥
與正常面試一樣，首先需要進行自我介紹、所學專業、在校期間參加的比賽以及項目經驗，其中項目經驗是最重要的，因為java開發主要就是技術支持，如果你寫過好的程序相應的也得過一些獎勵，不過這些獎勵最好是有點代表性的，比如ACM地區賽、國家賽這類的，勢必會對你的面試有所幫助
無論你是否為學計算機、軟體開發等專業的學生，面試官都會問你為什麼會選擇IT行業，如果你是女生，開發本來就是重男輕女的活，面試官可能會問壓力方面、今後婚姻方面以及你將如何在同行業中獲得競爭優勢等等一系列問題；
之後就是考專業性的了，會不會JSP框架，繼承這個類那個類有什麼區別，Java中的IO類怎麼怎麼樣的，或者說是如果讓你開發軟體你該怎麼進行設計等，口頭上考的專業性的東西應該不太多，因為正常開發都會有筆試，除非是面試特別高端的企業（比如IBM）。
對了，有筆試的話如果你的筆試成績不錯那還好，如果筆試成績打的擦邊球，那面試官就會以你專業性不夠扎實對你進行刁難，這個有點准備。
6. 程序員小白如何通過Java面試
1、了解業內招聘要求：多看幾家同類崗位的技術要求，大概就知道用人單位的需求了
2、多找找面試常見技術題：不同企業的面試題各種不同，多去找找，多背背
3、簡歷設計：這個就是要注意在簡歷中體現自己的項目經驗、技術水平
4、面試現場反應：注意自己的著裝、語言表達、技術表達
以上都是在你有專業技術的前提下進行的，如果專業技術就是小白，還是先提升專業技術吧
7. java數據結構與演算法分析
於之前面試android的時候考到了很多關於java的知識，所以這次重溫數據結構知識就打算用java來學習，畢竟android是以java為基礎的，而且我現在學習的j2ee架構也是以java為基礎的。
java中的類就是對現實世界的對象的一種抽象，例如人就是一個類別，人有名字，聯系電話，住址等成員屬性，人擁有說話，吃飯，走路等成員方法。類就是這樣，定義了一種對象，它有什麼，會做什麼。
繼承——子類就是父類的一種特定類別。例如學生就是人的子類，學生屬於人，是特定的一類人。所以我們讓學生繼承人，這樣學生可以擁有人的屬性和方法，也就是說，學生也有了名字，聯系電話，住址等成員屬性，擁有說話，吃飯，走路等成員方法。但是學生還有特定的一些方法（讀書，上課），或者特定的一些屬性（學號，年級），這些可以添加在子類中。
因為每個子類都屬於父類，例如每個學生都屬於人，所以可以用父類來引用子類的對象:People p = new Student();反過來不行。
java中一個類只能繼承一個父類，也就是單繼承。
但一個類可以實現多個介面，間接地實現了多繼承。介面就是一系列方法的聲明，沒有實現。於之前面試android的時候考到了很多關於java的知識，所以這次重溫數據結構知識就打算用java來學習，畢竟android是以java為基礎的，而且我現在學習的j2ee架構也是以java為基礎的。
java中的類就是對現實世界的對象的一種抽象，例如人就是一個類別，人有名字，聯系電話，住址等成員屬性，人擁有說話，吃飯，走路等成員方法。類就是這樣，定義了一種對象，它有什麼，會做什麼。
繼承——子類就是父類的一種特定類別。例如學生就是人的子類，學生屬於人，是特定的一類人。所以我們讓學生繼承人，這樣學生可以擁有人的屬性和方法，也就是說，學生也有了名字，聯系電話，住址等成員屬性，擁有說話，吃飯，走路等成員方法。但是學生還有特定的一些方法（讀書，上課），或者特定的一些屬性（學號，年級），這些可以添加在子類中。
因為每個子類都屬於父類，例如每個學生都屬於人，所以可以用父類來引用子類的對象:People p = new Student();反過來不行。
java中一個類只能繼承一個父類，也就是單繼承。
但一個類可以實現多個介面，間接地實現了多繼承。介面就是一系列方