InFix zu Postfix (upn)

[gallstone]

hallo,

habe die aufgabe ein proggie zu bauen, in dem Infix zu Postfix-Notations mittels selbstgeschiebenen Stack (der geht) umgeformt werden soll.

aber irgendwie haut das nicht hin.

ich übergebe einen mathematischen ausdruck mittels args.
3 + 3 wird zu 3 3 +
sobald ich aber ne klammer rein hau. kackt er ab.


hier ma der code:

import java.*;
import java.io.IOException;
import java.math.*;
public class aufgabe1 {
		
	public static Stack stack=new Stack();

	
	public static int zaehleZeichen(String [] s){
		int zeichen=0;
		int i=0;
		while (i<s.length){
			if ((s[i]=="(")||(s[i]==")")){
			}
			else {
				zeichen=zeichen+1;
			}
			i=i+1;
		}		
		return zeichen;
	}
	
	public static String [] upn(String[] str){
		String[] feld=new String[zaehleZeichen(str)];
		int i=0;		//für str
		int y=0;		//für feld
		
		
		while (i<str.length){
			if ((str[i].equals("*")==true) || (str[i].equals("/")==true) || (str[i].equals("-")==true) || (str[i].equals("+")==true)||(str[i].equals("(")==true)||(str[i].equals(")")==true)){
				if (str.equals("(")==true){
					stack.push(str[i]);
					System.out.println("Klammer ("+stack.peek());
				}
				if ((str[i].equals("*")==true)|| (str[i].equals("/")==true)){
					stack.push(str[i]);
					System.out.println("operatoren * / "+stack.peek());
				}
				if ((str[i].equals("-")==true)||(str[i].equals("+")==true)){
					while ((stack.isEmpty()==false)&&((stack.peek().equals("*")==true)|| (stack.peek().equals("/")==true))){
						feld[y]=stack.pop();
						y=y+1;
						}
					}
					stack.push(str[i]);
					System.out.println("operatoren - + " +stack.peek());
				}
				if (str.equals(")")==true){
					while ((stack.peek()!="(")&&(y<feld.length)&&(stack.isEmpty()==false)){
						System.out.println("klammer ( ins feld"+stack.peek());
						feld[y]=stack.pop();
						y=y+1;
					}
					if ((stack.peek()=="(")){
						System.out.println("klammer ( wird entfernt)"+stack.peek());
						stack.pop();
						
					}					
			}
			
			else{
				feld[y]=str[i];
				
			}
				y=y+1;
			i=i+1;
		}
		while (stack.isEmpty()==false){
			System.out.println("zahlen übergabe" +stack.peek());
			feld[y]=stack.pop();
			y=y+1;
		}
		return feld;
	}
		
		
public static String feldzustring(String []f){
		int i=0;
		String ausgabe="";
		while (i<f.length){
			ausgabe=ausgabe+f[i];
			i=i+1;
		}
		return ausgabe;
		
	}
	
	

	
	
	public static void main(String[] args) throws IOException{
	
			String [] huhu;
			huhu=upn(args);
			System.out.println(feldzustring(huhu));

	
	}
	
}

ich weiß nich mehr weiter ... hänge da schon stunden davor und meine blockade löst sich nicht.... wer kann mir helfen.?

mfg

 

[SlaterB]

da war ja ne Menge Menge falsch,
nach der nicht zu knappen Wartezeit hier mal eine bessere Version

import java.io.IOException;
import java.util.Stack;

public class Aufgabe1 {

	public static Stack stack = new Stack();

	public static int zaehleZeichen(String[] s) {
		int zeichen = 0;
		int i = 0;
		while (i < s.length) {
			if (s[i].equals("(") || s[i].equals(")")) {
			} else {
				zeichen = zeichen + 1;
			}
			i = i + 1;
		}
		return zeichen;
	}

	public static String[] upn(String[] str) {
		String[] feld = new String[zaehleZeichen(str)];
		System.out.println("Länge: " + feld.length);
		int i = 0; //für str
		int y = 0; //für feld

		while (i < str.length) {

			if (str[i].equals("(")) {
				stack.push(str[i]);
				System.out.println("Klammer (" + stack.peek());
			} else if ((str[i].equals("*")) || (str[i].equals("/"))) {
				stack.push(str[i]);
				System.out.println("operatoren * / " + stack.peek());
			} else if ((str[i].equals("-")) || (str[i].equals("+"))) {
				while (!stack.isEmpty()
					&& ((stack.peek().equals("*"))
						|| (stack.peek().equals("/")))) {
					feld[y] = (String) stack.pop();
					y = y + 1;
					System.out.println("y++ 1");
				}

				stack.push(str[i]);
				System.out.println("operatoren - + " + stack.peek());

			} else if (str[i].equals(")")) {
				while (!stack.peek().equals("(")
					&& (y < feld.length)
					&& !stack.isEmpty()) {

					System.out.println("klammer ( ins feld" + stack.peek());
					feld[y] = (String) stack.pop();
					y = y + 1;
					System.out.println("y++ 2");
				}
				if (stack.peek().equals("(")) {
					System.out.println(
						"klammer ( wird entfernt)" + stack.peek());
					stack.pop();

				}
			} else {
				feld[y] = str[i];
				y = y + 1;
				System.out.println(str[i]+" y++ 3 " + stack.isEmpty());
			}

			i = i + 1;
		}
		while (!stack.isEmpty()) {
			System.out.println("zahlen übergabe" + stack.peek());
			feld[y] = (String) stack.pop();
			y = y + 1;
			System.out.println("y++ 4");
		}
		return feld;
	}

	public static String feldzustring(String[] f) {
		int i = 0;
		String ausgabe = "";
		while (i < f.length) {
			ausgabe = ausgabe + f[i];
			i = i + 1;
		}
		return ausgabe;

	}

	public static void main(String[] args) throws IOException {

		String[] huhu = new String[] { "(", "3", ")", "+", "3" };
		huhu = upn(huhu);
		System.out.println("fertig: " + feldzustring(huhu));

	}

}

die wichtigsten Tipps:
Strings mit equals vergleichen, nicht mit ==!,
str und str nicht verwechseln..

== true, == false stören

 

[gallstone]

vielen dank!
das mit den strings vergl. hab ich dann auch gemerkt (-:
und auch das ich ab und an verpeilt hab hinzuschreiben! letztendlich klappte es dann noch noch. werde mir aber mal deine version genau anschauen...
hier mal meine:

import java.*;
import java.io.IOException;
import java.math.*;
public class aufgabe1 {
	//globaler stack	
	public static Stack stack=new Stack();
	
	//zaehlt die zeichen / felder in einem string[] | außer (,).
	public static int zaehleZeichen(String [] s){
		int zeichen=0;
		int i=0;
		while (i<s.length){
			if ((s[i].equals("("))||(s[i].equals(")"))){
			}
			else {
				zeichen=zeichen+1;
			}
			i=i+1;
		}		
		return zeichen;
	}
	//meth für Infix zu Postfix
	public static String [] upn(String[] str){
		
		String[] feld=new String[zaehleZeichen(str)];		//bestimmung der feldanzahl ohne klammern
		int i=0;		//für str
		int y=0;		//für feld
		while (i<str.length){
			if ((str[i].equals("*")==true) || (str[i].equals("/")==true) || (str[i].equals("-")==true) || (str[i].equals("+")==true)||(str[i].equals("(")==true)||(str[i].equals(")")==true)){
				
				if (str[i].equals("(")==true){
					stack.push(str[i]);		//klammer wird auf stack gelegt
				}
				if ((str[i].equals("*")==true)|| (str[i].equals("/")==true)){
					stack.push(str[i]);			//operatoren * oder / werden auf stack gelegt
					
				}
				//abarbeitung bei + und -
				if ((str[i].equals("-")==true)||(str[i].equals("+")==true)){	
					if ((stack.isEmpty()==false)){
						if ((stack.peek().equals("*")==true)|| (stack.peek().equals("/")==true)){
							
						while ((stack.isEmpty()==false)&&((stack.peek().equals("*")==true)|| (stack.peek().equals("/")==true))){
							feld[y]=stack.peek().toString();stack.pop();		//wenn rechenzeichen höhere rangordnung werden diese auf das feld gelegt
							y=y+1;	
						}
						}
						if ((stack.isEmpty()==false)&&((stack.peek().equals("+")==true)|| (stack.peek().equals("-")==true))){
							feld[y]=stack.peek().toString();stack.pop();
							y=y+1;		
						}
					}
					else{
						if (stack.isEmpty()==false){
						feld[y]=stack.peek().toString();stack.pop();		//wenn rechenzeichen höhere rangordnung werden diese auf das feld gelegt
						y=y+1;
						}				
					}
					stack.push(str[i]);			// + oder - werden auf stack gelegt
				}
				if (str[i].equals(")")==true){
					
					while ((stack.isEmpty()==false)&& (stack.peek().equals("(")==false) &&(y<feld.length)){
						feld[y]=stack.peek().toString();
						stack.pop();	//solange keine ) werden wird der stackinhalt auf das feld gebracht
					}
					if ((stack.isEmpty()==false)&&(stack.peek().equals("("))){
						stack.pop();	//wenn  wird das diese vom stack entfernt
					}
				}		
			}
			else{
				feld[y]=str[i];
				y=y+1;	
				if (stack.isEmpty()==false){
					if ((stack.peek().equals("+")==true)||(stack.peek().equals("-")==true||(stack.peek().equals("/")==true)||(stack.peek().equals("*")==true))==true){
					feld[y]=stack.peek().toString();stack.pop();
					y=y+1;		
					}
				}
			}
			i=i+1;
		}
//		stack wird geleert
		while ((stack.isEmpty()==false)&&(y<feld.length)){
					if (stack.peek().equals("(")){
					stack.pop();
					}
					feld[y]=stack.peek().toString();stack.pop();
					y=y+1;			
		}
		return feld;
	}
	//funktion zum auswerten eines upn string[]
	public static BigInteger auswerten(String[] str){
		Stack ausw=new Stack();		//aufbewarungsstack für zahlen
		int i=0;
		BigInteger z1;
		BigInteger z2;
		while ((i<str.length)){
			if ((str[i].equals("*")==true)||(str[i].equals("/")==true)||(str[i].equals("+")==true)||(str[i].equals("-")==true)){
				z2=new BigInteger(ausw.peek().toString());
				ausw.pop();
				z1=new BigInteger(ausw.peek().toString());
				ausw.pop();
				if ((str[i].equals("+")==true)){
					z1=z1.add(z2);
					ausw.push((z1.toString()));
				}
				if ((str[i].equals("/")==true)){
					z1=z1.divide(z2);
					ausw.push((z1.toString()));
				}
				if ((str[i].equals("*")==true)){
					z1=z1.multiply(z2);
					ausw.push((z1.toString()));
				}
				if ((str[i].equals("-")==true)){
					z1=z1.subtract(z2);
					ausw.push((z1.toString()));
				}			
			}
			else{
				ausw.push(str[i]);		
			}
			i=i+1;	
		}
		return new BigInteger(ausw.peek().toString()); //letzte wert auf stack ist das erg
	}
			
	//Feld wird in string gebracht um es auszugeben
	public static String feldzustring(String []f){
		int i=0;
		String ausgabe="";
		while (i<f.length){
			ausgabe=ausgabe+f[i];
			i=i+1;
		}
		return ausgabe;
		
	}
	
	//mainprogg
	public static void main(String[] args) throws IOException{
			if (args.length>0){
				System.out.println("InFix-style: "+feldzustring(args));
				System.out.println("upn-style: "+feldzustring(upn(args)));
				System.out.println("upn ausgerechnet: "+auswerten(upn(args)));
			}
			else{
				System.out.println("Also nen String muzs schon her!");
			}
	}
			
	
}

pop() löscht nur oberen stapel ...
ach ja fehler fängt es auch noch net ab!
mfg