ஜாவாவில் இணைக்கப்பட்ட பட்டியல்களைப் பயன்படுத்துவதற்கான அறிமுகம்

ஒரு தரவு அமைப்பு பல்வேறு முன் வரையறுக்கப்பட்ட முறைகளைப் பயன்படுத்துகிறது, தரவைச் சேமித்து, மீட்டெடுக்கிறது மற்றும் நீக்குகிறது திறமையான நிரல்களை உருவாக்கும். இணைக்கப்பட்ட பட்டியல் ஒரு பிரபலமான தரவு கட்டமைப்பாகும், இது இணைக்கப்பட்ட (அல்லது இணைக்கப்பட்ட) முனைகளின் பட்டியலைக் கொண்டுள்ளது.

ஆனால் ஜாவாவில் இணைக்கப்பட்ட பட்டியலை எவ்வாறு உருவாக்குவது? பார்க்கலாம்.

---

---

இணைக்கப்பட்ட பட்டியல் எவ்வாறு வேலை செய்கிறது?

இணைக்கப்பட்ட ஒவ்வொரு பட்டியலும் ஒரு சிறப்பு முனையுடன் தொடங்குகிறது, இது பெரும்பாலும் 'தலை' என்று குறிப்பிடப்படுகிறது, இது எல்லா நேரங்களிலும் பட்டியலின் தொடக்கத்தை சுட்டிக்காட்டும் பொறுப்பைக் கொண்டுள்ளது. தலை முக்கியமானது, ஏனென்றால் இணைக்கப்பட்ட பட்டியலில் உள்ள ஒவ்வொரு முனையும் அதன் வாரிசை உடல் ரீதியாகப் பின்பற்றத் தேவையில்லை (அதாவது முன்னோடி மற்றும் வாரிசு உடல் ரீதியாக அருகில் இருக்க வேண்டியதில்லை).

ஒவ்வொரு தரவு அமைப்பையும் போலவே, இணைக்கப்பட்ட பட்டியலும் எந்தவொரு டெவலப்பரும் பயன்படுத்தக்கூடிய முன் வரையறுக்கப்பட்ட செயல்பாடுகளின் மூலம் உருவாக்கம், மீட்பு, செருகல் மற்றும் அழிவை எளிதாக்குகிறது.

ஜாவாவில் இணைக்கப்பட்ட பட்டியலை உருவாக்குதல்

இணைக்கப்பட்ட பட்டியல்களை உருவாக்க மற்றும் கையாள வடிவமைக்கப்பட்ட ஒரு ஜாவா நிரல் மூன்று தனித்துவமான பிரிவுகளைக் கொண்டிருக்கும்; முனை வகுப்பு, இணைக்கப்பட்ட பட்டியல் வகுப்பு மற்றும் இயக்கி. இந்த மூன்று பிரிவுகளும் ஒரு கோப்பில் இணைக்கப்பட்டாலும், ஒவ்வொரு டெவலப்பரும் தெரிந்து கொள்ள வேண்டிய 'கவலையைப் பிரித்தல்' எனப்படும் கணினி அறிவியலில் ஒரு வடிவமைப்பு கொள்கை உள்ளது.

கவலைகளைப் பிரித்தல் கொள்கை ஒரு குறிப்பிட்ட கவலையைத் தீர்க்கும் குறியீட்டின் ஒவ்வொரு பகுதியும் பிரிக்கப்பட வேண்டும் என்று ஆணையிடுகிறது. இந்த கொள்கை உங்களுக்கு தூய்மையான (அதிகம் படிக்கக்கூடிய) குறியீட்டை உருவாக்க உதவும் மற்றும் தரவு கட்டமைப்புகளை உருவாக்க சிறந்தது.

ஜாவாவில் இணைக்கப்பட்ட பட்டியலை உருவாக்குவதற்கான முதல் படி ஒரு முனை வகுப்பை உருவாக்குவதாகும். ஒரு முனை வர்க்கம் இரண்டு பண்புகளைக் கொண்டிருக்க வேண்டும்; பண்புகளில் ஒன்று முனையின் தரவு பகுதியை குறிக்கும், மற்ற பண்பு இணைக்கப்பட்ட பகுதியை குறிக்கும். ஒரு முனை வகுப்பில் ஒரு கட்டமைப்பாளர், பெறுபவர்கள் மற்றும் செட்டர்களும் இருக்க வேண்டும்.

---

---

தொடர்புடையது: ஜாவாவில் வகுப்புகளை உருவாக்க கற்றுக்கொள்ளுங்கள்

பெறுபவர்கள் மற்றும் செட்டர்கள் மற்ற வகுப்புகளை (இணைக்கப்பட்ட பட்டியல் வகுப்பு போன்றவை) இணைக்கப்பட்ட பட்டியலில் உள்ள பல்வேறு முனைகளை அணுக அனுமதிக்கும்.

---

---

முனை வகுப்பு உதாரணம்

நாங்கள் என்ன சொல்கிறோம் என்று உங்களுக்கு ஒரு யோசனை பெற கீழே ஒரு முனை வகுப்பு உதாரணம்:


public class Node {
private int Data;
private Node NextNode;
//constructor
public Node() {
Data = 0;
NextNode = null;
}
//getters and setters
public int getData() {
return Data;
}
public void setData(int data) {
Data = data;
}
public Node getNextNode() {
return NextNode;
}
public void setNextNode(Node nextNode) {
NextNode = nextNode;
}
}

இந்த எடுத்துக்காட்டில், தரவு பண்புக்கூறு முழு மதிப்புகளை சேமிக்கும். இப்போது உங்களிடம் முனை வகுப்பு உள்ளது, இணைக்கப்பட்ட பட்டியலுக்கு செல்ல வேண்டிய நேரம் இது.

இணைக்கப்பட்ட பட்டியல் உதாரணம்

ஜாவாவில் இணைக்கப்பட்ட பட்டியலின் உதாரணம் கீழே உள்ளது.

public class LinkedList {
private Node Head;
//constructor
public LinkedList() {
Head = null;
}
}


மேலே உள்ள குறியீடு ஒரு இணைக்கப்பட்ட பட்டியலை உருவாக்கும் இணைக்கப்பட்ட பட்டியல் தரவு கட்டமைப்பில் பல செயல்பாடுகள் உள்ளன, அவை மக்கள்தொகைக்கு பயன்படுத்தப்படலாம்:

• முன்புறத்தில் செருகவும்.
• நடுவில் செருகவும்.
• பின்புறத்தில் செருகவும்.

தொடர்புடையது: ஜாவாஸ்கிரிப்ட் இஎஸ் 6 வகுப்புகளுடன் தரவு கட்டமைப்புகளை உருவாக்குவது எப்படி

செருகும் முறைகளின் இணைக்கப்பட்ட பட்டியல் சேகரிப்பு ஒரு டெவலப்பர் இந்த தரவு கட்டமைப்பை ஸ்டாக்ஸ் போன்ற மற்றொரு தரவு கட்டமைப்பைப் பயன்படுத்த தேர்வு செய்ய ஒரு காரணமாகும் (இது மேலே இருந்து செருகவும் நீக்கவும் மட்டுமே அனுமதிக்கிறது).

முன் முறையில் செருகலைப் பயன்படுத்துதல்

முன் முறையின் செருகல், பெயர் குறிப்பிடுவது போல, இணைக்கப்பட்ட பட்டியலின் முன்புறத்தில் புதிய தரவை (அல்லது புதிய முனைகள்) செருகும்.

முன் முறை எடுத்துக்காட்டில் செருகவும்

உங்கள் பட்டியலின் முன்புறத்தில் புதிய தரவை நீங்கள் எவ்வாறு செருகுவீர்கள் என்பதற்கான எடுத்துக்காட்டு கீழே உள்ளது.

//insert node at front method
public void insertAtFront(int key) {
//create a new node using the node class
Node Temp = new Node();
//check if the Temp node was successfully created
//assign the data that was provides by the user to it
if(Temp != null) {
Temp.setData(key);
Temp.setNextNode(null);

//check if the head of the linked list is empty
//assign the node that was just created to the head position
if(Head == null) {
Head = Temp;
}
//if a node is already at the head position
//add the new node to it and set it as the head
else {
Temp.setNextNode(Head);
Head = Temp;
}
}
}


தி insertAtFront மேலே உள்ள எடுத்துக்காட்டில் உள்ள முறை, கொடுக்கப்பட்ட இணைக்கப்பட்ட பட்டியலில் புதிய முனைகளைச் சேர்க்க பயனரை அனுமதிக்கிறது.

முன் எடுத்துக்காட்டில் செருகலைப் பயன்படுத்துதல்

முன்புறத்தில் நீங்கள் எப்படி செருகுவீர்கள் என்பதற்கு கீழே ஒரு எடுத்துக்காட்டு.

public class Driver {
//executes the program
public static void main(String[] args) {
//create a new linked list called List
LinkedList List = new LinkedList();
//add each value to the front of the linked list as a new node
List.insertAtFront(10);
List.insertAtFront(8);
List.insertAtFront(6);
List.insertAtFront(4);
List.insertAtFront(2);
}
}


தி இயக்கி வர்க்கம் (இது ஜாவாவில் இயங்கக்கூடிய வகுப்பிற்கு அடிக்கடி ஒதுக்கப்படும் பெயர்), ஐந்து சம எண்களின் இணைக்கப்பட்ட பட்டியலை உருவாக்க லிங்க்ட்லிஸ்ட் வகுப்பைப் பயன்படுத்துகிறது. மேலே உள்ள குறியீட்டைப் பார்த்தால், இணைக்கப்பட்ட பட்டியலில் '2' என்ற எண் முதலிடத்தில் இருப்பதை எளிதாகக் காண வேண்டும். ஆனால் இதை எப்படி உறுதிப்படுத்த முடியும்?

ஆன்லைனில் எலக்ட்ரானிக்ஸ் வாங்க சிறந்த இடம்

காட்சி அனைத்து முனைகள் முறையைப் பயன்படுத்துதல்

காட்சி அனைத்து முனைகள் முறை ஒரு அத்தியாவசிய இணைக்கப்பட்ட பட்டியல் முறையாகும். இது இல்லாமல், ஒரு டெவலப்பர் இணைக்கப்பட்ட பட்டியலில் உள்ள முனைகளைப் பார்க்க முடியாது. இது இணைக்கப்பட்ட பட்டியலின் மூலம் பயணிக்கிறது (தலையில் இருந்து தொடங்கி) பட்டியலை உருவாக்கும் ஒவ்வொரு முனையிலும் சேமிக்கப்பட்ட தரவை அச்சிடுகிறது.

அனைத்து முனைகளின் முறை உதாரணத்தைக் காட்டு

ஜாவாவில் டிஸ்ப்ளே அனைத்து நோட்ஸ் முறையைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு கீழே உள்ளது.

//display all nodes method
public void displayAllNodes() {
//create a new node call Temp and assign it to the head of the linked list
//if the head has a null value then the linked list is empty
Node Temp = Head;
if (Head == null){
System.out.println('The list is empty.');
return;
}
System.out.println('The List:');

while(Temp != null) {
//print the data in each node to the console(starting from the head)
System.out.print(Temp.getData() + ' ');
Temp = Temp.getNextNode();
}
}

இப்போது அந்த displayAllNodes முறை சேர்க்கப்பட்டுள்ளது இணைக்கப்பட்ட பட்டியல் இயக்கி வகுப்பில் ஒற்றை வரி குறியீட்டைச் சேர்ப்பதன் மூலம் நீங்கள் இணைக்கப்பட்ட பட்டியலைப் பார்க்கலாம்.

காட்சி அனைத்து முனைகள் முறை உதாரணத்தைப் பயன்படுத்துதல்

கீழே, நீங்கள் காட்சி அனைத்து முனைகள் முறையை எவ்வாறு பயன்படுத்துகிறீர்கள் என்று பார்ப்பீர்கள்.

//print the nodes in a linked list
List.displayAllNodes();

மேலே உள்ள குறியீட்டின் வரியைச் செயல்படுத்துவது கன்சோலில் பின்வரும் வெளியீட்டை உருவாக்கும்:

பட்டியல்:

2 4 6 8 10

கண்டுபிடி முனை முறையைப் பயன்படுத்துதல்

ஒரு பயனர் இணைக்கப்பட்ட பட்டியலில் ஒரு குறிப்பிட்ட முனை கண்டுபிடிக்க விரும்பும் சந்தர்ப்பங்கள் இருக்கும்.

உதாரணமாக, மில்லியன் கணக்கான வாடிக்கையாளர்களைக் கொண்ட வங்கி, ஒரு குறிப்பிட்ட வாடிக்கையாளரின் விவரங்களை மட்டுமே பார்க்க வேண்டியிருக்கும் போது அனைத்து வாடிக்கையாளர்களையும் தங்கள் தரவுத்தளத்தில் அச்சிடுவது நடைமுறையில் இருக்காது.

எனவே, பயன்படுத்துவதற்கு பதிலாக displayAllNodes முறை, தேவையான தரவுகளைக் கொண்ட ஒற்றை முனையைக் கண்டறிவது மிகவும் திறமையான முறையாகும். இதனால்தான் இணைக்கப்பட்ட பட்டியல் தரவு கட்டமைப்பில் ஒற்றை முனை முறையின் தேடல் முக்கியமானது.

முனை முறை உதாரணத்தைக் கண்டறியவும்

கண்டுபிடி முனை முறையைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு கீழே உள்ளது.

//search for a single node using a key
public boolean findNode(int key) {
//create a new node and place it at the head of the linked list
Node Temp = Head;
//while the current node is not empty
//check if its data matches the key provided by the user
while (Temp != null) {
if (Temp.getData() == key) {
System.out.println('The node is in the list');
return true;
}
//move to the next node
Temp = Temp.getNextNode();
}
//if the key was not found in the linked list
System.out.println('The node is not in the list');
return false;
}

உடன் displayAllNodes முறை, நீங்கள் அதை உறுதிப்படுத்தினீர்கள் இணைக்கப்பட்ட பட்டியல் 2 முதல் 10 வரையிலான 5 சம எண்களைக் கொண்டுள்ளது findNode மேலே உள்ள உதாரணம் அந்த சம எண்களில் ஒன்று எண் 4 என்பதை இயக்கி வகுப்பில் உள்ள முறையை அழைப்பதன் மூலம் எண்ணை ஒரு அளவுருவாக வழங்குவதன் மூலம் உறுதிப்படுத்த முடியும்.

கண்டுபிடி முனை முறை உதாரணத்தைப் பயன்படுத்துதல்

நடைமுறையில் கண்டுபிடி முனை முறையை நீங்கள் எவ்வாறு பயன்படுத்தலாம் என்பதற்கான எடுத்துக்காட்டு கீழே உள்ளது.

//check if a node is in the linked list
List.findNode(4);


மேலே உள்ள குறியீடு கன்சோலில் பின்வரும் வெளியீட்டை உருவாக்கும்:

The node is in the list

ஒரு முனை முறையை நீக்குதல்

மேலே இருந்து அதே வங்கி உதாரணத்தைப் பயன்படுத்தி, வங்கியின் தரவுத்தளத்தில் ஒரு வாடிக்கையாளர் தங்கள் கணக்கை மூட விரும்பலாம். நீக்குதல் முனை முறை பயனுள்ளதாக இருக்கும். இது மிகவும் சிக்கலான இணைக்கப்பட்ட பட்டியல் முறை.

ஒரு முனை நீக்கு முறை கொடுக்கப்பட்ட முனையை தேடுகிறது, அந்த முனையை நீக்குகிறது மற்றும் முந்தைய முனையை நீக்கிய முனைக்குப் பின் வரும் இணைப்பை இணைக்கிறது.

ஒரு முனை முறை உதாரணத்தை நீக்கவும்

கீழே ஒரு முனை முறையை நீக்குவதற்கான எடுத்துக்காட்டு.

public void findAndDelete(int key) {
Node Temp = Head;
Node prev = null;
//check if the head node holds the data
//and delete it
if (Temp != null && Temp.getData() == key) {
Head = Temp.getNextNode();
return;
}
//search the other nodes in the list
//and delete it
while (Temp != null) {
if (Temp.getNextNode().getData() == key ) {
prev = Temp.getNextNode().getNextNode();
Temp.setNextNode(prev);
return;
}
Temp = Temp.getNextNode();
}
}

ஒரு முனை முறை உதாரணத்தை நீக்குதல்

நடைமுறையில் நீக்கு முனை முறையைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு கீழே உள்ளது.

கூகுள் பிளே சேவைகள் செய்தியை நிறுத்திவிட்டன

//delete the node that holds the data 4
List.findAndDelete(4);
//print all nodes in the linked list
List.displayAllNodes();

முன்பே இருக்கும் டிரைவர் வகுப்பில் மேலே உள்ள இரண்டு கோடுகளைப் பயன்படுத்துவது பின்வரும் வெளியீட்டை கன்சோலில் உருவாக்கும்:

The List:
2 6 8 10

இப்போது நீங்கள் ஜாவாவில் இணைக்கப்பட்ட பட்டியல்களை உருவாக்கலாம்

இந்த டுடோரியல் கட்டுரையின் முடிவில் நீங்கள் அதை முடித்திருந்தால், நீங்கள் கற்றுக்கொண்டீர்கள்:

• ஒரு முனை வகுப்பை உருவாக்குவது எப்படி.
• இணைக்கப்பட்ட பட்டியல் வகுப்பை உருவாக்குவது எப்படி.
• இணைக்கப்பட்ட பட்டியல் வகுப்பை அதன் முன் வரையறுக்கப்பட்ட முறைகளுடன் எவ்வாறு விரிவுபடுத்துவது.
• விரும்பிய முடிவை அடைய ஒரு இயக்கி வகுப்பை உருவாக்குவது மற்றும் வெவ்வேறு இணைக்கப்பட்ட பட்டியல் முறைகளைப் பயன்படுத்துவது எப்படி.

தரவைச் சேமிக்க, மீட்டெடுக்க மற்றும் நீக்க நீங்கள் பயன்படுத்தக்கூடிய பல தரவு கட்டமைப்புகளில் ஒன்று இணைக்கப்பட்ட பட்டியல். நீங்கள் தொடங்குவதற்கு தேவையான அனைத்தும் உங்களிடம் இருப்பதால், ஜாவாவில் இந்த உதாரணங்களை ஏன் முயற்சி செய்யக்கூடாது?

பகிர் பகிர் ட்வீட் மின்னஞ்சல் ஜாவாவில் வரிசைகளில் செயல்பாடுகளை உருவாக்குவது மற்றும் செயல்படுத்துவது எப்படி

ஜாவா கற்றல்? வரிசைகள் உங்கள் தரவை எளிதாகக் கையாளட்டும்.

அடுத்து படிக்கவும் தொடர்புடைய தலைப்புகள்

• நிரலாக்க
• ஜாவா
• நிரலாக்க
• குறியீட்டு குறிப்புகள்

எழுத்தாளர் பற்றி கதீஷா கீன்(21 கட்டுரைகள் வெளியிடப்பட்டன)

கதீஷா கீன் ஒரு முழு அடுக்கு மென்பொருள் டெவலப்பர் மற்றும் தொழில்நுட்ப/தொழில்நுட்ப எழுத்தாளர். மிகவும் சிக்கலான சில தொழில்நுட்பக் கருத்துகளை எளிமையாக்கும் தனித்துவமான திறமை அவளிடம் உள்ளது; எந்தவொரு தொழில்நுட்ப புதியவராலும் எளிதில் புரிந்துகொள்ளக்கூடிய பொருள் உற்பத்தி. அவர் எழுதுவதில் ஆர்வமாக உள்ளார், சுவாரஸ்யமான மென்பொருளை உருவாக்கி, உலகம் முழுவதும் பயணம் செய்கிறார் (ஆவணப்படங்கள் மூலம்).

கதீஷா கீனிடமிருந்து மேலும்

எங்கள் செய்திமடலுக்கு குழுசேரவும்

தொழில்நுட்ப குறிப்புகள், மதிப்புரைகள், இலவச மின் புத்தகங்கள் மற்றும் பிரத்யேக ஒப்பந்தங்களுக்கு எங்கள் செய்திமடலில் சேரவும்!

குழுசேர இங்கே சொடுக்கவும்