2021-12-27 46. 全排列 47. 全排列 II 51. N 皇后 203. 移除链表元素 707. 设计链表

46. 全排列

class Solution {
    List<List<Integer>> res=new ArrayList<>();
    List<Integer> path=new ArrayList<>();
    public List<List<Integer>> permute(int[] nums){
         int[] used=new int[nums.length];
         backtracking(nums,used);
         return res;

    }
    //此题在处理时没有找到如何解决一个元素只要用一次的方法
    //可以另设一个数组标记，该元素是否已经使用
    public void backtracking(int[] nums,int[] used){
        if(path.size()==nums.length){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(used[i]==1) continue;
            path.add(nums[i]);
            used[i]=1;
            backtracking(nums,used);
            path.remove(path.size()-1);
            used[i]=0;
        }
    }
}

47. 全排列 II

class Solution {
    List<List<Integer>> res=new ArrayList<>();
    List<Integer> path=new ArrayList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
         int[] used=new int[nums.length];
         Arrays.sort(nums);
         backtracking(nums,used);
         return res;
    }
    public void backtracking(int[] nums,int[] used){
        if(path.size()==nums.length){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i=0;i<nums.length;i++){
//去重原则，将数组排序后，当该元素已经出现或者当前元素等于前一个元素并且前一个元素已经被选中时跳过不选
            if(used[i]==1 || (i>0 && nums[i]==nums[i-1]&&used[i-1]==1)){ 
                continue;
            }
            path.add(nums[i]);
            used[i]=1;
            backtracking(nums,used);
            path.remove(path.size()-1);
            used[i]=0;
        }
    }
}

51. N 皇后

class Solution {
//自己做题时未想到的点
//1.如何将最终得到的二维字符数组转换为题目所要求的的格式输出
//2.回溯终止条件没有想到就是遍历到最后一行时，回溯终止。
    List<List<String>> res=new ArrayList<>();
    List<String> path=new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
        char[][] queue=new char[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                queue[i][j]='.';
            }
        }
    backtracking(queue,0);
    return res;
    }
   // public void backtracking(char[][] queue){
      //  if(i==queue.length){
       //   for(char[] c:queue){
         //     path.add(String.valueof(c));
        //  }
      //  }
      ///  for(int i=0;i<queue.length;i++){
       //     for(int j=0;j<queue[0].length;j++){
        //        if(isV(i,j,queue,queue.length)){
         //           queue[i][j]='Q';
          //          backtracking(queue);
          //          queue[i][j]='.';
               // }
            //}
       // }
    //}
    public void backtracking(char[][] queue,int row){
        if(row==queue.length){
            path=new ArrayList<>();
          for(char[] c:queue){
              path.add(String.valueOf(c));
         }
         res.add(path);
         return;
        }
            for(int j=0;j<queue[0].length;j++){
                if(isV(row,j,queue,queue.length)){
                    queue[row][j]='Q';
                    backtracking(queue,row+1);
                   queue[row][j]='.';
    }
}
    }
    
//判断是否合法从三个方面进行 1.列不能重复 2.左上斜线不能重复 3.右上斜线不能重复
    public boolean isV(int i,int j,char[][] queue,int length){
        for(int m=0;m<i;m++){
            if(queue[m][j]=='Q') return false;
        }
          for(int m=i,n=j;m>=0&&n>=0;m--,n--){
            if(queue[m][n]=='Q') return false;
        }
        for(int m=i,n=j;m>=0&&n<length;m--,n++){
            if(queue[m][n]=='Q') return false;
        }
        return true;
    }
}

203. 移除链表元素

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode tempcur=new ListNode(0,head);
        ListNode cur=head;
       // while(head.val==val){
       //注意找新的头指针是在头指针不为空的前提下且头指针的值不等于符合条件的值时才向后移   
       //要考虑没有满足删除值的情况 
        while(head!=null && head.val==val){
            head=head.next;
        }
        while(cur!=null){
            if(cur.val==val){
                tempcur.next=cur.next;
            }else{
            tempcur=cur;
           // cur=cur.next;
            }
            //无论找没找到cur在循环中是要向后挪的
            cur=cur.next;
        }
        return head;
    }
}

707. 设计链表

//对头插法没有理解透彻
class ListNode{
    int val;
    ListNode next;
    public ListNode(){}
    public ListNode(int val){
        this.val=val;
    }
}

class MyLinkedList {
    //没有意识在构建链表的同时去创建一个节点类
    int size;
    ListNode head;
    /** Initialize your data structure here. */
    public MyLinkedList() {
        head = new ListNode(0);
        size = 0;
    }
    
    public int get(int index) {
        if(index<0 || index>=size) return -1;
        int count=0;
        ListNode cur=head;
        //index从0开始
      //  while(count!=index){
          while(count!=index+1){
            cur=cur.next;
            count++;
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
      addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
     addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
       
        if(index > size){
            return;
        }
     //以下情况均为增加节点情况，所以size++
        size++;
        ListNode cur = head;
      if(size >= index && size > 0) {
          for (int i = 0; i < index; i++) {
              cur = cur.next;
          }
          ListNode addNode = new ListNode(val); //利用有参数的构造方法
          addNode.next = cur.next;
          cur.next = addNode;
      }
        if(index < 0){
            ListNode addNode2 = new ListNode(val);
            addNode2.next = head.next;
            head.next = addNode2;
        }
    
       }
    
    public void deleteAtIndex(int index) {
        if(index<0||index>=size) return;
        ListNode cur=head;
        for(int i=0;i<index;i++){
            cur=cur.next;
        }
        cur.next=cur.next.next;
        size--;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */