說數據結構沒用那是不可能的，但是要看你做什麼了。
比如說你要血java，如果你想搞網站方面的話就簡單了。
數據結構基本可以不用學，因為在web應用中，能用到的演算法的地方少之又少，幾乎就那麼幾個，想記不住都難。
但是如果你要往軟體方面和手軟方面發展的話就要學一部分了，但是這東西學是學不到的，能學到的只不過是思路，到時候自己發揮一下，想個演算法就行了，演算法這東西說難不難，難的東西有，但是沒有你能用到的。
像你這樣的情況我想說兩點：
首先，說你想從事演算法類的工作，那麼選擇什麼樣的語言都是一樣的，演算法肯定有，但是用到的都不多。剛進公司的時候一般是用不到演算法的，因為演算法都是別人想的，你也許有好的演算法，但是別人不一定採用，但是你的演算法基礎不要丟掉，因為等你當了項目經理後這個是必不可少的。
其次，你要知道，在學計算機的路上，很少有人能學什麼就做什麼，大家都在被社會潮流推動，想要不掉隊就只能隨波逐流。因為畢竟我們都不想一輩子寫代碼。大家都是拿這東西做個跳板。
學java的路很長，但是也很有趣，希望你能學好。我想以你的演算法基礎，以後想成為專業精英不是問題。加油吧。
② JAVA數據結構與演算法
給你寫了答案如下，有問題再追問。
B
A
C
確切性
3
infexOf
隊頭指針指向隊尾
對
對
順序表：查找方便，但插入困難；
鏈表：查找困難，但插入方便。
//最大值
publicstaticintgetMax(intn,int[]arr){//n是數組最後一個元素的index
if(n==0)
returnarr[0];
if(arr[n]>getMax(n-1,arr))
returnarr[n];
returngetMax(n-1,arr);
}
//平均值
publicstaticintgetAverage(intn,int[]arr){//n是數組最後一個元素的index
if(n==1)
returnarr[0];
return(arr[n]+getAverage(n-1,arr)*(n-1))/n;
}
//刪除節點
publicstaticNodermNode(Nodehead,Nodenode){
Nodetemp=head;
while(temp.next!=null){
if(temp.next==node){
temp.next=node.next;
break;
}
else
temp=temp.next;
}
returnhead;
}
//數組元素逆置
publicstaticint[]inverseArray(int[]arr){
intstart=0;
intend=arr.length-1;
for(;start<arr.length/2;start++,end--){
inttemp=arr[start];
arr[start]=arr[end];
arr[end]=temp;
}
returnarr;
③ 一道java數據結構編程題。
/**
*四則運算表達式計算
*@authorpenli
*
*/
publicclassArithmetic{
publicstaticvoidmain(Stringargs[]){
System.out.println(arithmetic("2.2+((3+4)*2-22)/2*3.2"));
}
publicstaticdoublearithmetic(Stringexp){
Stringresult=parseExp(exp).replaceAll("[\[\]]","");
returnDouble.parseDouble(result);
}
/**
*解析計算四則運算表達式，例：2+((3+4)*2-22)/2*3
*@paramexpression
*@return
*/
publicstaticStringparseExp(Stringexpression){
//StringnumberReg="^((?!0)\d+(\.\d+(?<!0))?)|(0\.\d+(?<!0))$";
expression=expression.replaceAll("\s+","").replaceAll("^\((.+)\)$","$1");
StringcheckExp="\d";
StringminExp="^((\d+(\.\d+)?)|(\[\-\d+(\.\d+)?\]))[\+\-\*\/]((\d+(\.\d+)?)|(\[\-\d+(\.\d+)?\]))$";
//最小表達式計算
if(expression.matches(minExp)){
Stringresult=calculate(expression);
returnDouble.parseDouble(result)>=0?result:"["+result+"]";
}
//計算不帶括弧的四則運算
StringnoParentheses="^[^\(\)]+$";
StringpriorOperatorExp="(((\d+(\.\d+)?)|(\[\-\d+(\.\d+)?\]))[\*\/]((\d+(\.\d+)?)|(\[\-\d+(\.\d+)?\])))";
StringoperatorExp="(((\d+(\.\d+)?)|(\[\-\d+(\.\d+)?\]))[\+\-]((\d+(\.\d+)?)|(\[\-\d+(\.\d+)?\])))";
if(expression.matches(noParentheses)){
Patternpatt=Pattern.compile(priorOperatorExp);
Matchermat=patt.matcher(expression);
if(mat.find()){
StringtempMinExp=mat.group();
expression=expression.replaceFirst(priorOperatorExp,parseExp(tempMinExp));
}else{
patt=Pattern.compile(operatorExp);
mat=patt.matcher(expression);
if(mat.find()){
StringtempMinExp=mat.group();
expression=expression.replaceFirst(operatorExp,parseExp(tempMinExp));
}
}
returnparseExp(expression);
}
//計算帶括弧的四則運算
StringminParentheses="\([^\(\)]+\)";
Patternpatt=Pattern.compile(minParentheses);
Matchermat=patt.matcher(expression);
if(mat.find()){
StringtempMinExp=mat.group();
expression=expression.replaceFirst(minParentheses,parseExp(tempMinExp));
}
returnparseExp(expression);
}
/**
*計算最小單位四則運算表達式（兩個數字）
*@paramexp
*@return
*/
publicstaticStringcalculate(Stringexp){
exp=exp.replaceAll("[\[\]]","");
Stringnumber[]=exp.replaceFirst("(\d)[\+\-\*\/]","$1,").split(",");
BigDecimalnumber1=newBigDecimal(number[0]);
BigDecimalnumber2=newBigDecimal(number[1]);
BigDecimalresult=null;
Stringoperator=exp.replaceFirst("^.*\d([\+\-\*\/]).+$","$1");
if("+".equals(operator)){
result=number1.add(number2);
}elseif("-".equals(operator)){
result=number1.subtract(number2);
}elseif("*".equals(operator)){
result=number1.multiply(number2);
}elseif("/".equals(operator)){
result=number1.divide(number2);
}
returnresult!=null?result.toString():null;
}
}
④ 用java編寫一個數據結構的題！
線性表跟是不是數組沒關系啊。。。棧和隊列都是線性表吧。。不太懂你的意思。。
public class SeqList {
public static void main(String[] args) {
int[] a = new int[]{1,2,3,4,5,6,7};
int[] b = new int[]{3,5,8,9};
int[] c = new int[a.length + b.length];
new SeqList().seqListMerge(a, b, c);
}
public void seqListMerge(int[] a, int[] b, int[] c){
//i為數組a的計數器
int i = 0;
//j為數組b的計數器
int j = 0;
//k為數組c的計數器
int k = 0;
//判斷兩個數組長度，當一個先用完的時候推出循環
while(i < a.length && j < b.length){
if(a[i] > b[j]){
c[k] = b[j];
k++;
j++;
}else{
c[k] = a[i];
k++;
i++;
}
}
//如果a數組先到結尾，那麼把b數組的剩下的值拼到c里
if( i == a.length){
while(j < b.length){
c[k] = b[j];
k++;
j++;
}
}
//如果b數組先到結尾，那麼把a數組的剩下的值拼到c里
if(j == b.length){
while(i < a.length){
c[k] = a[i];
k++;
i++;
}
}
for(int p : c){
System.out.println(p);
}
}
}
⑤ 兩道java數據結構題~~
我沒有時間寫不過告訴你演算法吧
1.棧是後入先出，隊列是先入先出，那麼兩個棧，兩次LIFO之後不是就是先入先出嘛
2.鏈表兩個域，那麼先存儲頭指針所指，再用前後兩個引用變數進行反向賦值