集合
MsArrayList
定义一个全局数组Object[] elementData;
,是为了保存数据,但是不初始化。当我们new一个对象的时候才初始化。
定义集合的大小Integer size = 0
,这个大小不是数组的大小。
add(T element)
add(Integer index,T element)
remove(Integer index)
T get(Integer index)
package com.shengun.list;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
/**
* 模拟ArrayList
* @param <T>
*/
public class MsArrayList<T> implements Iterable<T> {
//定义一个空数组
private Object[] elementData;
//链表元素大小
private Integer size = 0;
/**
* 有参数构造
* @param capacity
*/
public MsArrayList(int capacity){
//初始化容量
elementData = new Object[capacity];
}
/**
* 无参数构造
*/
public MsArrayList() {
elementData = new Object[10];
}
/**
* 添加元素方法
*/
public void add(T element){
checkCapacity();
elementData[size] = element;
size++;
}
/**
* 指定位置添加元素
*/
public void add(Integer index, T element) {
checkIndex(index);
checkCapacity();
//判断元素是否是最后一个
if(index == size - 1){
elementData[size] = element;
}else{
System.arraycopy(elementData, index, elementData, index + 1, size - index);
elementData[index] = element;
}
size++;
}
/**
* 指定元素删除元素
*/
public void remove(Integer index) {
checkIndex(index);
System.arraycopy(elementData, index + 1, elementData, index, size - index);
elementData[--size] = null;
}
/**
* 判断是否需要扩容
*/
public void checkCapacity(){
//判断是否需要扩容
if(size <= elementData.length){
//需要扩容
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
/**
* 获取元素
*/
public T get(Integer index) {
checkIndex(index);
return (T) elementData[index];
}
/**
* 判断元素是否超限
* @param index
*/
public void checkIndex(Integer index) {
if(index < 0 || index > size){
throw new RuntimeException("元素超限");
}
}
/**
* 返回size
*/
public Integer getSize(){
return size;
}
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(1, 2);
list.remove(1);
MsArrayList<String> ms = new MsArrayList<String>();
ms.add("12");
ms.add("123");
ms.add("123456");
ms.add(1,"10");
ms.add(4,"10");
// ms.add(0,"10000");
ms.remove(0);
ms.remove(3);
ms.remove(1);
// System.out.println(ms.get(0));
// System.out.println(ms.get(3));
// System.out.println(ms.get(5));
Iterator<String> iterator = ms.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
@Override
public Iterator<T> iterator() {
return new MsIterator();
}
class MsIterator implements Iterator<T> {
int index = 0;
@Override
public boolean hasNext() {
return index != size;
}
@Override
public T next() {
return (T) elementData[index++];
}
}
}
TMsLinkedList
package com.shengun.list;
import java.util.Iterator;
public class MsLinkedList<T> implements Iterable<T> {
/**
* 节点
*/
class Node<E>{
E item;
Node<E> prev;
Node<E> next;
Node(Node<E> prev,E item,Node<E> next){
this.item = item;
this.prev = prev;
this.next = next;
}
}
//链表大小
private int size = 0;
//头节点
private Node<T> first;
//为节点
private Node<T> last;
//添加节点
public void add(T element) {
Node<T> l = last;
//直接添加在节点尾部
//新的节点
Node<T> newNode = new Node<>(l,element,null);
last = newNode;
if(l == null){
//第一个元素
first = newNode;
}else{
//否则不是第一个,他的下一个节点的元素指向新的节点
l.next = newNode;
}
size++;
}
/**
* 添加节点
*/
public void add(int index,T element) {
if(index <0|| index > size){
throw new RuntimeException("索引超限");
}
if(index == size){
add(element);
}else{
Node<T> oldValue = node(index);
Node<T> pre = oldValue.prev;
Node<T> newNode = new Node<>(pre, element, oldValue);
oldValue.prev = newNode;
if(pre == null){
//代表是第一个元素
first = newNode;
}else{
pre.next = newNode;
}
size++;
}
}
/**
* 指定位置元素替换
*/
public T set(int index, T element) {
checkIndex(index);
//原来元素的位置
Node<T> x = node(index);
T oldVale = x.item;
x.item = element;
return oldVale;
}
/**
* 根据元素下标找到指定的元素
*/
public T get(int index){
checkIndex(index);
return node(index).item;
}
/**
* 校验索引
*
* @param index
*/
private void checkIndex(int index) {
if(index < 0 || index >= size){
throw new RuntimeException("索引超限");
}
}
/**
* 遍历节点
* @param index
* @return
*/
private Node<T> node(int index){
//二分遍历
if(index < (index << 1)){
Node<T> x = first;
//从头部开始遍历
for (int i = 0; i < index; i++) {
x = x.next;
}
return x;
}else{
Node<T> x = last;
for (int i = size - 1; i > index; i--) {
x = x.prev;
}
return x;
}
}
public static void main(String[] args) {
// LinkedList last = new LinkedList();
// last.get(1);
// last.set(1, "2");
// last.add(1, "2");
MsLinkedList<String> list = new MsLinkedList<>();
list.add("0");
list.add("1");
list.add("2");
// list.set(3, "2");
list.add(0, "000000");
list.add(2, "222222222222");
list.add(5,"666666666666");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
@Override
public Iterator<T> iterator() {
return new MsIterator();
}
class MsIterator implements Iterator<T> {
int index = 0;
@Override
public boolean hasNext() {
return index != size;
}
@Override
public T next() {
return get(index++);
}
}
}
队列
ArrayQueue
package com.shengun.queue;
import java.util.Arrays;
/**
* 先进先出
*/
public class ArrayQueue<T> {
//第一个元素下标
private int head = 0;
//最后一个元素下标
private int tail = 0;
private Object[] elementData;
public ArrayQueue(){
elementData = new Object[10];
}
/**
* 入队列
* 队列是从尾部开始入
*/
public boolean enQueue(T element){
if(tail <= elementData.length){
int oldCapacity = elementData.length;
int newCapacity = oldCapacity << 1;
//需要扩容
elementData = Arrays.copyOf(elementData, newCapacity);
if(head != 0){
//进行数据迁移
if(tail - head > 0){
System.arraycopy(elementData, head, elementData, 0, tail - head);
}
tail = tail - head;
head = 0;
}
}
elementData[tail++] = element;
return true;
}
/**
* 出队列
*/
public T deQueue() {
if(head == tail){
throw new RuntimeException("队列为空");
}
return (T) elementData[head++];
}
public static void main(String[] args) {
ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
arrayQueue.enQueue(1);
arrayQueue.enQueue(2);
arrayQueue.enQueue(3);
arrayQueue.enQueue(4);
System.out.println(arrayQueue.deQueue());
System.out.println(arrayQueue.deQueue());
System.out.println(arrayQueue.deQueue());
System.out.println(arrayQueue.deQueue());
System.out.println(arrayQueue.deQueue());
System.out.println(arrayQueue.deQueue());
}
}
LinkedQueue
package com.shengun.queue;
public class LinkedQueue<T> {
class Node<E>{
E item;
Node<E> next;
public Node(E item,Node<E> next){
this.item = item;
this.next = next;
}
}
//头节点
private Node<T> head;
//尾节点
private Node<T> tail;
private int size = 0;
public LinkedQueue(){}
/**
* 入栈
*/
public Boolean enQueue(T element) {
//尾部插入
Node<T> newNode = new Node<>(element, null);
//如果尾节点为空
if (tail == null) {
//把新的值赋予为节点
tail = newNode;
//原来的尾节点就是新的头节点
head = tail;
size++;
return true;
}
tail.next = newNode;
tail = newNode;
size++;
return true;
}
/**
* 出栈
*/
public T dnQueue(){
if(size == 0){
throw new RuntimeException("栈为空");
}
Node<T> l = head;
head = head.next;
size --;
return l.item;
}
public static void main(String[] args) {
LinkedQueue<Integer> linkedQueue = new LinkedQueue<>();
linkedQueue.enQueue(1);
linkedQueue.enQueue(2);
linkedQueue.enQueue(3);
linkedQueue.enQueue(4);
System.out.println(linkedQueue.dnQueue());
System.out.println(linkedQueue.dnQueue());
System.out.println(linkedQueue.dnQueue());
System.out.println(linkedQueue.dnQueue());
System.out.println(linkedQueue.dnQueue());
}
}
栈
ArrayStack
package com.shengun.stack;
import java.util.Arrays;
public class ArrayStack<T> {
/**
* 数组啊实现的栈
*/
private Object[] elementData;
private int topIndex = 0;
public ArrayStack(){
elementData = new Object[10];
}
/**
* 入栈
*/
public boolean push(T element) {
//判断栈顶元素
if(topIndex>=elementData.length){
int newCapacity = elementData.length<<1;
elementData = Arrays.copyOf(elementData, newCapacity);
}
elementData[topIndex++] = element;
return true;
}
/**
* 出战并删除栈顶元素
*/
public T pop(){
if(topIndex<=0){
throw new RuntimeException("栈为空");
}
return (T)elementData[--topIndex];
}
/**
* 出栈
* @return
*/
public T peek(){
if(topIndex<=0){
throw new RuntimeException("栈为空");
}
return (T) elementData[topIndex-1];
}
public static void main(String[] args) {
ArrayStack<Integer> stack = new ArrayStack<>();
stack.push(0);
stack.push(1);
stack.push(2);
stack.push(3);
// System.out.println(stack.peek());
// System.out.println(stack.peek());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}
LinkedStack
package com.shengun.stack;
public class LinkedStack<T> {
class Node<E>{
E item;
Node<E> next;
public Node(E item,Node<E> next){
this.item = item;
this.next = next;
}
}
private Node<T> header;
//记录数
private int elementCount = 0;
public LinkedStack(){}
//入栈
public void add(T element) {
header = new Node<>(element, header);
elementCount++;
}
//出战,并删除元素
public T pop(){
if(header == null){
throw new RuntimeException("栈为空");
}
T element = header.item;
//删除栈顶元素
header = header.next;
elementCount--;
return element;
}
//出战
public T peek(){
if(header == null){
throw new RuntimeException("栈为空");
}
T element = header.item;
return element;
}
public static void main(String[] args) {
LinkedStack<Integer> stack = new LinkedStack<>();
stack.add(1);
stack.add(2);
stack.add(3);
stack.add(4);
System.out.println(stack.peek());
System.out.println(stack.peek());
System.out.println(stack.peek());
System.out.println(stack.peek());
System.out.println("#######################");
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}
hash表
MsHashTable
package com.shengun.hash;
import java.util.HashMap;
public class MsHashTable<K,V> {
class Node<K,V>{
//hash值
int hash;
K key;
V value;
Node<K,V> next;
public Node(int hash,K key,V value,Node<K,V> next){
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
}
private Node<K,V>[] table;
public MsHashTable(){
table = new Node[16];
}
public void set(K key, V value) {
//计算hashcode值
int hash = hash(key);
//计算数组下标
int i = (table.length - 1) & hash;
Node<K, V> node = new Node<>(hash, key, value, null);
//看下i位置是否存在值
Node<K, V> kvNode = table[i];
if(kvNode == null){
table[i] = node;
return;
}
//位置有数据
if(kvNode.equals(key)){
kvNode.value = value;
}else{
kvNode.next = node;
}
}
public V get(K key) {
//计算hashcode值
int hash = hash(key);
//计算数组下标
int i = (table.length - 1) & hash;
Node<K, V> node = table[i];
if(node == null){
return null;
}
Node<K,V> newNode = node;
while (newNode.next != null) {
if(newNode.key.equals(key)){
break;
}
newNode = newNode.next;
}
return newNode.value;
}
private int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
public static void main(String[] args) {
MsHashTable<Integer, String> ms = new MsHashTable<>();
ms.set(1, "1");
ms.set(2, "2");
ms.set(3, "3");
ms.set(4, "4");
ms.set(5, "5");
for (int i = 0; i < 5; i++) {
System.out.println(ms.get(i));
}
}
}
斐波那契数列
Fibonacci
package com.shengun.suanfa;
public class Fibonacci {
/**
* 斐波那契数列
*/
public int fibonacci(int n){
if(n == 0){
return 0;
}else if(n == 1){
return 1;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
public static void main(String[] args) {
Fibonacci fibonacci = new Fibonacci();
System.out.println(fibonacci.fibonacci(0));
System.out.println(fibonacci.fibonacci(1));
System.out.println(fibonacci.fibonacci(2));
System.out.println(fibonacci.fibonacci(3));
System.out.println(fibonacci.fibonacci(4));
System.out.println(fibonacci.fibonacci(5));
}
}
汉诺塔
Hanoi
package com.shengun.suanfa;
public class Hanoi {
//移动次数
int moveCount = 0;
public void move(int id,char src,char dist){
System.out.println("第"+(++moveCount)+"次移动,将" + id +" 从" + src + "移动到" + dist);
}
/**
* 将A上的东西移动到C上
*/
public void hanoi(int n, char A, char B, char C) {
if(n == 1){
move(0,A,C);
}else{
hanoi(n - 1, A, C, B);
move(n - 1, A, C);
hanoi(n - 1, B, A, C);
}
}
public static void main(String[] args) {
Hanoi hanoi = new Hanoi();
hanoi.hanoi(4, 'A', 'B', 'C');
}
}