Izpitno vprašanje DIRI2005 6100

Iz MaFiRaWiki

(Razlika med različicami)
Različica od 13:24, 11 februar 2008
PeterMarcic (Pogovor | prispevki)

← Prejšnja različica
Različica od 08:27, 13 februar 2008
PeterMarcic (Pogovor | prispevki)

Naslednja različica →
Vrstica 34: Vrstica 34:
== Odgovor == == Odgovor ==
 +
 +V podanem primeru programčka pripravimo sklad števil. Sklad pripravimo tako, da imamo elemente podvojene ali celo potrojene. Za izpis elementov sklada v takšnem vrstnem redu kot so bili vstavljeni si pripravimo pomožen sklad.
 +
 +Algoritem: dokler osnovni sklad ni prazen, elemente prelagamo v nov pomožen sklad. Vrhnji element preložimo v nov pomožen sklad in ga odstranimo iz sklada. Naslednji vrhnji element primerjamo s predhodnim vrhnjim elementom. V kolikor sta elementa enaka vrhnji element iz sklada odstranimo, sicer ga preložimo
 +v nov pomožen sklad. Hkrati postane vrhnji element, element s katerim nato primerjamo naslednje elemente sklada. Dobljen sklad je v obratnem vrstnem redu kot osnoven sklad, zato ga še preložimo.
 +Nov sklad izpišemo.
 +
 +
 +<java>import java.util.* ;
 +public class Primer6100
 +{
 + public static void main(String args[])
 + {
 + int element;
 + // priprava sklada
 + Stack<Integer> Sklad = new Stack<Integer>();
 + element = 1 ;
 + // polnjenje sklada
 + while ( element <= 10 )
 + {
 + Sklad.push(element);
 + Sklad.push(element);
 + Sklad.push(element);
 + element ++ ;
 + }
 + //izpis pripravljenega sklada
 + //priprava pomoznega sklada
 + Stack<Integer> Sklad_obrnjen = new Stack<Integer>();
 + // polnjenje pomoznega sklada
 + while (!Sklad.empty())
 + {
 + Sklad_obrnjen.push(Sklad.pop());
 + }
 + System.out.println();
 + System.out.println("Izpis sklada :");
 + System.out.println();
 + while (!Sklad_obrnjen.empty())
 + {
 + System.out.print(Sklad_obrnjen.peek() + " ");
 + Sklad.push(Sklad_obrnjen.pop());
 + }
 + System.out.println();
 + System.out.println();
 + // priprava novega,pomožnega sklada
 + Stack<Integer> Sklad_nov_obrnjen = new Stack<Integer>();
 + // Algoritem
 + element = Sklad.peek() ;
 + Sklad_nov_obrnjen.push(Sklad.pop());
 + while (!Sklad.empty())
 + {
 + if ( Sklad.peek() == element )
 + {
 + Sklad.pop();
 + }
 + else
 + {
 + Sklad_nov_obrnjen.push(Sklad.pop());
 + element = Sklad.peek();
 + }
 + }
 + System.out.println();
 + System.out.println("Izpis novega sklada :");
 + System.out.println();
 + while (!Sklad_nov_obrnjen.empty())
 + {
 + System.out.print(Sklad_nov_obrnjen.peek() + " ");
 + Sklad_nov_obrnjen.pop();
 + }
 + System.out.println();
 + System.out.println();
 + }
 +}</java>
 +//Izpis sklada
 +//1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8 8 8 9 9 9 10 10 10
 +//Izpis novega sklada
 +//1 2 3 4 5 6 7 8 9 10

Različica od 08:27, 13 februar 2008

Predmet Dopolnilno izobraževanje iz računalništva in informatike (DIRI)

Vprašanje

|Vpr. 6100| Dan je nepadajoče urejen sklad. S pomočjo osnovnih operacij izbriši vse podvojene elemente v skladu.


Podatkovna struktura Sklad je v Javini knjižnici predstavljena z razredom Stack. Osnovne operacije s katerimi upravljamo s skladom so predstavljene z metodami razreda Stack. Razred - class Stack vsebuje metode, s pomočjo katerih upravljamo s skladom. S pomočjo metod razreda Stack vstavljamo elemente v sklad, odstranjujemo elemente iz sklada, preverjamo ali je sklad prazen, preverjamo kateri element je na vrhu sklada.

Metode razreda Stack delujejo tako kot je za podatkovno strukturo Sklad značilno. Upoštevana je osnovna lastnost sklada - element, ki je bil zadnji vstavljen v sklad kot prvi prihaja iz sklada. Podatkovna struktura Sklad je v Javini knjižnici torej predstavljena z razredom Stack, ki v celoti upošteva osnovno pravilo sklada, pravilo LIFO. LIFO - last in first out, zadnji noter prvi ven, tako se obnaša Sklad, tako se obnaša Sklad predstavljen v razredu Stack.


Metode razreda Stack, s katerimi so predstavljene osnovne operacije nad skladom:

  • metoda push() - vstavi(), z metodo push vstavljamo elemente v sklad
  • metoda pop() - odstrani(), z metodo pop odstranjujemo elemente iz sklada
  • metoda peek() - vrh(), z metodo peek() ugotavljamo kateri element je na vrhu sklada
  • metoda empty() - prazen(), z metodo empty() ugotavljamo ali je sklad prazen


Konstruktor razreda Stack, s katerim pripravimo konkreten sklad

  • konstruktor Stack()

Konkreten sklad pripravimo s pomočjo konstruktorja Stack() iz razreda Stack. Pri pripravi konkretnega sklada napovemo kakšen sklad bomo pripravili, kakšne vrste elemente oziroma kakšne vrste podatkov bomo vstavljali v naš konkreten sklad. Ali bo to sklad celih števil, ali bo to sklad znakov,...

Zgled Priprava sklada celih števil

  • Stack<Integer> Sklad = new Stack<Integer>()


Odgovor

V podanem primeru programčka pripravimo sklad števil. Sklad pripravimo tako, da imamo elemente podvojene ali celo potrojene. Za izpis elementov sklada v takšnem vrstnem redu kot so bili vstavljeni si pripravimo pomožen sklad.

Algoritem: dokler osnovni sklad ni prazen, elemente prelagamo v nov pomožen sklad. Vrhnji element preložimo v nov pomožen sklad in ga odstranimo iz sklada. Naslednji vrhnji element primerjamo s predhodnim vrhnjim elementom. V kolikor sta elementa enaka vrhnji element iz sklada odstranimo, sicer ga preložimo v nov pomožen sklad. Hkrati postane vrhnji element, element s katerim nato primerjamo naslednje elemente sklada. Dobljen sklad je v obratnem vrstnem redu kot osnoven sklad, zato ga še preložimo. Nov sklad izpišemo.


  1. import java.util.* ;
  2. public class Primer6100
  3. {
  4. public static void main(String args[])
  5. {
  6. int element;
  7. // priprava sklada
  8. Stack<Integer> Sklad = new Stack<Integer>();
  9. element = 1 ;
  10. // polnjenje sklada
  11. while ( element <= 10 )
  12. {
  13. Sklad.push(element);
  14. Sklad.push(element);
  15. Sklad.push(element);
  16. element ++ ;
  17. }
  18. //izpis pripravljenega sklada
  19. //priprava pomoznega sklada
  20. Stack<Integer> Sklad_obrnjen = new Stack<Integer>();
  21. // polnjenje pomoznega sklada
  22. while (!Sklad.empty())
  23. {
  24. Sklad_obrnjen.push(Sklad.pop());
  25. }
  26. System.out.println();
  27. System.out.println("Izpis sklada :");
  28. System.out.println();
  29. while (!Sklad_obrnjen.empty())
  30. {
  31. System.out.print(Sklad_obrnjen.peek() + " ");
  32. Sklad.push(Sklad_obrnjen.pop());
  33. }
  34. System.out.println();
  35. System.out.println();
  36. // priprava novega,pomožnega sklada
  37. Stack<Integer> Sklad_nov_obrnjen = new Stack<Integer>();
  38. // Algoritem
  39. element = Sklad.peek() ;
  40. Sklad_nov_obrnjen.push(Sklad.pop());
  41. while (!Sklad.empty())
  42. {
  43. if ( Sklad.peek() == element )
  44. {
  45. Sklad.pop();
  46. }
  47. else
  48. {
  49. Sklad_nov_obrnjen.push(Sklad.pop());
  50. element = Sklad.peek();
  51. }
  52. }
  53. System.out.println();
  54. System.out.println("Izpis novega sklada :");
  55. System.out.println();
  56. while (!Sklad_nov_obrnjen.empty())
  57. {
  58. System.out.print(Sklad_nov_obrnjen.peek() + " ");
  59. Sklad_nov_obrnjen.pop();
  60. }
  61. System.out.println();
  62. System.out.println();
  63. }
  64. }

//Izpis sklada //1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 8 8 8 9 9 9 10 10 10 //Izpis novega sklada //1 2 3 4 5 6 7 8 9 10

Osebna orodja