In-depth understanding of Java data structures: the key to improving programming skills-javaTutorial-php.cn

In-depth understanding of Java data structures: the key to improving programming skills

WBOY

Release： 2024-01-10 23:17:11

Original

1213 people have browsed it

In-depth understanding of Java data structures: the key to improving programming skills

Full analysis of Java data structures: Understanding these data structures to improve your programming skills requires specific code examples

Introduction:
In computer science, data structures Refers to the way data is organized and stored in computer memory. In programming, understanding different data structures is crucial to optimizing algorithms and making programs more efficient. This article will introduce several common Java data structures and provide specific code examples to help readers understand and apply these data structures.

1. Array
An array is a linear data structure that can store multiple elements in a single variable. Each element is accessed by index, which starts from zero. Arrays in Java can store elements of the same type.
The following is a sample code showing how to declare, initialize and access elements in an array:

int[] myArray = new int[5]; // 声明一个长度为5的整数数组

myArray[0] = 10;
myArray[1] = 20;
myArray[2] = 30;
myArray[3] = 40;
myArray[4] = 50;

System.out.println(myArray[0]); // 输出：10
System.out.println(myArray[4]); // 输出：50

Copy after login

2. Linked List (LinkedList)
The linked list is a dynamic data structure that can be inserted at runtime and delete elements. A linked list consists of nodes, each node contains a data element and a reference to the next node.
The following is a sample code that shows how to create, add and delete nodes in a linked list:

class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

class LinkedList {
    Node head;

    public void addNode(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = newNode;
        }
    }

    public void deleteNode(int data) {
        Node temp = head;
        Node prev = null;
        if (temp != null && temp.data == data) {
            head = temp.next;
            return;
        }
        while (temp != null && temp.data != data) {
            prev = temp;
            temp = temp.next;
        }
        if (temp == null) {
            return;
        }
        prev.next = temp.next;
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();

        linkedList.addNode(10);
        linkedList.addNode(20);
        linkedList.addNode(30);
        linkedList.addNode(40);
        
        linkedList.deleteNode(20);

        Node temp = linkedList.head;
        while (temp != null) {
            System.out.println(temp.data);
            temp = temp.next;
        }
    }
}

Copy after login

3. Stack
The stack is a last-in-first-out (LIFO) data structure . It can add and remove elements using push and pop operations.
The following is a sample code showing how to use the stack:

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        stack.push(10);
        stack.push(20);
        stack.push(30);
        
        System.out.println(stack.pop()); // 输出：30
        System.out.println(stack.peek()); // 输出：20
    }
}

Copy after login

4. Queue (Queue)
The queue is a first-in, first-out (FIFO) data structure. It can add and remove elements by using add (enqueue) and poll (dequeue) operations.
The following is a sample code showing how to use a queue:

import java.util.LinkedList;
import java.util.Queue;

public class Main {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        queue.add(10);
        queue.add(20);
        queue.add(30);
        
        System.out.println(queue.poll()); // 输出：10
        System.out.println(queue.peek()); // 输出：20
    }
}

Copy after login

5. Hash table (HashMap)
The hash table is a data structure of key-value pairs that uses a hash function to Data is stored in array. Keys provide quick access and update of values.
The following is a sample code showing how to use a hash table:

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();

        hashMap.put("apple", 10);
        hashMap.put("banana", 20);
        hashMap.put("orange", 30);
        
        System.out.println(hashMap.get("apple")); // 输出：10
        System.out.println(hashMap.containsKey("banana")); // 输出：true
    }
}

Copy after login

6. Tree (Tree)
Tree is a non-linear data structure consisting of nodes and edges. Each node of the tree can have multiple child nodes.
The following is a sample code showing how to create and traverse a tree:

class Node {
    int data;
    Node left, right;

    public Node(int data) {
        this.data = data;
        left = right = null;
    }
}

class BinaryTree {
    Node root;

    public BinaryTree() {
        root = null;
    }

    public void inorderTraversal(Node node) {
        if (node == null) {
            return;
        }
        inorderTraversal(node.left);
        System.out.println(node.data);
        inorderTraversal(node.right);
    }
}

public class Main {
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();

        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        
        tree.inorderTraversal(tree.root);
    }
}

Copy after login

Summary:
This article introduces several common Java data structures and provides specific code examples to help readers understand and apply these data structures. By becoming proficient in these data structures, we can better optimize algorithms and improve program efficiency. Continuously learning and applying data structures will help improve your programming skills.

The above is the detailed content of In-depth understanding of Java data structures: the key to improving programming skills. For more information, please follow other related articles on the PHP Chinese website!