线性表的逻辑结构:栈、队列
利用链表结构和数组结构实现栈的先进后出
public class Test02 {
public static void main(String[] args) {
int [] a={1,2,3,4,5,6,7,8};
ArrayStack<Integer> arrayStack=new ArrayStack<Integer>(10);
for (int i = 0; i < a.length; i++) {
arrayStack.push(a[i]);
}
System.out.println("------------");
for (;;) {
Integer temp=arrayStack.pop();
if(temp==null){
break;
}
System.out.println(temp);
}
}
static class ArrayStack<T> implements MyStack<T>{
Object [] objects;
public ArrayStack(int size){
objects=new Object[size];
}
@Override
public boolean push(T object) {
for (int i = 0; i < objects.length; i++) {
if(objects[i]==null){
objects[i]=object;
return true;
}
}
return false;
}
@Override
public T pop() {
for (int i = 0; i < objects.length; i++) {
if(objects[i]==null){
if(i>0){
Object temp=objects[i-1];
objects[i-1]=null;
return (T)temp;
}
}else{
if(i==objects.length-1){
Object temp=objects[objects.length-1];
objects[objects.length-1]=null;
return (T)temp;
}
}
}
return null;
}
}
static class LinkedStack<T> implements MyStack<T>{
Node<T> top =null;
Node<T> p=null;
int size=0;
@Override
public boolean push(T object) {
if(size==0){
top=new Node<T>();
p=top;
top.value=object;
}else{
p.next=new Node<T>();
p.next.value=object;
p=p.next;
}
size++;
return true;
}
@Override
public T pop() {
Node<T> temp=top;
if(size==0){
return null;
}
if(size==1){
temp=top;
top=null;
size=0;
p=null;
return temp.value;
}
while (true){
if (temp.next!=null){
if(temp.next.next==null){
break;
}
}
temp=temp.next;
}
Node<T> result=p;
p=temp;
p.next=null;
size--;
return result.value;
}
static class Node<T>{
T value;
Node<T> next;
}
}
static class LinkedStack2<T> implements MyStack<T>{
Node<T> top=null;
int size=0;
@Override
public boolean push(T object) {
if(size==0){
top=new Node<T>();
top.value=object;
}else{
Node<T> temp=new Node<T>();
temp.value=object;
temp.next=top;
top=temp;
}
size++;
return true;
}
@Override
public T pop() {
Node<T> result=top;
if(size==1){
top=null;
size=0;
return result.value;
}
if(size==0){
return null;
}
top=top.next;
size--;
return result.value;
}
static class Node<T>{
T value;
Node<T> next;
}
}
interface MyStack<T>{
boolean push(T object);
T pop();
}
}
利用数组和链表结构实现队列先进先出效果
public class Test03 {
public static void main(String[] args) {
int [] a={1,2,3,4,5,6,7,8,9};
// ArrayQueue<Integer> arrayQueue=new ArrayQueue(9);
// for (int i = 0; i < a.length; i++) {
// arrayQueue.add(a[i]);
// }
// while (true) {
// Integer result=arrayQueue.remove();
// if(result==null){
// break;
// }
// System.out.println(result);
// }
LinkedQueue<Integer> linkedQueue=new LinkedQueue();
for (int i = 0; i < a.length; i++) {
linkedQueue.add(a[i]);
}
while (true) {
Integer result=linkedQueue.remove();
if(result==null){
break;
}
System.out.println(result);
}
}
//数组实现为有界队列
static class ArrayQueue<T> implements MyQueue<T>{
Object [] objects;
int size=0;
public ArrayQueue(int size){
objects=new Object[size];
}
@Override
public boolean add(T object) {//从头插入数据
if(size==objects.length){
return false;
}
if(size!=0){
System.arraycopy(objects, 0, objects, 1,
size);
}
objects[0]=object;
size++;
return true;
}
@Override
public T remove() {//尾部移除数据
if(size==0){
return null;
}
//size=0
//此时无元素
//size=1
//唯一的一个元素就是objects[0]
T result= (T) objects[size-1];
objects[size-1]=null;
size--;
return result;
}
}
static class LinkedQueue<T> implements MyQueue<T>{//尾部插入
Node<T> top;
Node<T> p;
int size=0;
@Override
public boolean add(T object) {//p指向最后一个
if(size==0){
top=new Node<T>();
top.value=object;
p=top;
}else{
p.next=new Node<T>();
p.next.value=object;
p=p.next;
}
size++;
return true;
}
@Override
public T remove() {//头部取出
if(size==0){
return null;
}
T result=top.value;
if(size==1){
top=null;
size=0;
return result;
}
top=top.next;
size--;
return result;
}
static class Node<T>{
T value;
Node<T> next;
}
}
interface MyQueue<T>{
boolean add(T object);
T remove();
}
}