├── src
    ├──  main
    │   └──  java
    │   │   └──  MoveZeroes
    │   │       ├── fate0928
    │   │       └── MoveZeroes.java
    └── main
    │   └── java
    │       ├── GenerateParentheses
    │           ├── Aerdax
    │           │   └── GenerateParentheses.py
    │           ├── code drinker
    │           │   ├── file.keep
    │           │   └── AzusaMutan
    │           │   │   └── GenerateParenthesis
    │           ├── graceBaoXP
    │           │   └── GenerateParentheses.java
    │           ├── Mnting
    │           │   └── 22.GenerateParentheses.java
    │           └── AzusaMutan
    │           │   └── GenerateParentheses
    │       ├── ValidParenthesisString
    │           ├── Aerdax
    │           │   └── ValidParenthesisString.py
    │           └── AzusaMutan
    │           │   ├── ValidParenthesisString.java
    │           │   └── zhanweta
    │           │       └── ValidParenthesisString.java
    │       ├── RemoveElement
    │           ├── OnePunchMan34
    │           │   └── RemoveElement.py
    │           ├── AzusaMutan
    │           │   └── RemoveElement.java
    │           ├── Ardax
    │           │   └── RemoveElement.py
    │           ├── GaryLinTouchWorld
    │           │   └── RemoveElement.js
    │           ├── L07152055
    │           │   └── RemoveElement.java
    │           ├── huangzfang
    │           ├── removeElements.py
    │           ├── Mnting
    │           │   └── RemoveElement.java
    │           ├── GoKu-gaga
    │           │   └── RemoveElement.js
    │           ├── zhangzhongjun
    │           │   └── Solution.java
    │           ├── zhanweta
    │           │   └── RemoveElement.java
    │           ├── beau0303
    │           │   └── RemoveElement.java
    │           ├── husterlantern
    │           │   └── RemoveElement
    │           ├── graceBaoXP
    │           │   └── RemoveElement.java
    │           ├── JiA1996
    │           │   └── removeElement
    │           │   │   └── removeElement.java
    │           ├── Zntao
    │           │   └── RemoveElement.java
    │           ├── zhangkaijian123
    │           │   └── RemoveElement.java
    │           ├── readme.md
    │           └── playwithfun1995
    │           │   └── RemoveElement.java
    │       ├── MoveZeroes
    │           ├── Aerdax
    │           │   └── MoveZeros.py
    │           ├── L07152055
    │           │   └── MoveZeroes.java
    │           ├── mayuqingxx
    │           │   └── MoveZeroes.java
    │           ├── readme.md
    │           ├── OnePunchMan34
    │           │   └── MoveZeroes.py
    │           ├── GaryLinTouchWorld
    │           │   └── MoveZeroes.js
    │           ├── Mnting
    │           │   └── 283.MoveZeros.java
    │           ├── codedrinker
    │           │   └── MoveZeroes.java
    │           ├── GoKu-gaga
    │           │   └── MoveZeroes.js
    │           ├── AzusaMutan
    │           │   └── MoveZero.java
    │           ├── wuydit
    │           │   ├── MoveZeroes.java
    │           │   └── RemoveElement.java
    │           ├── MoveZero.py
    │           ├── graceBaoXP
    │           │   └── MoveZeros.java
    │           ├── zwd
    │           │   └── MoveZeroes.java
    │           ├── zhangqian0710
    │           │   └── MoveZreos.java
    │           ├── JiA1996
    │           │   └── MoveZeroes.java
    │           ├── husterlantern1
    │           │   └── MoveZeroes.java
    │           ├── fcbhank
    │           │   └── MoveZeroes.java
    │           ├── Zntao
    │           │   └── MoveZeroes.java
    │           ├── weichong0325
    │           │   └── MoveZeroes.java
    │           ├── zhanweta
    │           │   └── MoveZeros.java
    │           ├── zhangkaijian123
    │           │   └── MoveZeroes.java
    │           ├── yuhangtdm
    │           │   └── MoveZeroes.java
    │           ├── zhangzhongjun
    │           │   └── ArrayTest.java
    │           ├── beau0303
    │           │   └── MoveZeroes.java
    │           ├── ZHANGJIKAI5
    │           │   └── MoveZeroes.java
    │           ├── wangyuhuich
    │           │   └── MoveZeroes.java
    │           └── eistert
    │           │   └── MoveZeroes.java
    │       └── ValidParentheses
    │           ├── ValidParentheses
    │           ├── Aerdax
    │               └── ValidParentheses.py
    │           ├── AzusaMutan
    │               ├── ValidParentheses
    │               ├── graceBaoXP
    │               │   └── ValidParentheses.java
    │               └── zhanweta
    │               │   └── ValidParentheses.java
    │           └── beau0303
    │               └── Solution.java
├── .gitignore
├── pom.xml
└── README.md


/src/ main/ java/ MoveZeroes/fate0928:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | letscode.iml
2 | target/
3 | .idea/


--------------------------------------------------------------------------------
/src/main/java/GenerateParentheses/Aerdax/GenerateParentheses.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/main/java/GenerateParentheses/code drinker/file.keep:
--------------------------------------------------------------------------------
1 | Keep
2 | 


--------------------------------------------------------------------------------
/src/main/java/ValidParenthesisString/Aerdax/ValidParenthesisString.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/ main/ java/ MoveZeroes/MoveZeroes.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/codedrinker/letscode/HEAD/src/ main/ java/ MoveZeroes/MoveZeroes.java


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/OnePunchMan34/RemoveElement.py:
--------------------------------------------------------------------------------
1 | class Solution:
2 |     def removeElement(self, nums: List[int], val: int) -> int:
3 |         pos=0
4 |         for i in range(len(nums)):
5 |             if nums[i] != val:
6 |                 nums[pos]=nums[i]
7 |                 pos+=1
8 |         return pos
9 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/Aerdax/MoveZeros.py:
--------------------------------------------------------------------------------
 1 | class Solution:
 2 |     def moveZeros(self, nums):
 3 |         count0 = nums.count(0)
 4 |         for i in range(count0):
 5 |             nums.remove(0)
 6 |             nums.append(0)
 7 |         return nums
 8 | nums=input("输入数字：")
 9 | nums = [int(n) for n in nums.split()]
10 | a=Solution()
11 | print(a.moveZeros(nums))


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/AzusaMutan/RemoveElement.java:
--------------------------------------------------------------------------------
 1 | public class RemoveElement {
 2 |     public int removeElement(int[] nums, int val) {
 3 |         int res = 0;
 4 |         for (int n: nums
 5 |         ){
 6 |             if ((val ^ n) != 0) {
 7 |                 nums[res++] = n;
 8 |             }
 9 |         }
10 | 
11 |         return res;
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/Ardax/RemoveElement.py:
--------------------------------------------------------------------------------
 1 | class Solution(object):
 2 |     def removeElement(self, nums, val):
 3 |         """
 4 |         :type nums: List[int]
 5 |         :type val: int
 6 |         :rtype: int
 7 |         """
 8 |         index=0
 9 |         for i in nums:
10 |             if i!=val:
11 |                 nums[index]=i
12 |                 index+=1
13 |         return index


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/L07152055/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.L07152055;
 2 | 
 3 | public class MoveZeroes {
 4 |     public static void movezeroes(int[] nums) {
 5 |         for(int i = 0, j = 0; i < nums.length; i++) {
 6 |             if(nums[i] != 0) {
 7 |                 int tmp = nums[i];
 8 |                 nums[i] = nums[j];
 9 |                 nums[j++] = tmp;
10 |             }
11 |         }
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/mayuqingxx/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.mayuqingxx;
 2 | 
 3 | public class MoveZeroes {
 4 |     public void moveZeroes(int[] nums) {
 5 |          for (int i = 0, a = 0; i < nums.length; i++) {
 6 |             if (nums[i] != 0) {
 7 |                 int temp = nums[i];
 8 |                 nums[i] = nums[a];
 9 |                 nums[a++] = temp;
10 |             }
11 |         }
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/GaryLinTouchWorld/RemoveElement.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @param {number[]} nums
 3 |  * @param {number} val
 4 |  * @return {number}
 5 |  */
 6 | var removeElement = function(nums, val) {
 7 |     var length = nums.length;
 8 |     for(let i = 0; i<length ; i++){
 9 |         if(nums[i] === val){
10 |             nums.splice(i,1);
11 |             i -=1;
12 |             length -=1;
13 |         }
14 |     }
15 |     return length;
16 | };


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/readme.md:
--------------------------------------------------------------------------------
 1 | ## 描述
 2 | Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.
 3 | 
 4 | ### Example:
 5 | 
 6 | Input: [0,1,0,3,12]
 7 | Output: [1,3,12,0,0]
 8 | ### Note:
 9 | 
10 | 1. You must do this in-place without making a copy of the array.  
11 | 2. Minimize the total number of operations.
12 | 
13 | ## 地址
14 | https://leetcode.com/problems/move-zeroes


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/L07152055/RemoveElement.java:
--------------------------------------------------------------------------------
 1 | 
 2 | class Solution {
 3 |     public int removeElement(int[] nums, int val) {
 4 |         int length = nums.length;
 5 |         int j = 0;
 6 |         for(int i = 0; i < nums.length; i++) {
 7 |             if(nums[i] != val) {
 8 |                 nums[j++] = nums[i];
 9 |             } else {
10 |                 length--;
11 |             }
12 |         }
13 |         return length;
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/huangzfang:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int removeElement(int[] nums, int val) {
 3 |         if(nums.length==0){
 4 | 			return 0;
 5 | 		}
 6 | 		int result=0;
 7 | 		for(int i=0,cur=0; i<nums.length; i++){
 8 | 			if(nums[i]!=val){
 9 | 				int swap=nums[i];
10 | 				nums[i]=nums[cur];
11 | 				nums[cur++]=swap;
12 | 				result++;
13 | 			}
14 | 		}
15 | 		nums=Arrays.copyOfRange(nums, 0, result);
16 | 		return result;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/removeElements.py:
--------------------------------------------------------------------------------
 1 | class Solution(object):
 2 |     def removeElement(self, nums, val):
 3 |         """
 4 |         :type nums: List[int]
 5 |         :type val: int
 6 |         :rtype: int
 7 |         """
 8 |         notval_count = 0
 9 | 
10 |         for i in range(0, len(nums)):
11 |             if nums[i] != val:
12 |                 nums[notval_count] = nums[i]
13 |                 notval_count += 1
14 | 
15 |         return notval_count


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/OnePunchMan34/MoveZeroes.py:
--------------------------------------------------------------------------------
 1 | class Solution:
 2 |     def moveZeroes(self, nums: List[int]) -> None:
 3 |         """
 4 |         Do not return anything, modify nums in-place instead.
 5 |         """
 6 |         #postion of output
 7 |         pos=0
 8 |         for i in range(len(nums)):
 9 |             if nums[i]:
10 |                 nums[pos]=nums[i]
11 |                 pos+=1
12 |         for i in range(pos,len(nums)):
13 |             nums[i]=0
14 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project xmlns="http://maven.apache.org/POM/4.0.0"
 3 |          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 5 |     <modelVersion>4.0.0</modelVersion>
 6 | 
 7 |     <groupId>com.github.codedrinker</groupId>
 8 |     <artifactId>letscode</artifactId>
 9 |     <version>1.0-SNAPSHOT</version>
10 | 
11 | 
12 | </project>


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/GaryLinTouchWorld/MoveZeroes.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @param {number[]} nums
 3 |  * @return {void} Do not return anything, modify nums in-place instead.
 4 |  */
 5 | var moveZeroes = function(nums) {
 6 |     let length = nums.length
 7 |     for(let i = 0 ; i < length ; i++){
 8 |         if(nums[i] === 0){
 9 |             nums.splice(i,1);
10 |             nums.push(0);
11 |             i = -1;
12 |             length -= 1;
13 |         }
14 |     }
15 |     return nums;
16 | };


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/Mnting/283.MoveZeros.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.Mnting;
 2 | /*
 3 |  * @lc app=leetcode.cn id=283 lang=java
 4 |  *
 5 |  * [283] 移动零
 6 |  */
 7 | class Solution {
 8 |     public void moveZeroes(int[] nums) {
 9 |         int insertPos = 0;
10 |         for(int num:nums){
11 |             if(num!=0)
12 |                 nums[insertPos++] = num;
13 |         }
14 |         while(insertPos<nums.length){
15 |             nums[insertPos++] = 0;
16 |         }
17 |     }
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/Mnting/RemoveElement.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * @lc app=leetcode.cn id=27 lang=java
 3 |  *
 4 |  * [27] 移除元素
 5 |  */
 6 | class Solution {
 7 |     public int removeElement(int[] nums, int val) {
 8 |         int Pos = 0, len = 0;
 9 |         for (int num : nums) {
10 |             if (num != val) {
11 |                 nums[Pos++] = num;
12 |             } else {
13 |                 len++;
14 |             }
15 |         }
16 |         return nums.length - len;
17 |     }
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Let's Code
 2 | 
 3 | 每日刷 LeetCode
 4 | 题目我会定时更新一些，数组、链表、栈、队列、二叉树等经典题目  
 5 | 解法会从遍历、递归、动态规划等逐步展开
 6 | 
 7 | # 刷题步骤
 8 | 1. 修改自己的刷题群备注为自己的 Github 账号名称，例如 codedrinker
 9 | 2. 点击 Star，Fork `letscode` 到自己的仓库  
10 | 3. 按照序号刷题，在以 LeetCode 题目名称的文件夹下面创建自己 Github 账号同名的文件名，例如
11 | ```
12 |   1.MoveZeroes
13 |     |-- codedrinker
14 |         |-- MoveZeroes.java
15 | ```
16 | 4. 访问 https://leetcode.com/ 官网，注册账号
17 | 5. 访问每个题目下面的 Readme.md 里面是链接地址和题目
18 | 6. 完成编码以后，到 LeetCode 官网提交结果，Accepted 以后再提交 Pull Request 合并到 master
19 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/GoKu-gaga/RemoveElement.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @param {number[]} nums
 3 |  * @param {number} val
 4 |  * @return {number}
 5 |  */
 6 | var removeElement = function(nums, val) {
 7 |   for(let i = 0; i < nums.length; i++) {
 8 |       if(nums[i] === val) {
 9 |           nums.splice(i, 1);
10 |           i -= 1;
11 |       }
12 |   }
13 |   return nums.length;
14 | };
15 | 
16 | /** 
17 |  * 执行结果
18 |  * 执行用时 : 76 ms, 在Remove Element的JavaScript提交中击败了96.95% 的用户
19 |  * 内存消耗 : 33.6 MB, 在Remove Element的JavaScript提交中击败了54.51% 的用户
20 | */


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/zhangzhongjun/Solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int removeElement(int[] nums, int val) {
 3 |         int i=0,j=0;
 4 |         for(;j<nums.length;j++){
 5 |             if(nums[j]!=val){
 6 |                 nums[i]=nums[j];
 7 |                 i++;
 8 |             }
 9 |         }
10 |         return i;
11 |     }
12 | 	
13 |    public static void main(String[] args){
14 | 	int nums[]={2,3,2,3};
15 | 	Solution solution = new Solution();
16 | 	System.out.println(solution.removeElement(nums,3));
17 |    }
18 | }


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/codedrinker/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.codedrinker;
 2 | 
 3 | /**
 4 |  * Created by codedrinker on 2019/5/29.
 5 |  * 解题思路
 6 |  * 循环元素，当元素不等于0就和cur 下标的元素交换，然后增加 cur 下标的值，最终就会把所有 0 交换到末尾，把所有非0交换到头部。
 7 |  */
 8 | public class MoveZeroes {
 9 |     public void moveZeroes(int[] nums) {
10 |         for (int i = 0, cur = 0; i < nums.length; i++) {
11 |             if (nums[i] != 0) {
12 |                 int swap = nums[i];
13 |                 nums[i] = nums[cur];
14 |                 nums[cur++] = swap;
15 |             }
16 |         }
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/zhanweta/RemoveElement.java:
--------------------------------------------------------------------------------
 1 | package RemoveElement.zhanweta;
 2 | 
 3 | public class RemoveElement {
 4 |     public static void main(String [] args){
 5 |         int [] nums = {3,2,2,3};
 6 |         System.out.print(removeElement(nums,3));
 7 |     }
 8 |     public static int removeElement(int[] nums,int val){
 9 |        int pos = -1;
10 |        for(int i = 0, len = nums.length  ; i<len; i++){
11 |            if(nums[i] != val) {
12 |                pos++;
13 |                nums[pos] = nums[i];
14 |            }
15 |        }
16 |        return pos+1;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/GoKu-gaga/MoveZeroes.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @param {number[]} nums
 3 |  * @return {void} Do not return anything, modify nums in-place instead.
 4 |  */
 5 | // 执行用时 : 80 ms, 在Move Zeroes的JavaScript提交中击败了99.23% 的用户
 6 | // 内存消耗 : 35.6 MB, 在Move Zeroes的JavaScript提交中击败了58.10% 的用户
 7 | 
 8 | var moveZeroes = function(nums) {
 9 |   let temp = 0;
10 |   let len = nums.length;
11 |   for(let i = 0; i < len; i++){
12 |       if(nums[i] !== 0){
13 |           nums[temp] = nums[i];
14 |           temp++;
15 |       }
16 |   }
17 |   for(; temp < len; temp++){
18 |       nums[temp] = 0;
19 |   }  
20 | };


--------------------------------------------------------------------------------
/src/main/java/ValidParentheses/ValidParentheses:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isValid(String s) {
 3 |        Map<Character,Character> map=new HashMap<>();
 4 | 		map.put('(', ')');
 5 | 		map.put('[',']');
 6 | 		map.put('{', '}');
 7 | 		Stack<Character> stack=new Stack<>();
 8 | 		for(int i=0;i<s.length();i++) {
 9 | 			char c=s.charAt(i);
10 | 			if(map.containsKey(c)) {
11 | 				stack.push(c);
12 | 			}else {
13 | 				if(stack.isEmpty()) return false;
14 | 				char left=stack.pop();
15 | 				if(c!=map.get(left))return false;
16 | 			}
17 | 		}
18 | 		
19 | 		return stack.isEmpty();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/beau0303/RemoveElement.java:
--------------------------------------------------------------------------------
 1 | package RemoveElement.beau0303;
 2 | 
 3 | /**
 4 |  * Created by IntelliJ IDEA.
 5 |  * Author:MeiFan
 6 |  * Date: 2019/5/30 13:11
 7 |  * e-mail:codemeifan@gmail.com.
 8 |  */
 9 | public class RemoveElement {
10 |     /*双指针，i从头开始定位，j去寻找非val的元素，然后把它赋值给i，这样遍历完，前i个元素都是非val的，return i*/
11 |     public int removeElement(int[] a, int val) {
12 |         int i, j;
13 |         for (i = 0, j = 0; j < a.length; j++) {
14 |             if (a[j]!=val){
15 |                 a[i]=a[j];
16 |                 i++;
17 |             }
18 |         }
19 |         return i;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/husterlantern/RemoveElement:
--------------------------------------------------------------------------------
 1 |     /*
 2 |     解题思路：和MoveZerees思路一样，不能创建新的数组，只能在原数组上操作，
 3 |     在找到和指定数字不相等的元素时，把元素移到前面去，索引往后移、进行循环，返回不相等的元素等于数组的长度减去
 4 |      */
 5 |     public  static int removeElement(int[] nums, int val) {
 6 |         int i=0,j=0;
 7 |         while(i<nums.length){
 8 |             if(nums[i]!=val){
 9 |                 nums[j++]=nums[i++];
10 |             }else{
11 |                 i++;
12 |             }
13 |         }
14 |         for(int k=0;k<j;k++){
15 |            System.out.print(nums[k]+" ");
16 |         }
17 |         System.out.println();
18 |         return j;
19 |     }
20 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/AzusaMutan/MoveZero.java:
--------------------------------------------------------------------------------
 1 | public class MoveZeroes {
 2 |     public static void moveZeroes(int[] nums) {
 3 |         int m;
 4 |         for(int i = 0 ; i < nums.length; i++) {
 5 |             if (nums[i] == 0) {
 6 |                 m = i;
 7 |                 for (int j = i; j < nums.length; j++) {
 8 |                     if (nums[j] != 0) {
 9 |                         int temp = nums[m];
10 |                         nums[m] = nums[j];
11 |                         nums[j] = temp;
12 |                         m = j;
13 |                     }
14 |                 }
15 |             }
16 |         }
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/wuydit/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.wuydit;
 2 | 
 3 | public class MoveZeroes {
 4 |     public void moveZeroes(int[] nums) {
 5 |         int zero = -1;
 6 |         int next = 0;
 7 |         while (next < nums.length) {
 8 |             if (nums[next] == 0) {
 9 |                 if (zero == -1) {
10 |                     zero = next;
11 |                 }
12 |             } else {
13 |                 if (zero >= 0) {
14 |                     nums[zero] = nums[next];
15 |                     nums[next] = 0;
16 |                     zero++;
17 |                 }
18 |             }
19 |             next++;
20 |         }
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/MoveZero.py:
--------------------------------------------------------------------------------
 1 | class Solution(object):
 2 |     def moveZeroes(self, nums):
 3 |         """
 4 |         :type nums: List[int]
 5 |         :rtype: None Do not return anything, modify nums in-place instead.
 6 |         """
 7 |         nonZero_count = 0
 8 | 
 9 |         for i in range(0, len(nums)):
10 |             if nums[i] is not 0:
11 |                 nums[nonZero_count] = nums[i]
12 |                 nonZero_count += 1
13 | 
14 |         for i in range(nonZero_count, len(nums)):
15 |             nums[i] = 0
16 |         return nums
17 | 
18 | nums = input("输入数字：")
19 | nums = [int(n) for n in nums.split()]
20 | a = Solution()
21 | print(a.moveZeroes(nums))


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/graceBaoXP/MoveZeros.java:
--------------------------------------------------------------------------------
 1 | package cn.grace.leetcode;
 2 | 
 3 | /**
 4 |  * 描述:
 5 |  * Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.
 6 |  * Input: [0,1,0,3,12]
 7 |  * Output: [1,3,12,0,0]
 8 |  */
 9 | public class MoveZeros {
10 |     public void moveZeroes(int[] nums) {
11 |         for (int i = 0; i < nums.length - 1; i++) {
12 |             for (int j = 1; j < nums.length - i; j++) {
13 |                 int temp = nums[j - 1];
14 |                 if (nums[j - 1] == 0) {
15 |                     nums[j - 1] = nums[j];
16 |                     nums[j] = temp;
17 |                 }
18 |             }
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/graceBaoXP/RemoveElement.java:
--------------------------------------------------------------------------------
 1 | package cn.grace.leetcode;
 2 | 
 3 | /**
 4 |  * Given an array nums and a value val, remove all instances of that value in-place and return the new length.
 5 |  * Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
 6 |  * The order of elements can be changed. It doesn't matter what you leave beyond the new length.
 7 |  *
 8 |  *
 9 |  */
10 | public class RemoveElement {
11 | 
12 |     public int removeElement(int[] nums, int val) {
13 |         int index=0;
14 |         for(int i=0;i<nums.length;i++){
15 |             if(nums[i]!=val){
16 |                 nums[index]=nums[i];
17 |                 index++;
18 |             }
19 |         }
20 |         return index;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/wuydit/RemoveElement.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.wuydit;
 2 | 
 3 | public class RemoveElement {
 4 |     public int removeElement(int[] nums, int val) {
 5 |         if(nums == null || nums.length == 0){
 6 |             return 0;
 7 |         }
 8 |         int begin = 0;
 9 |         int end = nums.length;
10 |         while (begin != end){
11 |             if( nums[begin] == val){
12 |                 nums[begin] = nums[end-1];
13 |                 end--;
14 |             }else {
15 |                 begin++;
16 |             }
17 |         }
18 | 
19 |         return begin;
20 |     }
21 | 
22 |     public static void main(String[] args) {
23 |         int[] nums = {3,2,2,3};
24 |         int val = 3;
25 |         System.out.println( new RemoveElement().removeElement(nums, val));
26 |     }
27 | 
28 | }
29 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/zwd/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.zwd;
 2 | 
 3 | import java.util.Arrays;
 4 | 
 5 | /**
 6 |  * Input: [0,1,0,3,12]
 7 |  * Output: [1,3,12,0,0]
 8 |  * <p>
 9 |  * 1. 原数组上操作，不拷贝
10 |  * 2. 尽量少的操作
11 |  */
12 | public class MoveZeroes {
13 |     public static void main(String[] args) {
14 |         int[] nums = {0, 1, 0, 3, 12};
15 |         moveZeroes(nums);
16 |         System.out.print(Arrays.toString(nums));
17 |     }
18 | 
19 |     private static void moveZeroes(int[] nums) {
20 |         int count = 0;//为0的个数
21 |         for (int i = 0; i < nums.length; i++) {
22 |             if (nums[i] != 0) {
23 |                 nums[count++] = nums[i];
24 |             }
25 |         }
26 |         for (int i = count; i < nums.length; i++) {
27 |             nums[i] = 0;
28 |         }
29 |     }
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/zhangqian0710/MoveZreos.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.zhangqian0710;
 2 | 
 3 | import java.util.Arrays;
 4 | 
 5 | /**
 6 |  * @author Miracle_Q
 7 |  * time：2019/5/29 12:51
 8 |  */
 9 | public class MoveZreos {
10 | 
11 |     public static void moveZeroes(int[] nums) {
12 |         int k = 0;
13 |         int len = nums.length;
14 |         for(int i=0;i<len;i++) {
15 |            if(nums[i] != 0) nums[k++]=nums[i];
16 |         }
17 |         for(int i=k;i<len;i++){
18 |             nums[i]=0;
19 |         }
20 | 
21 |         System.out.print(Arrays.toString(nums));
22 |     }
23 | 
24 | 
25 |     /**
26 |      * @param args
27 |      */
28 |     public static void main(String[] args) {
29 |         // TODO Auto-generated method stub
30 | 
31 |         int[] a = new int[] {0,0,1};
32 |         moveZeroes(a);
33 | 
34 | 
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/main/java/ValidParentheses/Aerdax/ValidParentheses.py:
--------------------------------------------------------------------------------
 1 | class Solution(object):
 2 |     def isValid(self, s):
 3 |         """
 4 |         :type s: str
 5 |         :rtype: bool
 6 |         """
 7 |         a=[]
 8 |         for i in s:
 9 |             if i == '(':
10 |                 a.append(i)
11 |             if i == ')':
12 |                 if len(a) == 0 or a.pop() != '(':
13 |                     return False
14 |             if i == '{':
15 |                 a.append(i)
16 |             if i =='}':
17 |                 if len(a) == 0 or a.pop() != '{':
18 |                     return False
19 |             if i == '[':
20 |                 a.append(i)
21 |             if i == ']':
22 |                 if len(a) == 0 or a.pop() != '[':
23 |                     return False
24 |         if len(a) > 0:
25 |             return False
26 |         return True


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/JiA1996/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | public class MoveZeroes {
 2 | 
 3 |     public static void moveZeroes(int[] nums) {
 4 | 
 5 |         int numOfNonZero = 0;
 6 | 
 7 |         for (int i = 0; i < nums.length; i++) {
 8 |             if (nums[i] != 0){
 9 |                 nums[numOfNonZero] = nums[i];
10 |                 numOfNonZero++;
11 |             }
12 |         }
13 | 
14 |         int numOfZero = nums.length - numOfNonZero;
15 | 
16 |         for (int j = numOfZero; j > 0 ; j--) {
17 |             nums[nums.length - j] = 0;
18 |         }
19 | 
20 | //        for (int k = 0; k < nums.length; k++) {
21 | //            System.out.println(nums[k]);
22 | //        }
23 |     }
24 | 
25 |     public static void main(String[] args) {
26 |         int[] intList = new int[]{0,1,0,3,12};
27 |         moveZeroes(intList);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/husterlantern1/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package com.liuxiang.leetcode;
 2 | 
 3 | /**
 4 |  * @Author: liux
 5 |  * @Date: 2019/5/29 17:12
 6 |  */
 7 | public class MoveZeroes {
 8 | 
 9 |     //    public static void main(String[] args) {
10 | //        int[] a ={0,0,1,2,3,4,1,0,3};
11 | //        moveZeroes(a);
12 | //          for(int i:a) {
13 | //             System.out.print(i+" ");
14 | //          }
15 | //    }
16 | //解题思路  不能新建数组，在原油数组上找出不等于0的元素一次放在数组的前面，等于0的数字放在数组的后面
17 |     public static void moveZeroes(int[] nums) {
18 |         int i=0,j=0;
19 |         while(i<nums.length){
20 |             if(nums[i]!=0) {
21 |                 nums[j++]=nums[i++];
22 |             }else {
23 |                 i++;
24 |             }
25 |         }
26 |         for(int k=j;k<nums.length;k++) {
27 |             nums[k]=0;
28 |         }
29 | 
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/fcbhank/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.fcbhank;
 2 | 
 3 | /**
 4 |  * Create by fcbhank on 2019/5/29
 5 |  * 283. Move Zeroes，时间复杂度O(n)
 6 |  * 解题思路：
 7 |  * 遍历数组，记录元素为0的个数为count。
 8 |  * 当前元素不为0时，其下标减去count即为数组去掉位于该元素前所有0后应处的位置，最后在末尾按count补全0。
 9 |  */
10 | public class MoveZeroes {
11 |     public void moveZeroes(int[] nums) {
12 |         int size = nums.length;
13 |         int count=0;
14 |         for (int i = 0; i < size; i++) {
15 |             if(nums[i]==0)
16 |                 count++;
17 |             else
18 |                 nums[i-count]=nums[i];
19 |         }
20 |         for(int i=size-count;i<size;i++)
21 |             nums[i]=0;
22 |     }
23 | }
24 | /*
25 | 结果：
26 | Runtime: 0 ms, faster than 100.00% of Java online submissions for Move Zeroes.
27 | Memory Usage: 35.6 MB, less than 99.98% of Java online submissions for Move Zeroes.
28 |  */
29 | 


--------------------------------------------------------------------------------
/src/main/java/GenerateParentheses/graceBaoXP/GenerateParentheses.java:
--------------------------------------------------------------------------------
 1 | package GenerateParentheses.graceBaoXP;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | 
 6 | /**
 7 |  * 全排列的题目，大部分用递归解决
 8 |  * 左右括号必须相等,先确定前缀，再递归
 9 |  */
10 | public class GenerateParentheses {
11 | 
12 |     public List<String> generateParenthesis(int n) {
13 |         List<String> list=new ArrayList<>();
14 |         String s="";
15 |         parenthesis((ArrayList<String>) list,s,n,n);
16 |         return list;
17 |     }
18 | 
19 |     public static void parenthesis(ArrayList<String> list,String s,Integer left,Integer right){
20 |         if(left==0&&right==0){
21 |             list.add(s);
22 |         }
23 |         if (left>0){
24 |             parenthesis(list,s+'(',left-1,right);
25 |         }
26 |         if (right>0&&left<right){
27 |             parenthesis(list,s+')',left,right-1);
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/JiA1996/removeElement/removeElement.java:
--------------------------------------------------------------------------------
 1 | package com.JiA1996.removeElement;
 2 | 
 3 | public class removeElement {
 4 | 
 5 |     public static int Solution(int[] nums, int val){
 6 |         int numOfNonVal = 0; //numbers of elements that are not equal to val
 7 |         for (int i = 0; i < nums.length; i++) {
 8 |             if (nums[i] != val){
 9 |                 nums[numOfNonVal] = nums[i];
10 |                 numOfNonVal += 1;
11 |             }
12 |         }
13 | //
14 | //        for (int j = 0; j < nums.length; j++) {
15 | //            System.out.println(nums[j]);
16 | //        }
17 | 
18 |         return numOfNonVal;
19 |     }
20 | 
21 |     public static void main(String[] args){
22 |         int[] intlist = new int[]{0,1,2,2,3,0,4,2};
23 |         int val = 2;
24 |         int answer = Solution(intlist, val);
25 |         System.out.println(answer);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/Zntao/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.Zntao;
 2 | 
 3 | /**
 4 |  * Created by Zntao
 5 |  */
 6 | public class MoveZeroes {
 7 |     // 通过一个变量维护前面非0的数组下标，新遍历到非零数据时与最前一个0兑换。（类似插入排序的思路）
 8 |     public static void moveZeroes(int[] nums) {
 9 | 
10 |         int length = nums.length;
11 |         int seq = 0;
12 |         for(int i = 0; i< length; i++){
13 |             if(nums[i] != 0){
14 |                 int temp = nums[i];
15 |                 nums[i] = 0;
16 |                 nums[seq] = temp;
17 |                 seq++;
18 |             }
19 | 
20 |         }
21 | 
22 |     }
23 | 
24 |     public static void main(String[] args) {
25 |         int a[] = {0,1,0,3,12};
26 |         moveZeroes(a);
27 |         /*
28 |         Runtime: 0 ms, faster than 100.00% of Java online submissions for Move Zeroes.
29 |         Memory Usage: 36.6 MB, less than 99.75% of Java online submissions for Move Zeroes.
30 |         */
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/weichong0325/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.weichong0325;
 2 | /**
 3 |  * Create by weichong0325 on 2019/5/30
 4 |  * 解题思路：
 5 |  * 遍历数组，记录元素为0的个数为count。
 6 |  * 当前元素不为0时，其下标减去count即为数组去掉位于该元素前所有0后应处的位置，最后在末尾按count补全0。
 7 |  */
 8 | public class MoveZeroes {
 9 |     public static void moveZeroes(int[] nums) {
10 |         int count=0;
11 |         for (int i = 0; i < nums.length; i++) {
12 |             if(nums[i]==0){
13 |                 count++;
14 |             } else{
15 |                 nums[i-count]=nums[i];
16 |             }
17 |         }
18 |         for(int i=nums.length-count;i<nums.length;i++){
19 |             nums[i]=0;
20 |         }
21 |     }
22 |     public static void main(String[] args) {
23 |         int[] intList = new int[]{0,1,0,3,12};
24 |         moveZeroes(intList);
25 |     }
26 | }
27 | /*
28 | 执行用时 : 1 ms, 在Move Zeroes的Java提交中击败了97.64% 的用户
29 | 内存消耗 : 36.9 MB, 在Move Zeroes的Java提交中击败了96.14% 的用户
30 |  */


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/zhanweta/MoveZeros.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.zhanweta;
 2 | /*
 3 | Runtime: 0 ms, faster than 100.00% of Java online submissions for Move Zeroes.
 4 | Memory Usage: 37.7 MB, less than 99.61% of Java online submissions for Move Zeroes.
 5 |  */
 6 | public class MoveZeros {
 7 |     public static void  main(String [] args){
 8 |         //测试用
 9 |         int [] nums = {2,1};
10 |         moveZeros(nums);
11 |     }
12 |     public static  void moveZeros(int [] nums){
13 |         int posOfNoZero = 0;
14 |         int len = nums.length;
15 |         for(int i = 0 ; i < len ; i++){
16 |             if(nums[i] != 0){
17 |                 if(i > posOfNoZero) {
18 |                     nums[posOfNoZero++] = nums[i];
19 |                     nums[i] = 0;
20 |                 }else
21 |                     posOfNoZero++;
22 |             }
23 |         }
24 |         for(int num : nums)
25 |             System.out.print(num);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/main/java/ValidParenthesisString/AzusaMutan/ValidParenthesisString.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |             public boolean checkValidString(String s) {
 3 |                 int n1 = 0;
 4 |                 int n2 = 0;
 5 |                 for (int i = 0; i < s.length(); i++) {
 6 |                     if (s.charAt(i) == '(' || s.charAt(i) == '*') n1++;
 7 |                     else n1--;
 8 |                     if (n1 < 0) return false;
 9 |                 }
10 | 
11 |                 if (n1 == 0) return true;
12 |                 else {
13 |                     for (int i = s.length() - 1; i >= 0; i--) {
14 |                         if (s.charAt(i) == ')' || s.charAt(i) == '*') n2++;
15 |                         else n2--;
16 |                         if (n2 < 0) return false;
17 |                     }
18 | 
19 |                     if (n2 >= 0) return true;
20 |                     else return false;
21 |                 }
22 |             }
23 |         }
24 | 


--------------------------------------------------------------------------------
/src/main/java/GenerateParentheses/Mnting/22.GenerateParentheses.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * @lc app=leetcode.cn id=22 lang=java
 3 |  * backtracking
 4 |  * 递归函数的开头写好跳出条件，满足条件才将当前结果加入总结果中
 5 |  * 已经拿过的数不再拿 if(s.contains(num)){continue;}
 6 |  * 遍历过当前节点后，为了回溯到上一步，要去掉已经加入到结果list中 * 的当前节点
 7 |  * [22] 括号生成
 8 |  */
 9 | import java.util.*;
10 | class Solution {
11 |     public List<String> generateParenthesis(int n) {
12 |         List<String> list = new ArrayList<String>();
13 |         backtracking(list, 0, 0, "",n);
14 |         return list;
15 |     }
16 |     public void backtracking(List<String> list,int open,int close,String str,int n){
17 |         if(str.length()==2*n){
18 |             list.add(str);
19 |             return;
20 |         }
21 |         if(open<n){
22 |             backtracking(list, open+1, close, str+"(", n);
23 |         }
24 |         if(close<open){
25 |             backtracking(list, open, close+1, str+")", n);
26 |         }
27 |     }
28 | }
29 | 
30 | 


--------------------------------------------------------------------------------
/src/main/java/ValidParentheses/AzusaMutan/ValidParentheses:
--------------------------------------------------------------------------------
 1 | import java.util.Stack;
 2 | 
 3 | class Solution {
 4 |     public boolean isValid(String s) {
 5 |         Stack<Character> stack = new Stack<>();
 6 |         for (int i = 0; i < s.length(); i++) {
 7 |             if (s.charAt(i) == '(') stack.push('(');
 8 |             else if (s.charAt(i) == '[') stack.push('[');
 9 |             else if (s.charAt(i) == '{') stack.push('{');
10 |             else if (s.charAt(i) == ')') {
11 |                 if (stack.isEmpty() || stack.pop() != '(') return false;
12 |             }
13 |             else if (s.charAt(i) == ']') {
14 |                 if (stack.isEmpty() || stack.pop() != '[') return false;
15 |             }
16 |             else if (s.charAt(i) == '}') {
17 |                 if (stack.isEmpty() || stack.pop() != '{') return false;
18 |             }
19 |         }
20 |         if (stack.isEmpty()) return true;
21 |         else return false;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/main/java/GenerateParentheses/code drinker/AzusaMutan/GenerateParenthesis:
--------------------------------------------------------------------------------
 1 | import java.util.ArrayList;
 2 | import java.util.List;
 3 | 
 4 | class Solution {
 5 |     public List<String> generateParenthesis(int n) {
 6 |         List<String> ans = new ArrayList<>();
 7 |         StringBuilder sb = new StringBuilder("(");
 8 |         return f(ans,sb,n,1,0);
 9 |     }
10 | 
11 |     public List<String> f (List<String> ans,StringBuilder sb, int n, int leftN, int rightN) {
12 |         if (leftN == n && rightN == n) {
13 |             ans.add(sb.toString());
14 |         }
15 |         if (leftN <= n && rightN != n) {
16 |             sb.append("(");
17 |             f(ans,sb,n,leftN+1,rightN);
18 |             sb.deleteCharAt(sb.length()-1);
19 |             if (leftN > rightN) {
20 |                 sb.append(")");
21 |                 f(ans,sb,n,leftN,rightN+1);
22 |                 sb.deleteCharAt(sb.length()-1);
23 |             }
24 |         }
25 | 
26 |         return ans;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/zhangkaijian123/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.zhangkaijian123;
 2 | 
 3 | /**
 4 |  * @author 张铠建
 5 |  * @description
 6 |  * 题目:给定一个数组num，编写一个函数将所有0移动到它的末尾，同时保持非零元素的相对顺序。
 7 |  * 解题思路:记录第一个0的位置，与后边非零元素交换位置,cur为数组最左边的0的下标
 8 |  * @createdate 2019-05-29 09:13
 9 |  **/
10 | public class MoveZeroes {
11 |     public void MoveZeros(int[] nums){
12 |         for (int i = 0,cur = 0;i < nums.length;i++){
13 |             if (nums[i] != 0){
14 |                 int temp = nums[i];
15 |                 nums[i] = nums[cur];
16 |                 nums[cur++] = temp;
17 |             }
18 |         }
19 |     }
20 |     //先将非零的元素移到前边，再把剩下的元素置为0
21 |     public void MoveZeros1(int[] nums){
22 |         int temp=0;
23 |         for (int i =0;i<nums.length;i++){
24 |             if (nums[i]!=0){
25 |                 nums[temp++]=nums[i];
26 |             }
27 |         }
28 |         for (int j = temp;j<nums.length;j++){
29 |             nums[temp]=0;
30 |         }
31 |     }
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/yuhangtdm/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.yuhangtdm;
 2 | 
 3 | 
 4 | /**
 5 |  * @author:yuhang
 6 |  * @Date:2019/5/29
 7 |  * 题目 将一个数组中的0往后移动,非0的其他元素保证原先的顺序 不可借用其他数组或者集合
 8 |  * 解题思路 将非0的元素往前移动
 9 |  * 如原先数组 10 0 3 0 1
10 |  * 移动第一次 10 0 3 0 1
11 |  * 移动第二次 10 3 0 0 1
12 |  * 移动第三次 10 3 1 0 0
13 |  * 可见就是把非0元素和下标从0开始依次递增的数交换位置
14 |  */
15 | public class MoveZeroes {
16 | 
17 |     public static void moveZeroes(Integer[] nums){
18 |         for (int i=0,cur=0; i< nums.length; i++){
19 |             if (nums[i] != 0){
20 |                 int tmp = nums[i];
21 |                 nums[i] = nums[cur];
22 |                 nums[cur] = tmp;
23 |                 cur++;
24 |             }
25 |         }
26 |     }
27 | 
28 |     public static void main(String[] args) {
29 |         // 0 0 1
30 |         // 1 0 0
31 |         Integer[] nums = new Integer[]{0,1,0,3,12};
32 |         moveZeroes(nums);
33 |         for (Integer integer : nums) {
34 |             System.out.print(integer+"\t");
35 |         }
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/zhangzhongjun/ArrayTest.java:
--------------------------------------------------------------------------------
 1 | import java.util.Arrays;
 2 | 
 3 | public class ArrayTest {
 4 |     public void moveZeroes(int[] nums) {
 5 |         int i = 0, j = 0;
 6 |         while (j < nums.length) {
 7 |             if (nums[j] == 0) {
 8 | 
 9 |             } else {
10 |                 nums[i] = nums[j];
11 |                 i++;
12 |             }
13 |             j++;
14 |         }
15 |         while (i < nums.length) {
16 |             nums[i]=0;
17 |             i++;
18 |         }
19 |     }
20 |     public static void main(String[] args) {
21 |         int[] nums = {0, 1, 0, 3, 12};
22 |         int i = 0, j = 0;
23 |         while (j < nums.length) {
24 |             if (nums[j] == 0) {
25 | 
26 |             } else {
27 |                 nums[i] = nums[j];
28 |                 i++;
29 |             }
30 |             j++;
31 |         }
32 |         while (i < nums.length) {
33 |             nums[i]=0;
34 |             i++;
35 |         }
36 |         System.out.println(Arrays.toString(nums));
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/main/java/GenerateParentheses/AzusaMutan/GenerateParentheses:
--------------------------------------------------------------------------------
 1 | import java.util.ArrayList;
 2 | import java.util.List;
 3 | 
 4 | class Solution {
 5 |         public List<String> generateParenthesis(int n) {
 6 |             List<String> ans = new ArrayList<>();
 7 |             StringBuilder sb = new StringBuilder("(");
 8 |             return f(ans,sb,n,1,0);
 9 |         }
10 | 
11 |         public List<String> f (List<String> ans,StringBuilder sb, int n, int leftN, int rightN) {
12 |             if (leftN == n && rightN == n) {
13 |                 ans.add(sb.toString());
14 |             }
15 |             if (leftN <= n && rightN != n) {
16 |                 sb.append("(");
17 |                 f(ans,sb,n,leftN+1,rightN);
18 |                 sb.deleteCharAt(sb.length()-1);
19 |                 if (leftN > rightN) {
20 |                     sb.append(")");
21 |                     f(ans,sb,n,leftN,rightN+1);
22 |                     sb.deleteCharAt(sb.length()-1);
23 |                 }
24 |             }
25 | 
26 |             return ans;
27 |         }
28 |     }
29 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/Zntao/RemoveElement.java:
--------------------------------------------------------------------------------
 1 | package RemoveElement.Zntao;
 2 | 
 3 | /**
 4 |  * Created by Zntao
 5 |  */
 6 | public class RemoveElement {
 7 |     //  与昨天题目思路类似，将0替换成val
 8 |     public static int removeElement(int[] nums, int val) {
 9 | 
10 |         int length = 0;
11 |         int seq = 0;
12 |         for(int i = 0;i < nums.length; i++){
13 |             if(nums[i] != val){
14 |                 int tem = nums[i];
15 |                 nums[i] = val;
16 |                 nums[seq] = tem;
17 |                 seq++;
18 |                 length++;
19 |             }
20 |         }
21 | 
22 |         return length;
23 | 
24 |     }
25 | 
26 |     public static void main(String[] args) {
27 | 
28 |         int a[] = {3,2,2,3};
29 |         int length = removeElement(a, 3);
30 |         System.out.println(length);
31 |         /*
32 |         * Runtime: 0 ms, faster than 100.00% of Java online submissions for Remove Element.
33 |           Memory Usage: 34.3 MB, less than 100.00% of Java online submissions for Remove Element.
34 |         * */
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/beau0303/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.beau0303;
 2 | 
 3 | /**
 4 |  * Created by IntelliJ IDEA.
 5 |  * Author:MeiFan
 6 |  * Date: 2019/5/29 15:37
 7 |  * e-mail:codemeifan@gmail.com.
 8 |  */
 9 | public class MoveZeroes {
10 |     public static void moveZeroes(int[] a) {
11 |         if (a.length == 1)
12 |             return;
13 |         for (int cur = 0, i = cur; i < a.length; cur++, i++) {
14 |             if (0 == a[cur]) { //cur定位到第一个0的位置，i去寻找后面第一个非0的值替换过来
15 |                 while (i < a.length && a[i] == 0) {
16 |                     i++;
17 |                 }
18 |                 if (i >= a.length)//判断是否被越界 如果越界 说明后面没有非0元素 直接返回
19 |                     break;
20 |                 swap(a, i, cur);
21 |             }
22 |         }
23 |     }
24 | 
25 |     public static void swap(int a[], int i, int j) {
26 |         a[i] = a[i] ^ a[j];
27 |         a[j] = a[j] ^ a[i];
28 |         a[i] = a[i] ^ a[j];
29 |     }
30 | 
31 |     public static void main(String[] args) {
32 |         int[] a = new int[]{1, 3, 0, 5, 0};
33 |         moveZeroes(a);
34 |         for (int i = 0; i < a.length; i++) {
35 |             System.out.print(a[i] + " ");
36 |         }
37 |     }
38 | 
39 | }
40 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/ZHANGJIKAI5/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package com.its.leet.code.leetcode.MoveZeroes;
 2 | 
 3 | 
 4 | /**
 5 |  * author：ZHANGJIKAI5
 6 |  * 解题思路：遍历数组，判断到当前下标i的元素不为空时，代表需要与nums[j]交换位置，交换后，j++
 7 |  * 此处本来想使用异或交换元素，从而少创建一个中间变量。
 8 |  * 但两个相同值异或三重异或后会变成0，只能加一重判断，导致内存使用率没有降下来。
 9 |  */
10 | public class MoveZeroes {
11 | 
12 | 
13 |     /**
14 |      * 执行用时 : 1 ms, 在Move Zeroes的Java提交中击败了97.69% 的用户
15 |      * 内存消耗 : 39.2 MB, 在Move Zeroes的Java提交中击败了86.28% 的用户
16 |      * @param nums
17 |      */
18 |     public void moveZeroes(int[] nums) {
19 |         for (int i=0, j=0; i<nums.length; i++) {
20 |                 if (nums[i] != 0) {
21 |                     if (nums[i] != nums[j]) {
22 |                         nums[i] = nums[i] ^ nums[j];
23 |                         nums[j] = nums[i] ^ nums[j];
24 |                         nums[i] = nums[i] ^ nums[j];
25 |                     }
26 |                     j++;
27 |                 }
28 |         }
29 |     }
30 | 
31 |     public static void main(String[] args) {
32 |        MoveZeroes moveZeroes = new MoveZeroes();
33 |         int[] input = { 2,1 };
34 |         moveZeroes.moveZeroes(input);
35 |         for (int i: input
36 |         ) {
37 |             System.out.println(i);
38 |         }
39 | 
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/main/java/ValidParentheses/AzusaMutan/graceBaoXP/ValidParentheses.java:
--------------------------------------------------------------------------------
 1 | package ValidParentheses.AzusaMutan.graceBaoXP;
 2 | 
 3 | 
 4 | import java.util.Stack;
 5 | 
 6 | public class ValidParentheses {
 7 | 
 8 |     public boolean checkValidString(String s) {
 9 |         Stack<Character> stack = new Stack<>();
10 |         for (int i = 0; i < s.length(); i++) {
11 |             if (s.charAt(i) == '(') {
12 |                 stack.push('(');
13 |             } else if (s.charAt(i) == '[') {
14 |                 stack.push('[');
15 |             } else if (s.charAt(i) == '{') {
16 |                 stack.push('{');
17 |             } else if (s.charAt(i) == ')') {
18 |                 if (stack.isEmpty() || stack.pop() != '(') {
19 |                     return false;
20 |                 }
21 |             } else if (s.charAt(i) == ']') {
22 |                 if (stack.isEmpty() || stack.pop() != '[') {
23 |                     return false;
24 |                 }
25 |             } else if (s.charAt(i) == '}') {
26 |                 if (stack.isEmpty() || stack.pop() != '{') {
27 |                     return false;
28 |                 }
29 |             }
30 |         }
31 |         if (stack.isEmpty()) {
32 |             return true;
33 |         }else{
34 |             return false;
35 |         }
36 | 
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/main/java/ValidParentheses/beau0303/Solution.java:
--------------------------------------------------------------------------------
 1 | package ValidParentheses.beau0303;
 2 | 
 3 | import java.util.Stack;
 4 | 
 5 | /**
 6 |  * Created by IntelliJ IDEA.
 7 |  * Author:MeiFan
 8 |  * Date: 2019/6/6 8:00
 9 |  * e-mail:codemeifan@gmail.com.
10 |  */
11 | public class Solution {
12 |     public static boolean isValid(String s) {
13 |         char[] chars = s.toCharArray();
14 |         Stack<Character> stack = new Stack();
15 |         for (int i = 0; i < chars.length; i++) {
16 |             if (chars[i] == '(' || chars[i] == '[' || chars[i] == '{')
17 |                 stack.push(chars[i]);
18 |             else if(stack.isEmpty())
19 |                 return false;
20 |             else if(isMatch(stack.peek(),chars[i]))
21 |                 stack.pop();
22 |             else return false;
23 | 
24 |         }
25 |         return stack.isEmpty();
26 |     }
27 | 
28 |     public static boolean isMatch(char c1, char c2) {
29 |         if (c1 == '(' && c2 == ')')
30 |             return true;
31 |         else if (c1 == '[' && c2 == ']')
32 |             return true;
33 |         else if (c1 == '{' && c2 == '}')
34 |             return true;
35 |         else return false;
36 |     }
37 | 
38 |     public static void main(String[] args) {
39 | 
40 | 
41 |         boolean valid = isValid("()()()()");
42 |         System.out.println(valid);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/wangyuhuich/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.wangyuhuich;
 2 | 
 3 | /**
 4 |  * 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
 5 |  * <p>
 6 |  * 示例:
 7 |  * <p>
 8 |  * 输入: [0,1,0,3,12]
 9 |  * 输出: [1,3,12,0,0]
10 |  * 说明:
11 |  * <p>
12 |  * 必须在原数组上操作，不能拷贝额外的数组。
13 |  * 尽量减少操作次数。
14 |  */
15 | 
16 | /**
17 |  * 解题思路:类似冒泡,数字0 上浮
18 |  */
19 | 
20 | 
21 | public class MoveZeroes {
22 |     /**
23 |      * 执行用时 : 1 ms, 在Move Zeroes的Java提交中击败了97.69% 的用户
24 |      * 内存消耗 : 39.9 MB, 在Move Zeroes的Java提交中击败了72.80% 的用户
25 |      */
26 |     public void moveZeroes(int[] nums) {
27 |         int zeroCount = 0;
28 |         int notZeroPosition = 0;
29 |         for (int i = 0; i < nums.length; i++) {
30 |             if(nums[i]==0){
31 |                 zeroCount+=1;
32 |             }else{
33 |                 nums[notZeroPosition++] = nums[i];
34 |             }
35 |         }
36 |         for (int i = notZeroPosition,j = 0; j < zeroCount; i++,j++) {
37 |             nums[i] = 0;
38 |         }
39 |     }
40 | 
41 |     /**
42 |      * 执行用时 : 122 ms, 在Move Zeroes的Java提交中击败了5.07% 的用户
43 |      * 内存消耗 : 40.6 MB, 在Move Zeroes的Java提交中击败了54.19% 的用户
44 |      */
45 | //    @Deprecated
46 | //    public void moveZeroes(int[] nums) {
47 | //        for (int i = 0; i < nums.length; i++) {
48 | //            for (int j = 0; j < nums.length-i-1; j++) {
49 | //                if (nums[j] == 0 && nums[j + 1] != 0) {
50 | //                    nums[j] = nums[j + 1] + (nums[j + 1] = nums[j]) - nums[j];
51 | //                }
52 | //            }
53 | //        }
54 | //    }
55 | }


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/zhangkaijian123/RemoveElement.java:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @author 张铠建
 3 |  * @description Runtime: 0 ms, faster than 100.00% of Java online submissions for Remove Element.
 4 |  * Memory Usage: 34.3 MB, less than 100.00% of Java online submissions for Remove Element.
 5 |  * @createdate 2019-05-30 10:05
 6 |  **/
 7 | public class RemoveElement {
 8 |     //将nums中的val元素全部移动到数组的最后，count记录val出现的次数，nums.length-count就是去掉val后数组的长度
 9 |     public static int removeElement(int[] nums, int val) {
10 |         int count = 0;
11 |         for (int i = 0;i<nums.length;i++){
12 |             if (nums[i] == val){
13 |                 count++;
14 |             }
15 |         }
16 |         for (int j = 0,cur = 0;j<nums.length;j++){
17 |             if (nums[j] != val){
18 |                 int temp = nums[j];
19 |                 nums[j] = nums[cur];
20 |                 nums[cur++] = temp;
21 |             }
22 |         }
23 |         int index = nums.length - count;
24 |         return index;
25 |     }
26 |     //count为去掉val后数组的长度，将val换到数组的最后
27 |     public int removeElement1(int[] nums, int val) {
28 |         int count = 0;
29 |         for (int i = 0;i<nums.length;i++){
30 |             if (nums[i] != val){
31 |                 nums[count++]=nums[i];
32 |             }
33 |         }
34 |         return count;
35 |     }
36 |     public static void main(String[] args) {
37 |         int[] nums = new int[]{2,3,3,2};
38 |         int index = removeElement(nums,2);
39 |         for (int i = 0;i<index;i++){
40 |             System.out.print(nums[i]);
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/main/java/MoveZeroes/eistert/MoveZeroes.java:
--------------------------------------------------------------------------------
 1 | package MoveZeroes.eistert;
 2 | 
 3 | /**
 4 |  * Created by eistert on 2019/06/01.
 5 |  */
 6 | public class MoveZeroes {
 7 | 	/**
 8 | 	 * Example:
 9 | 	 * 
10 | 	 * Input: [0,1,0,3,12] Output: [1,3,12,0,0]
11 | 	 * 
12 | 	 * @param nums
13 | 	 */
14 | 	public static int[] moveZeroes(int nums[]) {
15 | 		for (int i = 0, curr = 0; i < nums.length; i++) {
16 | 			if (nums[i] != 0) {
17 | 				int swap = nums[i];
18 | 				nums[i] = nums[curr];
19 | 				nums[curr++] = swap;
20 | 			}
21 | 
22 | 		}
23 | 		return nums;
24 | 	}
25 | 
26 | 	/**
27 | 	 * 解题思路：当元素值等于0时，依次遍历和next元素交换值，把0交换到最后。
28 | 	 * @param nums
29 | 	 * @return
30 | 	 */
31 | 	public static int[] moveZeroes2(int nums[]) {
32 | 
33 | 		for (int curr = 0; curr < nums.length; curr++) {
34 | 			int next = curr + 1;
35 | 			if (nums[curr] == 0) {
36 | 
37 | 				for (int i = curr; i < nums.length - 1; i++, next++) {
38 | 					int swap1 = nums[next];
39 | 					int swap2 = nums[i];
40 | 
41 | 					nums[i] = swap1;
42 | 					nums[next] = swap2;
43 | 				}
44 | 			}
45 | 			next = 0;
46 | 		}
47 | 		int time = 0;
48 | 		boolean flag = false;
49 | 		for (int i = 0; i < nums.length; i++) {
50 | 			if (nums[i] == 0) {
51 | 				time++;
52 | 			}
53 | 		}
54 | 		for (int i = 0; i < nums.length - time; i++) {
55 | 			if (nums[i] == 0) {
56 | 				flag = true;
57 | 			}
58 | 		}
59 | 
60 | 		if (nums.length > 2 && nums[nums.length - 1] == 0 && flag) {
61 | 			moveZeroes2(nums);
62 | 		}
63 | 		return nums;
64 | 
65 | 	}
66 | 
67 | 	public static void main(String[] args) {
68 | 		int[] nums = { 0, 1, 0, 3, 12 };
69 | //		moveZeroes(nums);
70 | 		moveZeroes2(nums);
71 | 		for (int i = 0; i < nums.length; i++) {
72 | 			System.out.println(nums[i]);
73 | 		}
74 | 	}
75 | 
76 | }
77 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/readme.md:
--------------------------------------------------------------------------------
 1 | ## 描述
 2 | Given an array nums and a value val, remove all instances of that value in-place and return the new length.
 3 | 
 4 | Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
 5 | 
 6 | The order of elements can be changed. It doesn't matter what you leave beyond the new length.
 7 | 
 8 | ### Example 1:
 9 | 
10 | ```
11 | Given nums = [3,2,2,3], val = 3,
12 | 
13 | Your function should return length = 2, with the first two elements of nums being 2.
14 | 
15 | It doesn't matter what you leave beyond the returned length.
16 | ```
17 | ### Example 2:
18 | 
19 | ```
20 | Given nums = [0,1,2,2,3,0,4,2], val = 2,
21 | 
22 | Your function should return length = 5, with the first five elements of nums containing 0, 1, 3, 0, and 4.
23 | 
24 | Note that the order of those five elements can be arbitrary.
25 | 
26 | It doesn't matter what values are set beyond the returned length.
27 | ```
28 | ### Clarification:
29 | 
30 | Confused why the returned value is an integer but your answer is an array?
31 | 
32 | Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.
33 | 
34 | Internally you can think of this:
35 | ```
36 | 
37 | // nums is passed in by reference. (i.e., without making a copy)
38 | int len = removeElement(nums, val);
39 | 
40 | // any modification to nums in your function would be known by the caller.
41 | // using the length returned by your function, it prints the first len elements.
42 | for (int i = 0; i < len; i++) {
43 |     print(nums[i]);
44 | }
45 | 
46 | ```
47 | 
48 | ## 备注
49 | 看清题目 O(1) 的空间复杂度要求
50 | 
51 | 
52 | ## 地址
53 | https://leetcode.com/problems/remove-element/


--------------------------------------------------------------------------------
/src/main/java/ValidParentheses/AzusaMutan/zhanweta/ValidParentheses.java:
--------------------------------------------------------------------------------
 1 | package ValidParentheses.AzusaMutan.zhanweta;
 2 | 
 3 | //  '(', ')', '{', '}', '[' and ']'
 4 | 
 5 | import java.util.ArrayList;
 6 | import java.util.List;
 7 | 
 8 | public class ValidParentheses {
 9 |     public static void main(String [] args){
10 |         String s =
11 |                 "{[]}";
12 |         System.out.println(isValid(s));
13 |     }
14 |     public static boolean isValid(String s){
15 |         
16 |         List<Character> chars = new ArrayList<Character>();    //栈
17 |         int len = s.length();    //s长度
18 | //        chars.add(s.charAt(0));
19 |         
20 |          //将s的前半部分去重部分放入一个栈中
21 |         for(int i = 0 ; i < len ; i ++ ){
22 |             //chars长度为0，则直接添加
23 |             if(chars.size() == 0)
24 |                 chars.add(s.charAt(i));
25 |             
26 |             //chars长度不为0且与栈顶数据不等，入栈
27 |             else {
28 |                 switch (s.charAt(i)){
29 |                     case ')':{
30 |                         if(chars.get(chars.size()-1) == '(')
31 |                             chars.remove(chars.size() - 1);
32 |                         else
33 |                             chars.add(s.charAt(i));
34 |                         break;
35 |                     }
36 |                     case '}':{
37 |                         if(chars.get(chars.size()-1) == '{')
38 |                             chars.remove(chars.size() - 1);
39 |                         else
40 |                             chars.add(s.charAt(i));
41 |                         break;
42 | 
43 |                     }
44 |                     case ']':{
45 |                         if(chars.get(chars.size()-1) == '[')
46 |                             chars.remove(chars.size() - 1);
47 |                         else
48 |                             chars.add(s.charAt(i));
49 |                         break;
50 |                     }
51 |                     default:
52 |                         chars.add(s.charAt(i));
53 |                         break;
54 |                 }
55 |             }
56 | 
57 |         }
58 | 
59 |         return chars.size() == 0;
60 |         
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/main/java/ValidParenthesisString/AzusaMutan/zhanweta/ValidParenthesisString.java:
--------------------------------------------------------------------------------
 1 | package ValidParenthesisString.AzusaMutan.zhanweta;
 2 | 
 3 | import java.util.ArrayList;
 4 | import java.util.List;
 5 | 
 6 | public class ValidParenthesisString {
 7 |     public static void main(String [] args){
 8 |         String s =
 9 |                 "((*)))";    // ((*))*)
10 |         System.out.println(checkValidString(s));
11 |     }
12 |     public static boolean checkValidString(String s) {
13 |         List<Character> chars = new ArrayList<Character>();   //栈_(
14 |         int len = s.length();    //s长度
15 |         //""->true
16 |         if(s.equals(""))
17 |             return true;
18 |         else{
19 |             //将s的前半部分去重部分放入一个栈中
20 |             for(int i = 0 ; i < len ; i ++ ){
21 |                 //chars长度不为0且与栈顶数据不等，入栈
22 |                     switch (s.charAt(i)){
23 |                         case ')':{
24 |                             if(chars.size() == 0 )
25 |                                 return false;
26 |                             else if(chars.get(chars.size() - 1) == '*'){
27 |                                 int lenC = chars.size();
28 |                                 for(int j = lenC-2 ; j >= 0; j--){
29 |                                     if(chars.get(j) == '(' ){
30 |                                         chars.remove(j);
31 |                                         break;
32 |                                     }
33 |                                 }
34 |                                 if(lenC == chars.size()) {
35 |                                     chars.remove(chars.size() - 1);
36 |                                 }
37 |                             }else {
38 |                                 chars.remove(chars.size() - 1);
39 | 
40 |                             }
41 |                             break;
42 |                         }
43 |                         case '*':{
44 |                             chars.add('*');
45 | 
46 |                             break;
47 |                         }
48 |                         default:
49 |                             chars.add('(');
50 | 
51 |                             break;
52 |                     }
53 |                 }
54 | 
55 |             }
56 | 
57 |             //二次处理
58 |         int lenS = chars.size();
59 |         int pos = 0;
60 |         for(int j = 0 ; j < lenS ; j ++){
61 |             if(chars.get(j) == '(')
62 |                 pos++;
63 |             else if(pos > 0 && chars.get(j) == '*'){
64 |                 pos --;
65 |             }
66 |         }
67 | 
68 |             return pos == 0;
69 |         }
70 | 
71 | }
72 | 


--------------------------------------------------------------------------------
/src/main/java/RemoveElement/playwithfun1995/RemoveElement.java:
--------------------------------------------------------------------------------
 1 | package RemoveElement.playwithfun1995;
 2 | 
 3 | 
 4 | import java.util.Arrays;
 5 | 
 6 | /**
 7 |  * Created by moon-wind on 2019/5/30.
 8 |  * 将非val数据移动到数组前方 统计非val个数
 9 |  */
10 | public class RemoveElement {
11 | 
12 |     public static void main(String[] args) {
13 |         RemoveElement removeElement = new RemoveElement();
14 | 
15 |         int[] nums = new int[8];
16 |         int val ;
17 |         int result = -1;
18 | 
19 |         long start = System.currentTimeMillis();
20 |         for(int i = 100000 ; i>0 ; i--){
21 | 
22 |             nums = new int[]{3, 1, 3, 3, 4, 3, 3, 3,2,3,3};
23 |             val = 3;
24 |             result = removeElement.removeElement2(nums, val);
25 | //            System.out.print(i);
26 |         }
27 |         long end = System.currentTimeMillis();
28 | 
29 |         System.out.println("\ntime" + (end - start));
30 |         System.out.println("\nend" + end);
31 |         System.out.println("\nstart" + start);
32 | 
33 |         System.out.println(result);
34 | 
35 |         String s = Arrays.toString(nums);
36 |         System.out.println(s);
37 | 
38 |     }
39 | 
40 | 
41 |     /**
42 |      * a few seconds ago	Accepted	0 ms	34.5 MB	java
43 |      * 思路：前面的指针用来遍历数组 ， 找到和val值相同的元素
44 |      *      后面的指针用来把后面的非val数依次（依次指和前置指针一一对应）挪到前指针指到的val处
45 |      * @param nums
46 |      * @param val
47 |      * @return
48 |      */
49 | 
50 |     public int removeElement(int[] nums, int val) {
51 |         int invertedIndex = nums.length - 1;
52 |         for(int i = 0 ; i <= invertedIndex ; i++){   // 这里要等于invertedIndex ，当i=invertedIndex且nums[i]==val时 ,invertedIndex需要指向下一个位置 以便在末尾同一加一
53 |             // 正序找到下一个val数据
54 |             if(nums[i] == val){
55 |                 // 倒序找到下一个非val数据
56 |                 while(nums[invertedIndex] == val && invertedIndex>i){
57 |                     invertedIndex --;
58 |                 }
59 | 
60 |                 // 将invertedIndex处的非val值赋值到i处
61 |                 nums[i] = nums[invertedIndex];
62 |                 invertedIndex --; // 移动到下一个位置
63 | 
64 |             }
65 |         }
66 | 
67 | 
68 |         return invertedIndex + 1;
69 |     }
70 | 
71 |     /**
72 |      * an hour ago	Accepted	0 ms	34.2 MB	java
73 |      * 思路 count(非val) = index - count(val)
74 |      * @param nums
75 |      * @param val
76 |      * @return
77 |      */
78 |     public int removeElement2(int[] nums, int val) {
79 |         int index = 0;
80 |         int count = 0;   // 统计val个数
81 |         while (index < nums.length) {
82 |             if (nums[index] == val) {
83 |                 count += 1;
84 |             } else {
85 |                 // 遇到非val数据 将其移动到index-count处 因为 count(非val) = index - count(val)
86 |                 nums[index - count] = nums[index];
87 |             }
88 |             index += 1;
89 |         }
90 |         return index - count;
91 |     }
92 | }
93 | 
94 | 


--------------------------------------------------------------------------------