链表
头插法
public void addFirst(int data) {
// 1. 拿到一个实体
Node node = new Node(data);
// 2. 插入
// 如果是第一次插入,直接到头节点
if (this.head == null) {
this.head = node;
} else { //不是第一次插入
node.next = this.head; // 插入的节点指向头节点
this.head = node; // 更新头节点
}
}
尾插法
public void addLast(int data) {
// 1. 拿到一个实体
Node node = new Node(data);
Node cur = this.head;
// 2. 插入
// 如果是第一次插入,直接到头节点
if (this.head == null) {
this.head = node;
} else {
// 找尾巴
while (cur.next != null) {
cur = cur.next;
}
// 退出上面的循环,cur所执行的位置就是尾节点
cur.next = node;
}
}
任意位置插入
public boolean addIndex(int index, int data) {
Node node = new Node(data);
Node cur = searchIndex(index);
// 如果链表为空,直接插入到头节点
if (cur == null) {
node.next = this.head;
this.head = node;
} else { // 链表不为空,插入到 cur 的位置处
node.next = cur.next; // 将node链接到cur的下一个节点
cur.next = node; // 再将cur链接到node
}
return true;
}
查找是否包含
public boolean contains(int key) {
Node cur = this.head;
while (cur != null) {
if (cur.data == key) {
return true;
}
cur = cur.next;
}
return false;
}
删除元素(首次出现)
public int remove(int key) {
int oldData = 0;
Node pre = searchPre(key);
// 1. 若没有找到
if (pre == null) {
// return -1;
throw new UnsupportedOperationException("没有key的前驱");
}
// 2. 找到了,并且在第一个节点
if (pre == this.head && pre.data == key){
oldData = this.head.data;
this.head = this.head.next;
return oldData;
}
// 3. 找到了,并且不在第一个节点
Node delNode = pre.next; // 确定要删除的节点的位置
pre.next = delNode.next; // 让要删除的节点的前驱指向要删除的节点的后一个节点,进而删除该节点
return 0;
}
树
先序遍历(DLR)
public void preOrder(TreeNode treeNode) {
if(treeNode!= null) {
System.out.print(treeNode.getValue()+" ");
preOrder(treeNode.getLeftTreeNode());
preOrder(treeNode.getRightTreeNode());
}
}
非递归
public void preOrder1(TreeNode root) {
if(root==null) return;
// 栈,保存访问过的节点
LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
TreeNode node = root;
while(!stack.isEmpty() || node!=null) {
// 一直往左下遍历
while(node!=null) {
stack.push(node);
nodesVal.add(node.val);
node = node.left;
}
// 无左子树的时候,去判断右子树
node = stack.pop();
node = node.right;
}
}
中序遍历(LDR)
public void inOrder(TreeNode treeNode) {
if(treeNode!=null) {
midOrder(treeNode.getLeftTreeNode());
System.out.print(treeNode.getValue() +" ");
midOrder(treeNode.getRightTreeNode());
}
}
非递归
public void inOrder() {
Node current = root;
//把LinkedList作为栈使用
LinkedList<Node> s = new LinkedList<Node>();
while (current != null || !s.isEmpty()) {
while (current != null) {
s.addFirst(current);
current = current.left;
}
if (!s.isEmpty()) {
current = s.removeFirst();
System.out.print(current.data + " -> ");
current = current.right;
}
}
}
后序遍历(LRD)
public void afterOrder(TreeNode treeNode) {
if(treeNode!=null) {
afterOrder(treeNode.getLeftTreeNode());
afterOrder(treeNode.getRightTreeNode());
System.out.print(treeNode.getValue() + " ");
}
}
非递归
public void postTraversal1(TreeNode root) {
Deque<TreeNode> stack = new LinkedList<>();
// 当前正在遍历的结点
TreeNode cur = root;
// 刚被弹出栈的结点.
TreeNode pre = null;
while (!stack.isEmpty() || cur != null) {
// 当 cur 不为空时, 将左边的结点一直压栈
while (cur != null) {
stack.push(cur);
cur = cur.left;
}
// 当 cur 为空时, 查看栈顶元素
TreeNode top = stack.peek();
if (top.right == null) {
// 无右孩子
System.out.println(top.val);
pre = stack.pop();
} else if (top .right == pre) {
// 有右孩子并且右孩子已经被遍历过
System.out.println(top.val);
pre = stack.pop();
} else {
// 右孩子没有被遍历过.
cur = top.right;
}
}
}
层次遍历
public void levelTraverse(TreeNode root) {
if (root == null) {
return;
}
LinkedList<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
System.out.print(node.val+" ");
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
}
深度遍历
public void depthOrderTraverse(TreeNode root) {
if (root == null) {
return;
}
LinkedList<TreeNode> stack = new LinkedList<>();
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
System.out.print(node.val+" ");
if (node.right != null) {
stack.push(node.right);
}
if (node.left != null) {
stack.push(node.left);
}
}
}
查找
public boolean Search(Integer val) {
if(root == null) {
return false;
}
TreeNode treeNode = root;
while(treeNode!=null) {
if(treeNode.getValue()==val)
return true;
else if(treeNode.getValue()>val)
treeNode = treeNode.getLeftTreeNode();
else
treeNode = treeNode.getRightTreeNode();
}
return false;
}
图
public class AMWGraph {
private ArrayList vertexList;//存储点的链表
private int[][] edges;//邻接矩阵,用来存储边
private int numOfEdges;//边的数目
boolean[] isVisited = new boolean[8];
public AMWGraph(int n) {
//初始化矩阵,一维数组,和边的数目
edges=new int[n][n];
vertexList=new ArrayList(n);
numOfEdges=0;
}
//得到结点的个数
public int getNumOfVertex() {
return vertexList.size();
}
//得到边的数目
public int getNumOfEdges() {
return numOfEdges;
}
//返回结点i的数据
public Object getValueByIndex(int i) {
return vertexList.get(i);
}
//返回v1,v2的权值
public int getWeight(int v1,int v2) {
return edges[v1][v2];
}
//插入结点
public void insertVertex(Object vertex) {
vertexList.add(vertexList.size(),vertex);
}
//插入结点
public void insertEdge(int v1,int v2,int weight) {
edges[v1][v2]=weight;
numOfEdges++;
}
//删除结点
public void deleteEdge(int v1,int v2) {
edges[v1][v2]=0;
numOfEdges--;
}
//得到第一个邻接结点的下标
public int getFirstNeighbor(int index) {
for(int j=0;j<vertexList.size();j++) {
if (edges[index][j]>0) {
return j;
}
}
return -1;
}
//根据前一个邻接结点的下标来取得下一个邻接结点
public int getNextNeighbor(int v1,int v2) {
for (int j=v2+1;j<vertexList.size();j++) {
if (edges[v1][j]>0) {
return j;
}
}
return -1;
}
DFS
//私有函数,深度优先遍历
private void depthFirstSearch(boolean[] isVisited,int i) {
//首先访问该结点,在控制台打印出来
System.out.print(getValueByIndex(i)+" ");
//置该结点为已访问
isVisited[i]=true;
int w=getFirstNeighbor(i);
while (w!=-1) {
if (!isVisited[w]) {
depthFirstSearch(isVisited,w);
}
w=getNextNeighbor(i, w);
}
}
//对外公开函数,深度优先遍历,与其同名私有函数属于方法重载
public void depthFirstSearch() {
for(int i=0;i<getNumOfVertex();i++) {
//因为对于非连通图来说,并不是通过一个结点就一定可以遍历所有结点的。
if (!isVisited[i]) {
depthFirstSearch(isVisited,i);
}
}
}
BFS
//私有函数,广度优先遍历
private void broadFirstSearch(boolean[] isVisited,int i) {
int u,w;
Queue<Integer> queue=new LinkedList<>(); //队列
//访问结点i
System.out.print(getValueByIndex(i)+" ");
isVisited[i]=true;
//结点入队列
queue.add(i);
while (!queue.isEmpty()) {
u=((Integer)queue.poll()).intValue();
w=getFirstNeighbor(u);
while(w!=-1) {
if(!isVisited[w]) {
//访问该结点
System.out.print(getValueByIndex(w)+" ");
//标记已被访问
isVisited[w]=true;
//入队列
queue.add(w);
}
//寻找下一个邻接结点
w=getNextNeighbor(u, w);
}
}
}
//对外公开函数,广度优先遍历
public void broadFirstSearch() {
for(int i=0;i<getNumOfVertex();i++) {
if(!isVisited[i]) {
broadFirstSearch(isVisited, i);
}
}
}
}