【Java数据结构】栈、队列、链表
看B站的数据结构视频照着打的，留着自己复习方便看。
B站链接：Java数据结构
栈：栈的底层我们使用数组来存储数据
package demo2;
public class MyStack {
//栈的底层我们使用数组来存储数据
int[] elements;
public MyStack(){
elements = new int[0];
}
//压入元素
public void push(int element){
//创建一个新的数组
int[] newArr = new int[elements.length + 1];
for (int i = 0; i < elements.length; i++) {
newArr[i] = elements[i];
}
//把添加的元素放入新数组中
newArr[elements.length] = element;
//使用新数组替换旧数组
elements = newArr;
}
//取出栈顶元素
public int pop(){
//栈中没有元素
if (elements.length == 0){
throw new RuntimeException("stack is empty");
}
//取出数组的最后一个元素
int element = elements[elements.length-1];
//创建一个新的数组
int[] newArr = new int[elements.length-1];
//原数组中除了最后一个元素的其他元素都放入新的数组中
for (int i=0;i<elements.length-1;i++){
newArr[i] = elements[i];
}
//替换数组
elements = newArr;
//返回数组
return element;
}
//查看栈顶元素
public int peek(){
return elements[elements.length-1];
}
}
测试栈：
package demo2.demo2.test;
import demo2.MyStack;
public class testMyStack {
public static void main(String[] args){
//创建一个栈
MyStack ma = new MyStack();
//压入数据
ma.push(9);
ma.push(8);
ma.push(7);
//输出栈顶元素
System.out.println(ma.pop());
//查看栈顶元素
System.out.println(ma.peek());
}
}
队列：
package demo2;
public class MyQueue {
int[] elements;
public MyQueue(){
elements = new int[0];
}
//入队
public void add(int element){
//创建一个新的数组
int[] newArr = new int[elements.length + 1];
for (int i = 0; i < elements.length; i++) {
newArr[i] = elements[i];
}
//把添加的元素放入新数组中
newArr[elements.length] = element;
//使用新数组替换旧数组
elements = newArr;
}
public int poll(){
//把数组中第0个元素取出来
int element = elements[0];
//创建新的数组
int[] newArr = new int[elements.length-1];
for (int i=0;i<newArr.length;i++){
newArr[i] = elements[i+1];
}
//替换数组
elements = newArr;
return element;
}
//判断队列是否为空
public boolean isEmpty(){
return elements.length == 0;
}
}
测试队列：
package demo2.demo2.test;
import demo2.MyQueue;
public class testMyQueue {
public static void main(String[] args){
//创建一个队列
MyQueue mq = new MyQueue();
//入队
mq.add(9);
mq.add(8);
mq.add(7);
//出队
System.out.println(mq.poll());
System.out.println(mq.poll());
System.out.println(mq.isEmpty());
}
}
链表：节点
package demo2;
//一个节点
public class Node {
//节点内容
int data;
//下一个节点
Node next;
public Node(int data){
this.data=data;
}
//为节点追回节点
public Node append(Node node){
//当前节点
Node currentNode = this;
//循环向后找
while (true){
//取出下一个节点
Node nextNode = currentNode.next;
//如果下一个节点为null,当前节点已经是最后一个节点
if (nextNode==null){
break;
}
//赋给当前节点
currentNode = nextNode;
}
//把需要追回的节点追加为找到的当前节点的下一个节点
currentNode.next = node;
return this;
}
//插入节点作为当前节点的下一个节点
public void after(Node node){
//取出下一个节点作为下下一个节点
Node nextNext = this.next;
//把新节点作为当前节点的下一个节点
this.next = node;
//把下下节点设置为新节点的下一个节点
node.next = nextNext;
}
//显示所有节点信息
public void show(){
Node currentNode = this;
while (true){
System.out.print(currentNode.data+" ");
//取出下一个节点
currentNode = currentNode.next;
//如果是最后一个节点
if (currentNode == null){
break;
}
}
System.out.println();
}
//删除下一个节点
public void remove(){
//取出下下一个节点
Node newnext = this.next.next;
//把下下一个节点设置为当前节点的下一个节点
this.next = newnext;
}
//获取下一个节点
public Node next(){
return this.next;
}
//获取节点中的数据
public int getData(){
return this.data;
}
//当前节点是否是最后一个节点
public boolean islast(){
return next==null;
}
}
测试节点：
package demo2.demo2.test;
import demo2.Node;
public class testNode {
public static void main(String[] agrs){
//创建节点
Node n1 = new Node(1);
Node n2 = new Node(2);
Node n3 = new Node(3);
//追加节点
// n1.append(n2);
// n1.append(n3);
n1.append(n2).append(n3).append(new Node(4));
//取出下一个节点的数据
// System.out.println(n1.next().next().next().getData());
//判断节点是否为最后一个节点
// System.out.println(n1.next().islast());
// System.out.println(n1.next().next().next().islast());
//显示所有节点信息
n1.show();
// n1.next().remove();
// n1.show();
//插入一个新的节点
Node node = new Node(5);
n2.after(node);
n1.show();
}
}
循环链表：
package demo2;
//一个节点
public class LoopNode {
//节点内容
int data;
//下一个节点
LoopNode next=this;
public LoopNode(int data){
this.data=data;
}
//插入节点作为当前节点的下一个节点
public void after(LoopNode node){
//取出下一个节点作为下下一个节点
LoopNode nextNext = this.next;
//把新节点作为当前节点的下一个节点
this.next = node;
//把下下节点设置为新节点的下一个节点
node.next = nextNext;
}
//删除下一个节点
public void remove(){
//取出下下一个节点
LoopNode newnext = this.next.next;
//把下下一个节点设置为当前节点的下一个节点
this.next = newnext;
}
//获取下一个节点
public LoopNode next(){
return this.next;
}
//获取节点中的数据
public int getData(){
return this.data;
}
}
测试循环链表：
package demo2.demo2.test;
import demo2.LoopNode;
public class testLoopNode {
public static void main(String[] args){
LoopNode n1 = new LoopNode(1);
LoopNode n2 = new LoopNode(2);
LoopNode n3 = new LoopNode(3);
LoopNode n4 = new LoopNode(4);
//增加节点
n1.after(n2);
n2.after(n3);
n3.after(n4);
System.out.println(n1.next().getData());
System.out.println(n2.next().getData());
System.out.println(n3.next().getData());
System.out.println(n4.next().getData());
}
}
双向链表：
package demo2;
public class DoubleNode {
//上一个节点
DoubleNode pre=this;
//下一个节点
DoubleNode next=this;
//节点数据
int data;
public DoubleNode(int data){
this.data = data;
}
//增加节点
public void after(DoubleNode node){
//原来的下一个节点
DoubleNode nextNext = this.next;
//把新节点作为当前节点的下一个节点
this.next = node;
//把当前节点做新节点的前一个节点
node.pre = this;
//让原来的下一个节点作为新节点的下一个节点
node.next = nextNext;
//让原来的下一个节点的上一个节点为新节点
nextNext.pre = node;
}
//下一个节点
public DoubleNode next(){
return this.next;
}
//上一个节点
public DoubleNode pre(){
return this.pre;
}
//获取数据
public int getData(){
return this.data;
}
}
测试循环链表：
package demo2.demo2.test;
import demo2.DoubleNode;
public class testDoubleNode {
public static void main(String[] args){
//创建节点
DoubleNode n1 = new DoubleNode(1);
DoubleNode n2 = new DoubleNode(2);
DoubleNode n3 = new DoubleNode(3);
//追加节点
n1.after(n2);
n2.after(n3);
System.out.println(n2.pre().getData());
System.out.println(n2.getData());
System.out.println(n2.next().getData());
System.out.println(n3.next().getData());
System.out.println(n1.pre().getData());
}
}