数据结构之线性结构

数组

import java.util.Arrays;

public class ArrayObj {

	private int[] elements;

	public ArrayObj() {
		this.elements = new int[0];
	}

	public int size() {
		return elements.length;
	}

	public void add(int element) {
		int[] arr = new int[this.size() + 1];
		for (int i = 0; i < elements.length; i++) {
			arr[i] = elements[i];
		}
		arr[this.size()] = element;
		elements = arr;
	}

	public void delete(int index) {
		indexOut(index);
		int[] arr = new int[this.size() - 1];
		for (int i = 0; i < this.size() - 1; i++) {
			if (i < index) {
				arr[i] = elements[i];
				continue;
			}
			arr[i] = elements[i + 1];
		}
		elements = arr;
	}

	public int get(int index) {
		indexOut(index);
		return elements[index];
	}

	private void indexOut(int index) {
		if (index >= this.size()) {
			throw new RuntimeException("索引越界：" + index);
		}
	}

	public void insert(int index, int element) {
		indexOut(index);
		int[] arr = new int[this.size() + 1];
		for (int i = 0; i < this.size() + 1; i++) {
			if (i < index) {
				arr[i] = elements[i];
				continue;
			}
			if (i == index) {
				continue;
			}
			arr[i] = elements[i - 1];
		}
		arr[index] = element;
		elements = arr;
	}

	@Override
	public String toString() {
		return Arrays.toString(elements);
	}

	// 测试
	public static void main(String[] args) {
		ArrayObj arr = new ArrayObj();
		arr.add(1);
		arr.add(2);
		arr.add(3);
		arr.add(4);
		arr.insert(0, 0);
		arr.insert(10, -1);
		arr.delete(1);
		System.out.println(arr);
	}
}

数组元素查找

• 线性查找

public static int lineSearch(int target, int[] arr) {
	for (int i = 0; i < arr.length; i++) {
		if (arr[i] == target) {
			return i;
		}
	}
	return -1;
}

• 二分查找（二分查找的前提是有序数组）

// arr为有序数组
public static int binarySearch(int target, int[] arr) {
	int begin = 0;
	int end = arr.length - 1;
	int mid = (begin + end) / 2;
	while (true) {
		if (begin > end) {
			return -1;
		}
		if (arr[mid] == target) {
			return mid;
		} else {
			if (arr[mid] > target) {
				end = mid - 1;
				mid = (begin + end) / 2;
			} else {
				begin = mid + 1;
				mid = (begin + end) / 2;
			}
		}
	}
}

栈

import java.util.Arrays;

public class Stack {

	private int[] elements;

	public Stack() {
		elements = new int[0];
	}

	public int size() {
		return elements.length;
	}
	
	public boolean isEmpty() {
		return this.size() == 0;
	}

	public void push(int element) {
		int[] arr = new int[this.size() + 1];
		for (int i = 0; i < this.size(); i++) {
			arr[i] = elements[i];
		}
		arr[this.size()] = element;
		elements = arr;
	}

	public int pop() {
		if (this.isEmpty()) {
			throw new RuntimeException("stack is empty");
		}
		int result = elements[this.size() - 1];
		int[] arr = new int[this.size() - 1];
		for (int i = 0; i < this.size() - 1; i++) {
			arr[i] = elements[i];
		}
		elements = arr;
		return result;
	}

	@Override
	public String toString() {
		return Arrays.toString(elements);
	}

	// 测试
	public static void main(String[] args) {
		Stack stack = new Stack();
		stack.push(1);
		stack.push(2);
		stack.push(3);
		System.out.println(stack);
		System.out.println(stack.pop());
		System.out.println(stack.pop());
		System.out.println(stack.size());
		System.out.println(stack.isEmpty());
	}
}

队列

import java.util.Arrays;

public class Queue {
	
	private int[] elements;

	public Queue() {
		elements = new int[0];
	}
	
	public int size() {
		return elements.length;
	}
	
	public boolean isEmpty() {
		return this.size() == 0;
	}
	
	public void enqueue(int element) {
		int[] arr = new int[this.size() + 1];
		for (int i = 0; i < this.size(); i++) {
			arr[i] = elements[i];
		}
		arr[this.size()] = element;
		elements = arr;
	}
	
	public int dequeue() {
		if (this.isEmpty()) {
			throw new RuntimeException("queue is empty");
		}
		int result = elements[0];
		int[] arr = new int[this.size() - 1];
		for (int i = 0; i < this.size() - 1; i++) {
			arr[i] = elements[i + 1];
		}
		elements = arr;
		return result;
	}

	@Override
	public String toString() {
		return Arrays.toString(elements);
	}
	
	public static void main(String[] args) {
		Queue queue = new Queue();
		queue.enqueue(1);
		queue.enqueue(2);
		queue.enqueue(3);
		System.out.println(queue);
		System.out.println(queue.dequeue());
		System.out.println(queue.dequeue());
		System.out.println(queue.dequeue());
		System.out.println(queue);
	}

}

链表

单链表

public class SinglyLinked {

	private Node header;

	public class Node {
		public int data;
		public Node nextNode;

		public Node(int data, Node nextNode) {
			this.data = data;
			this.nextNode = nextNode;
		}
	}

	public SinglyLinked() {
		header = new Node(0, null);
	}

	public void add(int element) {
		Node newNode = new Node(element, null);
		Node currentNode = header;
		while (currentNode.nextNode != null) {
			currentNode = currentNode.nextNode;
		}
		currentNode.nextNode = newNode;
	}

	public void delete(int element) {
		Node currentNode = header;
		while (currentNode.nextNode != null) {
			if (currentNode.nextNode.data == element) {
				currentNode.nextNode = currentNode.nextNode.nextNode;
				break;
			}
			currentNode = currentNode.nextNode;
		}
	}

	public int getIndex(int element) {
		int result = -1;
		Node currentNode = header;
		while (currentNode.nextNode != null) {
			result++;
			if (currentNode.nextNode.data == element) {
				return result;
			}
			currentNode = currentNode.nextNode;
		}
		// if no find this element
		if (result == this.size() - 1) {
			// reset result
			result = -1;
		}
		return result;
	}

	public int getElement(int index) {
		this.checkIndex(index);
		Node currentNode = header;
		for (int i = 0; i < index + 1; i++) {
			currentNode = currentNode.nextNode;
		}
		return currentNode.data;
	}
	
	private void checkIndex(int index) {
		if (index < 0 || index > this.size()) {
			throw new RuntimeException("索引越界：" + index);
		}
	}
	
	public int size() {
		int result = 0;
		Node currentNode = header;
		while (currentNode.nextNode != null) {
			result++;
			currentNode = currentNode.nextNode;
		}
		return result;
	}

	public boolean isEmpty() {
		return this.size() == 0;
	}

	@Override
	public String toString() {
		StringBuilder builder = new StringBuilder();
		builder.append("[ ");
		Node currentNode = header;
		while (currentNode.nextNode != null) {
			builder.append(currentNode.nextNode.data + ", ");
			currentNode = currentNode.nextNode;
		}
		builder.delete(builder.length() - 2, builder.length() - 1);
		builder.append("]");
		return builder.toString();
	}

	// 测试
	public static void main(String[] args) {
		SinglyLinked linked = new SinglyLinked();
		linked.add(1);
		linked.add(2);
		linked.add(3);
		linked.add(4);
		linked.add(5);
		linked.add(6);
		System.out.println(linked);
		System.out.println(linked.getElement(5));
		System.out.println(linked.getIndex(6));
	}

}

递归解决斐波那契数列

斐波那契数列：从第二个数开始，其余数为前两个数的和

比如斐波那契数列：1，1，2，3，5，8，13 …

// 斐波那契数列 1, 1, 2, 3, 5, 8, 13
// 参数 i 表示数列中的第几个数 (1 ~ n)
public static int febonacci(int i) {
	if (i == 1 || i == 2) {
		return 1;
	}
	return febonacci(i - 1) + febonacci(i - 2);
}