这些代码你知道多少？别再做菜鸟程序员了！

作为一名程序员，了解和掌握基本的手写代码是必备的技能之一。手写代码可以帮助程序员更好地理解计算机科学的基础概念，并为未来的编程项目做好准备。本文将介绍一些基本的手写代码，涵盖了从数据结构到算法等各个方面。

数据结构

1. 数组

数组是一种简单的数据结构，用于存储相同类型的数据元素。数组中的每个元素都有一个索引，可以通过索引来访问数组中的元素。

int[] myArray = new int[10];

2. 链表

链表是一种线性的数据结构，由一系列节点组成。每个节点包含数据元素和指向下一个节点的指针。链表可以用于存储各种类型的数据，如整数、字符串等。

class Node {
  int data;
  Node next;

  Node(int data) {
    this.data = data;
  }
}

class LinkedList {
  Node head;

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

3. 堆栈

堆栈是一种后进先出（LIFO）的数据结构。堆栈中的元素只能从顶部访问和删除。堆栈可以用于存储各种类型的数据，如整数、字符串等。

class Stack {
  int[] array;
  int top;

  Stack(int size) {
    array = new int[size];
    top = -1;
  }

  void push(int data) {
    if (top == array.length - 1) {
      System.out.println("Stack overflow!");
      return;
    }
    array[++top] = data;
  }

  int pop() {
    if (top == -1) {
      System.out.println("Stack underflow!");
      return -1;
    }
    return array[top--];
  }
}

4. 队列

队列是一种先进先出（FIFO）的数据结构。队列中的元素只能从队首访问和删除。队列可以用于存储各种类型的数据，如整数、字符串等。

class Queue {
  int[] array;
  int front;
  int rear;

  Queue(int size) {
    array = new int[size];
    front = -1;
    rear = -1;
  }

  void enqueue(int data) {
    if ((rear + 1) % array.length == front) {
      System.out.println("Queue overflow!");
      return;
    }
    if (front == -1) {
      front = rear = 0;
    } else {
      rear = (rear + 1) % array.length;
    }
    array[rear] = data;
  }

  int dequeue() {
    if (front == -1) {
      System.out.println("Queue underflow!");
      return -1;
    }
    int data = array[front];
    if (front == rear) {
      front = rear = -1;
    } else {
      front = (front + 1) % array.length;
    }
    return data;
  }
}

算法

1. 排序算法

排序算法用于对数据进行排序。常用的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。

// 冒泡排序
public static void bubbleSort(int[] array) {
  for (int i = 0; i < array.length - 1; i++) {
    for (int j = 0; j < array.length - i - 1; j++) {
      if (array[j] > array[j + 1]) {
        int temp = array[j];
        array[j] = array[j + 1];
        array[j + 1] = temp;
      }
    }
  }
}

// 选择排序
public static void selectionSort(int[] array) {
  for (int i = 0; i < array.length - 1; i++) {
    int minIndex = i;
    for (int j = i + 1; j < array.length; j++) {
      if (array[j] < array[minIndex]) {
        minIndex = j;
      }
    }
    int temp = array[i];
    array[i] = array[minIndex];
    array[minIndex] = temp;
  }
}

// 插入排序
public static void insertionSort(int[] array) {
  for (int i = 1; i < array.length; i++) {
    int current = array[i];
    int j = i - 1;
    while (j >= 0 && array[j] > current) {
      array[j + 1] = array[j];
      j--;
    }
    array[j + 1] = current;
  }
}

// 快速排序
public static void quickSort(int[] array, int low, int high) {
  if (low < high) {
    int partitionIndex = partition(array, low, high);
    quickSort(array, low, partitionIndex - 1);
    quickSort(array, partitionIndex + 1, high);
  }
}

private static int partition(int[] array, int low, int high) {
  int pivot = array[high];
  int i = low - 1;
  for (int j = low; j < high; j++) {
    if (array[j] <= pivot) {
      i++;
      int temp = array[i];
      array[i] = array[j];
      array[j] = temp;
    }
  }
  int temp = array[i + 1];
  array[i + 1] = array[high];
  array[high] = temp;
  return i + 1;
}

// 归并排序
public static void mergeSort(int[] array, int low, int high) {
  if (low < high) {
    int mid = (low + high) / 2;
    mergeSort(array, low, mid);
    mergeSort(array, mid + 1, high);
    merge(array, low, mid, high);
  }
}

private static void merge(int[] array, int low, int mid, int high) {
  int[] temp = new int[high - low + 1];
  int i = low;
  int j = mid + 1;
  int k = 0;
  while (i <= mid && j <= high) {
    if (array[i] <= array[j]) {
      temp[k] = array[i];
      i++;
    } else {
      temp[k] = array[j];
      j++;
    }
    k++;
  }
  while (i <= mid) {
    temp[k] = array[i];
    i++;
    k++;
  }
  while (j <= high) {
    temp[k] = array[j];
    j++;
    k++;
  }
  for (int l = 0; l < temp.length; l++) {
    array[low + l] = temp[l];
  }
}

2. 搜索算法

搜索算法用于在数据结构中查找特定元素。常用的搜索算法有二分查找、线性查找等。

// 二分查找
public static int binarySearch(int[] array, int target) {
  int low = 0;
  int high = array.length - 1;
  while (low <= high) {
    int mid = (low + high) / 2;
    if (array[mid] == target) {
      return mid;
    } else if (array[mid] < target) {
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }
  return -1;
}

// 线性查找
public