算法相关笔记，持续更新中...

单链表

1.删除单链表中的指定节点：

public static void deleteNode(Node head,Node node){
    //删除尾节点，采用顺序查找找到尾节点的前一节点
    if（node.next == null）{
        while(head.next!=node){
          head = head.next;
        }
        head.next = null;
    }
    //要删除的节点是头结点
    else if（head==node）{
      head = null；
    }
    //要删除的节点是中间的普通节点
    else{
      Node q = node.next；
      node.data = q.data;
      node.next = q.next;
    }
}

2.单链表中删除指定数值的节点方法一：利用栈

public Node removeValue1(Node head,int num){
  Stack stack = new Stack();
  while(head !=null){
    if(head.data!=null){
      stack.push(head)；
    }
    head = head.next;
  }
  while（!stack.isEmpty()）{
    stack.peek().next = head;
    head = stack.pop();
  }
  return head;
}

3.单链表中删除指定数值的节点方法二：不利用栈

public Node removeValue2(Node head,int num){
  while(head！= null){
    if(head.data!=null){
      break；
    }
    head = head.next;
  }
  Node pre = head;
  Node cur = head;
  while(cur!=null){
    if(cur.data == num){
      pre.next = cur.next;
    }else{
      pre = cur;
    }
    cur = cur.next;
  }
  return head;
}

4.删除单链表中数值重复出现的节点

public void deleteDuplication(Node head){
  if(head == null){
    return ;
  }
  HashSet set = new HashSet();
  Node pre = head;
  Node cur = head.next;
  set.add(head.data)；
  while(cur!=null){
    if(set.contains(cur.data)){
      pre.next = cur.next;
    }else{
      set.add(cur.data)；
      pre = cur;
    }
    cur = cur.next;
  }
}

5.两个单链表生成相加链表

public Node addList2(Node head1,Node head2){
  Stack stack1 = new Stack();
  Stack stack2 = new Stack();
  while(head1!= null){
    stack1.push(head1.data);
    head1 = head1.next;
  }
  while(head2!= null){
    stack2.push(head2.data);
    head2 = head2.next;
  }
  int n1 = 0;//链表1的数值
  int n2 = 0;//链表2的数值
  int n  = 0;//n1+n2+ca
  int ca = 0;//进位
  
  Node node = nul;//当前节点
  Node pnode= null;//当前节点的前驱节点
  while(!stack1.isEmpty()||!stack2.isEmpty()){
    n1 = stack1.isEmpty()?0:stack1.pop();
    n2 = stack2.isEmpty()?0:stack2.pop();
    n = n1+n2+ca;
    node = new Node(n%10);
    node.next = pnode;
    pnode = node;
    ca = n/10;
  }
  
  if(ca == 1){
    pnode = node;
    node = new Node(n/10);
    node.next = pnode;
  }
  return node;
}

6.判断一个单链表是否为回文结构(1221反转1221是回文结构，1234反转4321不是回文结构)

public boolean isPalindeome1(Node head){
  if(head == null){
    retrun false;
  }
  Stack stack = new Stack();//记住这个地方不是cur.next不然最后一个节点没有压入栈
  Node cur = head;
  while(cur!=null){
    stack.push(cur);
    cur = cur.next;
  }
  while(head.next!=null){
    if(head.data != stack.pop().data){
      return false;
    }
    head = head.next;
  }
  return true;
}

7.删除单链表的倒数第k个节点

public static Node removeLastKthNode(Node head,int k){
  if(k<=0||head == null){
    return head;
  }
  Node p = head;
  for(int i = 0; i

8.通过两个栈来实现一个队列
栈 先进后出；队列 先进先出

public class QueueWithStack{
  private static Stack