由于文章篇幅有限，我将提供一些关键数据结构和算法的实现示例。首先介绍几个核心数据结构和算法，然后给出相应的Java代码示例。
-
数组
- 实现一个动态扩容的数组
- 实现数组的增删改查操作
public class DynamicArray<T> {
private Object[] array;
private int size;
private int capacity;
public DynamicArray() {
capacity = 10;
array = new Object[capacity];
size = 0;
}
public void add(T element) {
if (size == capacity) {
capacity *= 2;
Object[] newArray = new Object[capacity];
System.arraycopy(array, 0, newArray, 0, size);
array = newArray;
}
array[size++] = element;
}
public T get(int index) {
if (index < 0 || index >= size) throw new IndexOutOfBoundsException();
return (T) array[index];
}
public void remove(int index) {
if (index < 0 || index >= size) throw new IndexOutOfBoundsException();
for (int i = index; i < size - 1; i++) {
array[i] = array[i + 1];
}
size--;
}
}-
链表
- 实现一个单链表
- 实现链表的增删改查操作
public class ListNode {
int val;
ListNode next;
ListNode(int val) {
this.val = val;
}
}
public class LinkedList {
private ListNode head;
public void addAtHead(int val) {
ListNode newHead = new ListNode(val);
newHead.next = head;
head = newHead;
}
public void addAtTail(int val) {
if (head == null) {
head = new ListNode(val);
} else {
ListNode current = head;
while (current.next != null) {
current = current.next;
}
current.next = new ListNode(val);
}
}
public void deleteAtIndex(int index) {
if (index == 0) {
head = head.next;
return;
}
int count = 0;
ListNode current = head;
ListNode prev = null;
while (current != null && count < index) {
prev = current;
current = current.next;
count++;
}
if (current != null) {
prev.next = current.next;
}
}
public ListNode get(int index) {
ListNode current = head;
int count = 0;
while (current != null && count < index) {
current = current.next;
count++;
}
return current;
}
}-
栈
网趣网上购物系统HTML静态版下载网趣购物系统静态版支持网站一键静态生成，采用动态进度条模式生成静态，生成过程更加清晰明确，商品管理上增加淘宝数据包导入功能，与淘宝数据同步更新!采用领先的AJAX+XML相融技术，速度更快更高效！系统进行了大量的实用性更新，如优化核心算法、增加商品图片批量上传、谷歌地图浏览插入等，静态版独特的生成算法技术使静态生成过程可随意掌控，从而可以大大减轻服务器的负担，结合多种强大的SEO优化方式于一体，使
立即学习“Java免费学习笔记（深入）”；
- 实现一个基于数组的栈
- 实现栈的入栈、出栈等操作
public class ArrayStack {
private int[] array;
private int top;
private int capacity;
public ArrayStack(int capacity) {
this.capacity = capacity;
array = new int[capacity];
top = -1;
}
public void push(int value) {
if (top == capacity - 1) throw new IllegalStateException("Stack is full");
array[++top] = value;
}
public int pop() {
if (top == -1) throw new IllegalStateException("Stack is empty");
return array[top--];
}
public int peek() {
if (top == -1) throw new IllegalStateException("Stack is empty");
return array[top];
}
public boolean isEmpty() {
return top == -1;
}
}-
队列
- 实现一个基于数组的队列
- 实现队列的入队、出队等操作
public class ArrayQueue {
private int[] array;
private int front;
private int rear;
private int capacity;
public ArrayQueue(int capacity) {
this.capacity = capacity;
array = new int[capacity];
front = 0;
rear = -1;
}
public void enqueue(int value) {
if (rear == capacity - 1) throw new IllegalStateException("Queue is full");
array[++rear] = value;
}
public int dequeue() {
if (isEmpty()) throw new IllegalStateException("Queue is empty");
int value = array[front];
front++;
return value;
}
public int peek() {
if (isEmpty()) throw new IllegalStateException("Queue is empty");
return array[front];
}
public boolean isEmpty() {
return front > rear;
}
}-
排序算法
- 实现冒泡排序、插入排序、选择排序、快速排序等算法
public class Sort {
public static void bubbleSort(int[] array) {
int length = array.length;
for (int i = 0; i < length - 1; i++) {
for (int j = 0; j < length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = 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 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 quickSort(int[] array, int low, int high) {
if (low < high) {
int mid = partition(array, low, high);
quickSort(array, low, mid - 1);
quickSort(array, mid + 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;
}
}以上是一些核心的数据结构和算法的Java实现示例，希望能对你有所帮助。
