Topic 1：线性表
package lanqiao;
/**
* 线性表的接口
* 我们的这个接口为顺序存储的线性表服务
* 我们进行面向接口的编程
* @author wangtong
*
*/
public interface List {
//指定的下标（索引）位置插入数据元素（增）
public void insert(int index,Object obj) throws Exception;
//删除指定下标（索引）位置的数据（删）
//注意我们的这个删除方法的操作一般情况下 都要把我们删除的那个数据给返回出来显示一下的
public Object delect(int index) throws Exception;
//替换指定下标（索引）位置的数据（改）
public void replace (int index,Object obj) throws Exception;
//获取指定下标位置的元素（查）
public Object getData(int index) throws Exception;
//获取线性表中元素的个数
public int getSize();
//判断线性表是否为空
public boolean isEmpty();
}
package lanqiao;
/**
*
* 实现List接口 完成顺序存储的线性表
* 底层实现是数组
* 我们要时刻注意 size指的是元素的个数 他等于下标减一
* @author wangtong
*
*/
public class LinearList implements List {
//线性表的默认长度
private final int defaultSize = 10;
//线性表的总长度
private int totalSize ;
//线性表中元素个数
private int size;
//顺序存储的线性表
private Object[] linearList;
//无参构造函数 这个无参构造函数应当构造一个默认长度的线性表
//所以我们先写一个实现构造默认函数
private void init (int sz) {
totalSize = sz;
size = 0;
linearList = new Object[sz];
}
//无参构造
public LinearList () {
init(defaultSize);
}
//有参构造函数
public LinearList (int size) {
init(size);
}
@Override
public void insert(int index, Object obj) throws Exception {
//先判断线性表是否有空余的位置
if (size == totalSize) {
throw new Exception("线性表已满，无法插入！！！");
}
//再判断索引是否越界
/*
* 只允许在线性表元素的之前后之后插入 不能在一个空位置的之后插入
* 我们这里的判断条件设置为判断 index > size 要是成立的话那么就会
* 在一个空位置的之后插入 不符合 ；index = size是允许的这个时候
* 就是在最后一个元素的后面插入
*/
if (index > size) {
throw new Exception("插入的位置不正确！！！");
}
//索引满足条件之后 我们要把插入位置的元素及其以后的元素都向后移动
//我们这里要注意移动的顺序 要从后往前执行才能保证数据不会被覆盖
for (int i = size - 1; i >= index; i--) {
linearList[i+1] = linearList[i];
}
//插入元素
linearList[index] = obj;
//记录元素的插入
size ++;
}
@Override
public Object delect(int index) throws Exception {
//判断线性表是否为空
if (size == 0) {
throw new Exception ("线性表已空，无法删除！！！");
}
//判断索引是否有错
if (index > size-1) {
throw new Exception ("删除的元素不存在！！！");
}
//当索引符合要求之后开始删除
//先获得我们要删除的元素 不然一会给覆盖了
Object temp = linearList[index];
//从index的后一位开始往前移动
for (int i = index; i < size - 1; i++) {
linearList[i] = linearList[i+1];
}
//删除减一
size --;
return temp;
}
@Override
public void replace(int index, Object obj) throws Exception {
//判断线性表为空
if (size == 0) {
throw new Exception ("线性表已空，无法替换！！！");
}
//判断索引是否越界
if (index > size-1) {
throw new Exception ("替换的元素的下标错误（下标指向的那个元素为null）！！！");
}
//替换
linearList[index] = obj;
}
@Override
public Object getData(int index) throws Exception {
//判断线性表为空
if (size == 0) {
throw new Exception ("线性表已空，无法查找元素！！！");
}
//判断索引是否越界
if (index > size-1) {
throw new Exception ("查找的那个元素为null（下标指向的那个元素为null）！！！");
}
return linearList[index];
}
@Override
public int getSize() {
return size;
}
@Override
public boolean isEmpty() {
// if (size == 0) {
// return true;
// } else {
// return false;
// }
//看简单的代码
return size == 0;
}
//增加方法 print
public void print () {
// 我们这里使用增强for会出现问题
for (int i = 0; i < size; i++) {
System.out.println(linearList[i]);
}
}
//增加方法追加 表示在线性表的后面加一个元素
public void append(Object obj) throws Exception {
//先判断线性表是否有空余的位置
if (size == totalSize) {
throw new Exception("线性表已满，无法插入！！！");
}
size ++;//为了解决第一个元素的加入
linearList[size - 1] = obj;
}
}
package test;
import lanqiao.LinearList;
/**
* 测试我们写的顺序存储的线性表
* @author wangtong
*
*/
public class TestLinearList {
public static void main (String[] args) {
//无参构造
LinearList ll = new LinearList() ;
//有参构造
//LinearList ll2 = new LinearList(20);
try {
for(int i = 0; i < 10; i++)
ll.append(i);
System.out.println(ll.getSize());
System.out.println("------------------------------------------");
System.out.println("删除" + ll.delect(5));
System.out.println("------------------------------------------");
System.out.println(ll.getSize());
System.out.println("------------------------------------------");
System.out.println(ll.getData(5));
System.out.println(ll.getData(6));
ll.replace(1,3);
System.out.println("------------------------------------------");
ll.print();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Topic 2 ： 栈
package lanqiao;
/**
* 实现栈的面向接口编程
* 先进后出 栈的删除（出栈）并不是真正的删除
* 他只是把指针变量挪了一位
* @author wangtong
*
*/
public interface StackInterface {
//进栈（压栈）
public void push (Object obj) throws Exception;
//出栈 跟以前一样删除一个元素要 返回这个元素看看删除的是什么
public Object pop () throws Exception;
//查看栈顶元素但不删除
public Object getTop () throws Exception;
//判断是否为空栈
public boolean isEmpty();
}
package lanqiao;
/**
* 栈类的实现
* @author wangtong
*
*/
public class Stack implements StackInterface{
//栈顶指针 也表示栈内的元素个数
private int top;
//栈的总空间
private int totalSize;
//默认栈的空间
private final int defaultSize = 10;
//栈的容器
private Object[] stack;
//初始化方法
private void init( int sz) {
top = 0;
totalSize = sz;
stack = new Object[sz];
}
//无参构造器
public Stack () {
init(defaultSize);
}
//有参构造器
public Stack (int size) {
init(size);
}
@Override
public void push(Object obj) throws Exception {
//检测栈是否已满
if (top == totalSize) {
throw new Exception("栈已满！！！");
}
stack[top] = obj;
top ++;
}
@Override
public Object pop() throws Exception {
//检测栈是否为空
if (top == 0) {
throw new Exception("栈为空！！！");
}
top --;
return stack[top];
}
@Override
public Object getTop() throws Exception {
//检测栈是否为空
if (top == 0) {
throw new Exception("栈为空！！！");
}
return stack[top - 1];
}
@Override
public boolean isEmpty() {
return top == 0;
}
}
package lanqiao;
/**
* 测试自己栈的实现
* 基于数组的顺序栈
* @author wangtong
*
*/
public class TestStack {
public static void main (String[] args) {
Stack s = new Stack();
try {
for (int i = 0; i < 10; i++) {
s.push(i);
System.out.println(s.getTop());
}
// 逐个出栈
while (!s.isEmpty()) {
System.out.println(s.pop());
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Topic 3：队列
package lanqiao;
/**
* 队列的特点是队头删除 队尾插入
* 实现队列的面向接口编程
* @author wangtong
*
*/
public interface QueueInterface {
//入队
public void enter (Object obj) throws Exception;
//出队
public Object out () throws Exception;
//获取但不删除队首元素
public Object lookFront () throws Exception;
//判空
public boolean isEmpty () ;
}
package lanqiao;
/**
* 队列的实现类
* @author wangtong
*
*/
public class Queue implements QueueInterface{
private Object[] queue;
private int front;
private int rear;
private final int defaultSize = 10;
private int totalSize;
private void init (int size) {
front = 0;
rear = 0;
totalSize = size;
queue = new Object[size];
}
public Queue () {
init(defaultSize);
}
public Queue (int size) {
init(size);
}
@Override
public void enter(Object obj) throws Exception {
//判满
if (front == totalSize) {
throw new Exception ("你的队列已满！！！");
}
queue[rear++] = obj;//先赋值 后加加
}
@Override
public Object out() throws Exception {
//判空
if (isEmpty()) {
throw new Exception ("栈为空！！！");
}
Object temp = queue[front++];
return temp;
}
@Override
public Object lookFront() throws Exception {
//判空
if (isEmpty()) {
throw new Exception ("栈为空！！！");
}
return queue[front];
}
@Override
public boolean isEmpty() {
return front == rear;
}
//增加方法 自身的长度
public int length () {
return rear - front;
}
}
package lanqiao;
/**
* 测试字节写的顺序存储结构的队列
* @author wangtong
*
*/
public class TestQueue {
public static void main (String[] args) throws Exception {
Queue q = new Queue();
for (int i = 0; i < 9; i++) {
q.enter(i);
}
System.out.println(q.out());
q.enter(1);
System.out.println(q.length());
}
}