说数据结构没用那是不可能的，但是要看你做什么了。
比如说你要血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.链表两个域，那么先存储头指针所指，再用前后两个引用变量进行反向赋值