PHP study notes: data structures and algorithms

PHP Study Notes: Data Structures and Algorithms

Overview:
Data structures and algorithms are two very important concepts in computer science. They are used to solve problems. and key to optimizing code performance. In PHP programming, we often need to use various data structures to store and operate data, and we also need to use algorithms to implement various functions. This article will introduce some commonly used data structures and algorithms, and provide corresponding PHP code examples.

1. Linear structure

1. Array (Array)
   Array is one of the most commonly used data structures and can be used to store ordered data sets. PHP's array is a collection of ordered maps (key-value), and you can use subscripts to access the elements in the array. The following are some common array operations:

• Create an array: $arr = array(1, 2, 3);
• Add elements: $arr[] = 4 ;
• Access elements: $arr[0];
• Delete elements: unset($arr[0]);
• Array length: count($arr);
• Loop traversal: foreach ($arr as $value) { ... }

2. Linked List (Linked List)
   Linked list is data composed of a series of nodes Structure, each node contains data and a pointer to the next node. Linked lists can implement efficient insertion and deletion operations, but search operations are slow. The following is a simple example of a linked list:

class Node {
    public $data;
    public $next;

    public function __construct($data = null) {
        $this->data = $data;
        $this->next = null;
    }
}

class LinkedList {
    public $head;

    public function __construct() {
        $this->head = null;
    }

    public function insert($data) {
        $newNode = new Node($data);
        if ($this->head === null) {
            $this->head = $newNode;
        } else {
            $currentNode = $this->head;
            while ($currentNode->next !== null) {
                $currentNode = $currentNode->next;
            }
            $currentNode->next = $newNode;
        }
    }

    public function display() {
        $currentNode = $this->head;
        while ($currentNode !== null) {
            echo $currentNode->data . " ";
            $currentNode = $currentNode->next;
        }
    }
}

$linkedList = new LinkedList();
$linkedList->insert(1);
$linkedList->insert(2);
$linkedList->insert(3);
$linkedList->display();

2. Non-linear structure

1. Stack (Stack)
   The stack is a last-in-first-out (LIFO) The data structure can be implemented using an array or a linked list. The following is a simple stack example:

class Stack {
    private $arr;

    public function __construct() {
        $this->arr = array();
    }

    public function push($data) {
        array_push($this->arr, $data);
    }

    public function pop() {
        if (!$this->isEmpty()) {
            return array_pop($this->arr);
        }
    }

    public function isEmpty() {
        return empty($this->arr);
    }
}

$stack = new Stack();
$stack->push(1);
$stack->push(2);
$stack->push(3);
echo $stack->pop();  // 输出 3

2. Queue (Queue)
   Queue is a first-in-first-out (FIFO) data structure that can be implemented using an array or linked list. The following is a simple queue example:

class Queue {
    private $arr;

    public function __construct() {
        $this->arr = array();
    }

    public function enqueue($data) {
        array_push($this->arr, $data);
    }

    public function dequeue() {
        if (!$this->isEmpty()) {
            return array_shift($this->arr);
        }
    }

    public function isEmpty() {
        return empty($this->arr);
    }
}

$queue = new Queue();
$queue->enqueue(1);
$queue->enqueue(2);
$queue->enqueue(3);
echo $queue->dequeue();  // 输出 1

3. Commonly used algorithms

1. Sort algorithm
2. Bubble sort
3. Selection sort
4. Insertion sort
5. Quick sort
6. Merge sort
7. Search algorithm
8. Binary search
9. Recursive algorithm
10. Factorial
11. Fibonacci Sequence

The above are sample codes for some common data structures and algorithms. By learning and understanding these codes, you can better master them. PHP data structures and algorithms. Of course, there are many other data structures and algorithms that can be learned and explored. I hope readers can continue to learn and practice and continuously improve their abilities in the field of programming.

The above is the detailed content of PHP study notes: data structures and algorithms. For more information, please follow other related articles on the PHP Chinese website!