数据结构_线性表_栈_队列的(面向接口)实现_Unit_1；

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());
	}
}