栈、双链表

package com.itheima;

/**
* 栈的实现（使用数组实现 入栈、出栈 和获取栈的长度）
* @author
*
*/
public class Stack {

Object[] datas;
int top;//栈顶
int maxSize;//栈的最大空间

//构造方法
public Stack(int maxSize){
    this.maxSize = maxSize;
    datas = new Object[maxSize];
    top = -1;
}

/**
 * 获取栈的长度
 * @return
 */
public int getSize(){
    return maxSize;
}

/**
 * 返回栈中元素的个数
 * @return
 */
public int getElementCount(){
    return top;
}

/**
 * 判断栈是否为空
 * @return
 */
public boolean isEmpty(){
    return top == -1;
}

/**
 * 判断是否栈满
 * @return
 */
public boolean isFull(){
    return top + 1 == maxSize;
}

/**
 * 判断入栈是否成功
 * @param data
 * @return
 */
public boolean push(Object data){
    if (isFull()) {
        System.out.println("栈已满");
        return false;
    }
    datas[++top] = data;
    return true;
}

/**
 * 出栈
 * @return
 */
public Object pop(){
    if (isEmpty()) {
        System.out.println("栈已空");
    }
    return datas[top--];
}

/**
 * 返回栈顶元素
 * @return
 */
public Object peek(){
    return datas[getElementCount()];
}


public static void main(String[] args) {
    // TODO Auto-generated method stub
    Stack stack = new Stack(100);
    stack.push(new String("1"));
    stack.push(new String("2"));
    stack.push(new String("3"));
    stack.push(new String("4"));
    stack.push(new String("5"));
    stack.push(new String("6"));
    //返回栈顶元素看看是不是后进先出
    System.out.println(stack.peek());
    System.out.println();

    while (stack.top >= 0) {
        System.out.println(stack.pop());


    }
}

}

双链表
package com.itheima;

/**
* 双链表
* @author qingchao
*
*/
public class DoubleLink {

private class Node{
    Object data;//存放数据
    Node prev;//指向前一个数据
    Node next;//指向后一个数据
    public Node(Object data){
        this.data = data;
    }
}
private Node head;//头节点
private Node rear;//尾节点

/**
 * 添加数据
 * @param data
 */
public void add(Object data){
    //把数据放到节点中
    Node node = new Node(data);
    //把节点链接到链表中
    if (head == null) {
        //链表为空
        head = node;
        rear = node;
    } else {
        //从链表的尾部添加数据
        //老的尾节点指向新的尾节点
        rear.next = node;
        //新节点的前驱指向老的尾节点
        node.prev = rear;
        //成为新的节点
        rear = node;
    }

}

public String toString(){
    StringBuilder mess = new StringBuilder();
    //从头节点取数据
    Node temp = head;
    while (temp != null) {
        mess.append(temp.data + ",");
        temp = temp.next;
    }
    return mess + "";
}

/**
 * 删除数据
 * @param data
 */
public void remove(Object data){
    //找出数据所在的节点
    Node temp = find(data);
    if (temp != null) {
        //能找到数据所在的节点
        //只有一个数据
        if (head == null && rear == null) {
            head = null;
            rear = null;
        } else if(head == temp){//删除头节点
            head = head.next;
            head.prev = null;
        } else if(rear == temp){//删除尾节点
            rear = rear.prev;
            rear.next = null;
        } else {//删除中间节点
            temp.prev.next = temp.next;
            temp.next.prev = temp.prev;
        }

    }

}

/**
 * 找数据存在的节点
 * @param data
 * @return
 */
private Node find(Object data){
    //刚开始从头节点开始找
    Node temp = head;
    while (temp != null) {
        if (temp.data.equals(data) && temp.data.hashCode() == data.hashCode()) {
            //找到了
            break;
        }
        //没知道的话继续下一个
        temp = temp.next;

    }
    return temp;
}

public static void main(String[] args) {
    //测试 添加数据
    DoubleLink datas = new DoubleLink();
    datas.add("aaa");
    datas.add(33);
    datas.add("bbb");
    System.out.println(datas);
    System.out.println("***********************");
    System.out.println("测试删除");
    datas.remove(33);
    System.out.println(datas);
}

}