రెండు డైమెన్షనల్ శ్రేణులు

1. ద్విమితీయ శ్రేణులు

శ్రేణుల గురించి మరో ఆసక్తికరమైన విషయం. శ్రేణులు ఒక డైమెన్షనల్ (లీనియర్) మాత్రమే కాదు. అవి రెండు డైమెన్షనల్ కూడా కావచ్చు.

దాని అర్థం ఏమిటి, మీరు అడగండి?

దీనర్థం శ్రేణి యొక్క సెల్‌లు నిలువు వరుస (లేదా అడ్డు వరుస) మాత్రమే కాకుండా దీర్ఘచతురస్రాకార పట్టికను కూడా సూచిస్తాయి.

int[][] name = new int[width][height];

పేరు అనేది అర్రే వేరియబుల్ పేరు, వెడల్పు అనేది టేబుల్ వెడల్పు (సెల్‌లలో) మరియు ఎత్తు అనేది టేబుల్ ఎత్తు. ఉదాహరణ:

int[][] data = new int[2][5];
data[1][1] = 5;

ఇది మెమరీలో ఇలా కనిపిస్తుంది:

మార్గం ద్వారా, మీరు రెండు డైమెన్షనల్ శ్రేణుల కోసం వేగవంతమైన ప్రారంభాన్ని కూడా ఉపయోగించవచ్చు:

// Lengths of months of the year in each quarter
int[][] months = { {31, 28, 31}, {30, 31, 30}, {31, 31, 30}, {31, 30, 31} };

ప్రోగ్రామర్‌గా మీకు రెండు-డైమెన్షనల్ శ్రేణి అవసరమయ్యే చాలా ప్రదేశాలు ఉన్నాయి. రెండు డైమెన్షనల్ శ్రేణులు దాదాపు ప్రతి బోర్డ్ గేమ్‌కు పునాదిగా ఉంటాయి, ఉదా చదరంగం, చెకర్స్, టిక్-టాక్-టో మరియు సముద్ర యుద్ధం:

రెండు డైమెన్షనల్ శ్రేణులు చదరంగం లేదా సముద్ర యుద్ధానికి సరైనవి. మనకు సెల్ కోఆర్డినేట్‌ల రూపంలో సంఖ్యలు మాత్రమే అవసరం. 'పాన్ e2-e4' కాదు, కానీ 'పాన్ (5,2) -> (5,4)'. ప్రోగ్రామర్‌గా మీకు ఇది మరింత సులభం అవుతుంది.

2. శ్రేణులలో మూలకాలను అమర్చడం: (x, y) లేదా (y, x)

మార్గం ద్వారా, ఇక్కడ ఒక ఆసక్తికరమైన గందరగోళం ఉంది:

మేము ఉపయోగించి శ్రేణిని సృష్టించినప్పుడు , మనకు 'రెండు అడ్డు వరుసలు మరియు 5 నిలువు వరుసలుnew int[2][5]; ' పట్టిక ఉందా లేదా అది 'రెండు నిలువు వరుసలు మరియు 5 వరుసలు ' ఉందా?" మరో మాటలో చెప్పాలంటే, మనం మొదట వెడల్పును మరియు తరువాత ఎత్తును పేర్కొంటున్నామా... లేదా వైస్ వెర్సా, మొదట ఎత్తు మరియు తరువాత వెడల్పు?సరే, మనం తరచుగా చెప్పినట్లు, ఇక్కడ ప్రతిదీ అంత సులభం కాదు.

శ్రేణి మెమరీలో ఎలా నిల్వ చేయబడుతుంది అనే ప్రశ్నతో ప్రారంభిద్దాం .

వాస్తవానికి, కంప్యూటర్ మెమరీలో వాస్తవానికి మ్యాట్రిక్స్ లేదు: మెమరీలోని ప్రతి స్థానానికి వరుస సంఖ్యా చిరునామా ఉంటుంది: 0, 1, 2, ... మా విషయంలో, మేము 2 × 5 మాతృక గురించి మాట్లాడుతాము, కానీ మెమరీలో ఇది కేవలం 10 వరుస కణాలు, మరేమీ లేదు. అడ్డు వరుసలు మరియు నిలువు వరుసలు ఎక్కడ ఉన్నాయో ఏదీ సూచించదు.

"వెడల్పు x ఎత్తు"కి అనుకూలంగా వాదన.

ఈ విధానానికి అనుకూలంగా ఉన్న వాదన ఏమిటంటే, ప్రతి ఒక్కరూ పాఠశాలలో గణితాన్ని నేర్చుకుంటారు, అక్కడ వారు సమన్వయ జతలను 'x' (అంటే, సమాంతర అక్షం) మరియు ఆపై 'y' (నిలువు పరిమాణం) అని వ్రాస్తారని నేర్చుకుంటారు. మరియు ఇది కేవలం పాఠశాల ప్రమాణం కాదు — ఇది గణితశాస్త్రంలో సాధారణంగా ఆమోదించబడిన ప్రమాణం. వారు చెప్పినట్లు, మీరు గణితంతో వాదించలేరు. అవునా? మొదటి వెడల్పు ఆపై ఎత్తు?

"ఎత్తు x వెడల్పు"కి అనుకూలంగా వాదన.

ఈ స్థానం కోసం ఒక ఆసక్తికరమైన వాదన కూడా ఉంది: రెండు డైమెన్షనల్ శ్రేణుల వేగవంతమైన ప్రారంభీకరణ. నిజానికి, మనం మా శ్రేణిని ప్రారంభించాలనుకుంటే, మనం ఇలా కోడ్‌ని వ్రాయవచ్చు:

// Matrix of important data
int[][] matrix = { {1, 2, 3, 4, 5}, {1, 2, 3, 4, 5} };

మీరు ఏమీ గమనించలేదా? మన దగ్గర ఇది ఉంటే?

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {1, 2, 3, 4, 5}
};

మేము మా డేటాను లైన్ ద్వారా కోడ్ లైన్‌లో వ్రాస్తే, మనకు 2 అడ్డు వరుసలు మరియు 5 నిలువు వరుసలతో మ్యాట్రిక్స్ వస్తుంది.

క్రింది గీత

మనం ఏమి చెప్పగలం? మీకు ఏది సౌకర్యవంతంగా ఉంటుందో నిర్ణయించుకోవడం మీ ఇష్టం. చాలా ముఖ్యమైన విషయం ఏమిటంటే, ఒకే ప్రాజెక్ట్‌లో పనిచేసే ప్రోగ్రామర్‌లందరూ ఒకే విధానానికి కట్టుబడి ఉంటారు.

మీరు ప్రాజెక్ట్‌లో పని చేస్తున్నట్లయితే, కోడ్‌లో చాలా ఇనిషియలైజ్ చేయబడిన టూ-డైమెన్షనల్ శ్రేణులు ఉన్నాయి, అప్పుడు చాలా మటుకు అక్కడ ప్రతిదీ వేగవంతమైన డేటా ప్రారంభీకరణపై ఆధారపడి ఉంటుంది, అంటే మీరు ప్రామాణిక 'ఎత్తు x వెడల్పు'ని కలిగి ఉంటారు.

మీరు చాలా గణితాన్ని కలిగి ఉన్న ప్రాజెక్ట్‌లో మిమ్మల్ని మీరు కనుగొనగలిగే అదృష్టవంతులైతే మరియు కోఆర్డినేట్‌లతో (ఉదాహరణకు, గేమ్ ఇంజిన్‌లు) పని చేస్తే, అప్పుడు కోడ్ ఎక్కువగా 'వెడల్పు x ఎత్తు' విధానాన్ని అవలంబిస్తుంది.

3. ద్విమితీయ శ్రేణులు ఎలా అమర్చబడి ఉంటాయి

రెండు డైమెన్షనల్ శ్రేణులు వాస్తవానికి ఎలా అమర్చబడి ఉన్నాయో ఇప్పుడు మీరు నేర్చుకుంటారు. సిద్ధంగా ఉన్నారా?

రెండు డైమెన్షనల్ శ్రేణులు వాస్తవానికి శ్రేణుల శ్రేణులు!

మరో మాటలో చెప్పాలంటే, ఒక సాధారణ శ్రేణి విషయంలో శ్రేణి వేరియబుల్ శ్రేణి మూలకాలను నిల్వ చేసే కంటైనర్‌కు సూచనను నిల్వ చేస్తే, ద్విమితీయ శ్రేణుల విషయంలో పరిస్థితి కొద్దిగా పేలుతుంది: రెండు డైమెన్షనల్-అరే వేరియబుల్ నిల్వ చేస్తుంది a ఒక డైమెన్షనల్ శ్రేణుల సూచనలను నిల్వ చేసే కంటైనర్‌కు సూచన. వందసార్లు వివరించడానికి ప్రయత్నించే బదులు ఒకసారి దాన్ని చర్యలో చూడటం మంచిది:

ఎడమ వైపున , మనకు రెండు డైమెన్షనల్-అరే వేరియబుల్ ఉంది, ఇది రెండు డైమెన్షనల్-అరే ఆబ్జెక్ట్‌కు సూచనను నిల్వ చేస్తుంది. లోమధ్యలో మనకు ద్విమితీయ శ్రేణి వస్తువు ఉంది, దీని కణాలు ఒక డైమెన్షనల్ శ్రేణిని నిల్వ చేస్తాయి, అవి ద్విమితీయ శ్రేణి యొక్క వరుసలు. మరియు కుడి వైపున , మీరు నాలుగు వన్-డైమెన్షనల్ శ్రేణులను చూడవచ్చు — మా ద్విమితీయ శ్రేణి యొక్క వరుసలు.

రెండు డైమెన్షనల్ శ్రేణులు వాస్తవానికి ఈ విధంగా పని చేస్తాయి. మరియు ఈ విధానం జావా ప్రోగ్రామర్‌కు అనేక ప్రయోజనాలను ఇస్తుంది:

ముందుగా , 'కంటెయినర్ల కంటైనర్' 'వరుసల శ్రేణుల' సూచనలను నిల్వ చేస్తుంది కాబట్టి, మనం చాలా త్వరగా మరియు సులభంగా అడ్డు వరుసలను మార్చుకోవచ్చు. 'కంటైనర్ ఆఫ్ కంటైనర్'ని పొందడానికి, మీరు కేవలం రెండు సూచికలకు బదులుగా ఒక సూచికను పేర్కొనాలి. ఉదాహరణ:

int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];

ఈ కోడ్ అడ్డు వరుసలను మార్చుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది:

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;

{
  {5, 4, 3, 2, 1},
  {1, 2, 3, 4, 5}
};

మీరు ద్విమితీయ శ్రేణి యొక్క సెల్‌ను సూచిస్తే, కానీ మీరు శ్రేణి పేరు తర్వాత ఒక సూచికను మాత్రమే పేర్కొంటే, మీరు సాధారణ వన్-డైమెన్షనల్ శ్రేణులకు సూచనలను నిల్వ చేసే కంటైనర్‌ల కంటైనర్‌ను సూచిస్తున్నారు.