Volání metod posloupnosti – Java – Fórum – Programujte.com

Zdravím rádcové,

mám tu program, který dle určitého algoritmu počítá ze dvouciferného čísla posloupnost, pak jí seřadí a vypíše buď na obrazovku nebo do souboru. To podle toho, jak se program spustí. Jestliže ho spustíme bez parametru, vypíše na obrazovku danou posloupnost, pod ní seřazenou a ještě vykreslí graf seřazené i neseřazené posloupnosti. O graf se stará metoda kreslit, do které vstupují dvě posloupnosti a číslo, které určuje počet prvků v poli ale to není důležité. A teď k jádru věci. Potřebuju, aby mi do metody kreslit vstoupili dvě posloupnosti. Jedna normálně neseřazená a ta druhá seřazená... problém je, že mi tam vstupuje pouze ta seřazená. Poradíte někdo? Zde je celý program:

	import java.util.*;
	import java.io.*;
	import java.awt.*;

	class xxx {
		
		public static int TEXT=0,GRAF=1;
		public static FileInputStream fis;
		public static FileOutputStream fos;
		public static PrintStream ps;
		
		/**
		 * Načte ze vstupu kladné dvouciferné číslo
		 * @return
		 */
		
		public static int dvouciferne() {
			int cislo;
			Scanner scan = new Scanner(System.in);

			do {
				System.out.print("Zadej dvouciferne cislo: ");
				cislo=scan.nextInt();
				cislo=Math.abs(cislo);
			}
			while (cislo<10 || cislo>99);

			return cislo;
		}
		
		/**
		 * Zjišťuje, jestli se číslo v poli už nevyskytuje
		 * @param cislo
		 * @param pole
		 * @param pocet
		 * @return
		 */
		
		public static int vyskyt(int cislo,int[] pole,int pocet) {
			int i;

			for (i=0;i<pocet;++i)
				if (cislo==pole[i])
					return 1;

			return 0;
		}
		
		/**
		 * Počítá další číslo dle zadaného algoritmu
		 * @param cislo
		 * @return
		 */
		
		public static int dalsi(int cislo) {
			cislo=cislo*cislo;
			while (cislo>=100)
				cislo=cislo/10;
			cislo=cislo+1;

			return cislo;
		}
		
		/**
		 * Vyplní pole čísly do prvního opakování
		 * @param hodnota
		 * @param pole
		 * @return
		 */
		
		public static int naplnit(int hodnota,int[] pole) {
			int pocet;

			for (pocet=0;vyskyt(hodnota,pole,pocet)==0;++pocet) {
				pole[pocet]=hodnota;
				hodnota=dalsi(hodnota);
			}

			return pocet;
		}
		
		/**
		 * Vypíše zadaný počet prvků do souboru
		 * @param pole
		 * @param pocet
		 */
		
		public static void vypsatT(int[] pole,int pocet) {
			int i;
                
			ps.print(pocet+" [");
			for (i=0;i<pocet;++i)
				ps.print((i>0?", ":"")+pole[i]);
			ps.println("]");
		}
		
		/**
		 * Vypíše zadaný počet prvků na obrazovku
		 * @param pole
		 * @param pocet
		 */
		
		public static void vypsatG(int[] pole,int pocet) {
			int i;
         
			System.out.print(pocet+" [");
			for (i=0;i<pocet;++i)
				System.out.print((i>0?", ":"")+pole[i]);
			System.out.println("]");
		}
		
		/***
		 * Seřadí pole metodou InsertSort
		 * @param pole
		 * @param pocet
		 */
		
		public static void seradit(int[] pole,int pocet) {
			int i,j,temp;

			for (i=1;i<pocet;++i) {
				temp=pole[i];
				for (j=i;j>0 && pole[j-1]>temp;--j)
					pole[j]=pole[j-1];
				pole[j]=temp;
			}
		}
		
		/**
		 * Kreslí graf
		 * @param a
		 * @param b
		 * @param pocet
		 */
		
		public static void kreslit(int[] a, int[] b, int pocet) {
			int VYSKA = 600;
			int SIRKA = pocet*35;
			DrawingTool dt = new DrawingTool(SIRKA, VYSKA, Color.WHITE, true);
			dt.setColor(Color.BLACK);
			int mezeraMeziRadky = VYSKA / 20;
			for (int y = 0; y < 20; y++) {
				dt.line(0, mezeraMeziRadky * y, SIRKA, mezeraMeziRadky * y);
				dt.line(0,VYSKA-1,SIRKA,VYSKA-1);
			}
			dt.setColor(Color.BLUE);
			int sirkaSloupce = ((SIRKA - 10) / pocet) - 1;
			for (int i = 0; i < pocet; i++) {
				int x = i * (sirkaSloupce + 1);
				for (int y = 0; y < sirkaSloupce; y++) {
					dt.line(x + y + 4, VYSKA / 2, x + y + 4, (VYSKA / 2) - (VYSKA / 2 / 100) * a[i]);
				}
			}
    	  
			dt.setColor(Color.RED);
			for (int i = 0; i < pocet; i++) {
				int x = i * (sirkaSloupce + 1);
				for (int y = 0; y < sirkaSloupce; y++) {
					dt.line(x + y + 4, VYSKA, x + y + 4, (VYSKA) - (VYSKA / 2 / 100) * b[i]);
				}
			}
		}
		
		/**
		 * Zpracuje sekvenci pro zadané číslo
		 * @param cislo
		 * @param graf
		 */
		
		public static void zpracuj (int cislo,int graf) {
			int pocet;
			int[] pole=new int[30];

			pocet=naplnit(cislo,pole);
			if (graf>0) {
				vypsatG(pole, pocet);
				seradit(pole, pocet);
				vypsatG(pole, pocet);
				seradit(pole, pocet);
				kreslit(pole, pole, pocet);
			}
			else {
				vypsatT(pole, pocet);
				seradit(pole, pocet);
				vypsatT(pole, pocet);
				ps.println();
			}
		}
		
		/**
		 * Hlavní program
		 * @param args
		 * @throws java.lang.Exception
		 */
		
		public static void main (String[] args) throws java.lang.Exception {
			if (args.length>0) {
				fis = new FileInputStream(args[0]);
				Scanner scan = new Scanner(fis);
				fos = new FileOutputStream("vystup.txt");
				ps = new PrintStream(fos);
				while (scan.hasNextInt())
					zpracuj(scan.nextInt(),TEXT);
				fos.close();
				fis.close();
			}
			else
			{
				zpracuj(dvouciferne(),GRAF);
			}
		}

	}

Nevím, zda k tomu potřebujete program, který dělá graf...

Protože tam dvakrát dáváš stejné pole.

kreslit(pole, pole, pocet);

No a jak tedy docílit toho, aby mi tam šli dvě různé pole. Zkusil jsem udělat to, že jsem v metodě seradit vytvořil kopii toho původního neseřazeného pole aby to původní zůstalo ale udělalo to to, že se mi v grafu zobrazují místo dvou seřazených dvě neseřazené...

Když seřadíš tu kopii a pak do vykreslit zase dvakrát dáš to původní, tak se ti samozřejmě dvakrát vykreslí to původní.

int[] puvodni = new int[30];
int[] serazene;

pocet = naplnit(cislo, puvodni);
serazene = Arrays.copyOf(puvodni, pocet);
...
seradit(serazene, pocet);
...
kreslit(puvodni, serazene, pocet);

Kopii pole jsem teda vytvořil v metodě seradit a metodu zpracuj jsem upravil takto:

		public static void zpracuj (int cislo,int graf) {
			int pocet;
			int[] pole=new int[30];
			int[] serazena;

			pocet=naplnit(cislo,pole);
			serazena = Arrays.copyOf(pole, pocet);
			if (graf>0) {
				vypsatG(pole, pocet);
				seradit(serazena, pocet);
				vypsatG(pole, pocet);
				seradit(serazena, pocet);
				kreslit(pole, serazena, pocet);
			}
			else {
				vypsatT(pole, pocet);
				seradit(pole, pocet);
				vypsatT(pole, pocet);
				ps.println();
			}
		}

stejně mi to ale pořád vykresluje dvě neseřazené posloupnosti... kde dělám chybu?

Tak, už jsem na to přišel. Teď se to jeví jako vcelku jasná a jednoduchá záležitost. Stačilo jen v metodě zpracuj vytvořit další pole s kopií toho původního neseřazeného a pak už si metoda kreslit sama načetla obě pole. Nic víc a nikde jinde :D

Blik :)