好的，以下是一份简单的数据结构与算法学习笔记，使用Markdown格式：

数据结构与算法学习笔记

数据结构

数组

数组是一种线性数据结构，它可以存储同一类型的多个元素。在数组中，每个元素都有一个唯一的索引，从0开始。数组的长度是固定的，一旦创建后就不能改变。

下面是一个创建和遍历数组的示例：

javaCopy Code
int[] arr = new int[5];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
arr[4] = 5;

for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

链表

链表也是一种线性数据结构，但是它不像数组那样在内存中连续存储。每个节点包含两部分信息：数据和指向下一个节点的指针。链表的长度是可变的，可以动态添加或删除节点。

下面是一个创建和遍历链表的示例：

javaCopy Code
class Node {
    int val;
    Node next;
    
    public Node(int val) {
        this.val = val;
        this.next = null;
    }
}

Node head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);

while (head != null) {
    System.out.println(head.val);
    head = head.next;
}

栈

栈是一种后进先出（LIFO）的数据结构，它只能在栈顶进行插入和删除操作。栈可以用数组或链表实现。

下面是一个使用数组实现的栈的示例：

javaCopy Code
class ArrayStack {
    private int[] arr;
    private int top;

    public ArrayStack(int size) {
        arr = new int[size];
        top = -1;
    }

    public void push(int value) {
        if (top == arr.length - 1) {
            throw new RuntimeException("Stack is full");
        }
        arr[++top] = value;
    }

    public int pop() {
        if (top == -1) {
            throw new RuntimeException("Stack is empty");
        }
        return arr[top--];
    }

    public boolean isEmpty() {
        return top == -1;
    }
}

ArrayStack stack = new ArrayStack(5);
stack.push(1);
stack.push(2);
stack.push(3);

while (!stack.isEmpty()) {
    System.out.println(stack.pop());
}

队列

队列是一种先进先出（FIFO）的数据结构，它只能在队尾进行插入操作，在队头进行删除操作。队列可以用数组或链表实现。

下面是一个使用链表实现的队列的示例：

javaCopy Code
class Node {
    int val;
    Node next;

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

class LinkedQueue {
    private Node front;
    private Node rear;

    public LinkedQueue() {
        front = rear = null;
    }

    public void enqueue(int value) {
        if (rear == null) {
            rear = new Node(value);
            front = rear;
        } else {
            rear.next = new Node(value);
            rear = rear.next;
        }
    }

    public int dequeue() {
        if (front == null) {
            throw new RuntimeException("Queue is empty");
        }
        int value = front.val;
        front = front.next;
        if (front == null) {
            rear = null;
        }
        return value;
    }

    public boolean isEmpty() {
        return front == null;
    }
}

LinkedQueue queue = new LinkedQueue();
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);

while (!queue.isEmpty()) {
    System.out.println(queue.dequeue());
}

算法

排序算法

排序算法是一种将一组数据按照某种顺序排列的算法。常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。

下面是一个使用快速排序对数组进行排序的示例：

javaCopy Code
void quickSort(int[] arr, int left, int right) {
    if (left >= right) {
        return;
    }
    int pivot = partition(arr, left, right);
    quickSort(arr, left, pivot - 1);
    quickSort(arr, pivot + 1, right);
}

int partition(int[] arr, int left, int right) {
    int pivotValue = arr[right];
    int i = left - 1;
    for (int j = left; j < right; j++) {
        if (arr[j] < pivotValue) {
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, right);
    return i + 1;
}

void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

int[] arr = {5, 3, 7, 1, 8, 2};
quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));

查找算法

查找算法是一种在数据集中查找特定值的算法。常见的查找算法有线性查找和二分查找等。

下面是一个使用二分查找在数组中查找特定值的示例：

javaCopy Code
int binarySearch(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return -1;
}

int[] arr = {1, 2, 3, 5, 7, 8};
int index = binarySearch(arr, 5);
System.out.println(index);

以上是简单的数据结构与算法学习笔记，希望能对您有所帮助。