# Leetcode question brushing diary (with code and link)

Tip: after the article is written, the directory can be generated automatically. Please refer to the help document on the right for how to generate it

# 1, Finds the subscript of the specified element

Given an n-element ordered (ascending) integer array nums and a target value target, write a function to search the target in nums. If the target value exists, return the subscript, otherwise return - 1.

Source: LeetCode Tips:

• You can assume that all elements in nums are non repeatable
• n will be between 
• Each element of num will be between [- 99999999]
```    //non-recursive
public static int select2(int[] nums,int target){
int left = 0;
int right = nums.length-1;
while (left<=right){
int mid = (left+right)/2;
if (target<nums[mid]){
right = mid-1;
}else if (target>nums[mid]){
left = mid+1;
}else {
return mid;
}
}
return -1;
}
```

# 2, Search insertion location

Given a sort array and a target value, find the target value in the array and return its index. If the target value does not exist in the array, returns the position where it will be inserted in order.

You must use an algorithm with a time complexity of O(log n).

Source: LeetCode Use dichotomy

```    public static int searchInsert(int[] nums, int target) {
int left = 0;
int right = nums.length-1;
if (target>nums[nums.length-1]){
return nums.length;
}
while (left<=right){
int mid = (left+right)/2;
if (target<nums[mid]){
right = mid-1;
}else if (target>nums[mid]){
left = mid+1;
}else {
return mid;
}
}
return left;
}
```

More simply, there is violent cracking
brute force

```    //Non dichotomy, violence
public static int searchInsert2(int[] nums, int target) {
for (int i = 0; i < nums.length; i++) {
if (nums[i]>=target){
return i;
}
}
return nums.length;
}
```

# 3, Finds the first and last elements in a sorted array

Given an integer array nums arranged in ascending order and a target value target. Find the start and end positions of the given target value in the array.

If the target value target does not exist in the array, return [- 1, - 1].

Can you design and implement an algorithm with time complexity of O(log n) to solve this problem?

Source: LeetCode brute force

```    private static int[] searchRange(int[] nums, int target){
int[] test = new int;
test=-1;
test=-1;
for (int i = 0; i < nums.length; i++) {
if (nums[i]==target){
//Left boundary
test = i;
test = i;
int j=i;
while (j!=nums.length-1&&nums[j+1]==nums[j]){
test = j + 1;
j++;
}
break;
}
}
return test;
}
```

Dichotomy

```    public static int[] searchRange3(int[] nums, int target){
int index = erfen(nums,target);
int left = index;
int right = index;
if (index!=-1){
//towards the left
while (left-1>=0&&nums[left-1]==nums[left]){
left--;
}
while (right+1<nums.length&&nums[right+1]==nums[right]){
right++;
}
}
return new int[]{left,right};
}
private static int erfen(int[] nums, int target) {
int l = 0;
int r = nums.length-1;
while (l<=r){
int mid = (l+r)/2;
if (target<nums[mid]){
r = mid-1;
}else if (target>nums[mid]){
l = mid+1;
}else {
return mid;
}
}
return -1;
}
```

# 4, Remove element

Give you an array num and a value val. you need to remove all elements with a value equal to Val in place and return the new length of the removed array.

Instead of using extra array space, you must use only O(1) extra space and modify the input array in place.

The order of elements can be changed. You don't need to consider the elements in the array that exceed the new length.

Source: LeetCode brute force

```    public static int removeElement(int[] nums, int val) {
int length = nums.length;
for (int i = 0; i < length; i++) {
if (val==nums[i]){
for (int j=i;j<length-1;j++){
nums[j] = nums[j+1];
}
length--;
i--;
}
}
return length;
}
```

## Double pointer algorithm

```    public static int removeElement2(int[] nums, int val){
int top = 0;
int bot = 0;
while (top<nums.length){
if (nums[top]!=val){
nums[bot] = nums[top];
bot++;
}
top++;
}
return bot;
}
```

# 5, Square of ordered array

Give you an integer array nums sorted in non decreasing order, and return a new array composed of the square of each number. It is also required to sort in non decreasing order.
Source: LeetCode Double pointer

```    private static int[] method1(int[] arr) {
int[] temp = new int[arr.length];
int index = temp.length-1;
int p1 = 0;
int p2 = arr.length-1;
while (p1<=p2){
if (arr[p1]*arr[p1]<arr[p2]*arr[p2]){
temp[index--] = arr[p2]*arr[p2];
p2--;
}else{
temp[index--] = arr[p1]*arr[p1];
p1++;
}
}
return temp;
}
```

# 6, Minimum length subarray

Given an array containing n positive integers and a positive integer target.

Find out the continuous sub array [numsl, numsl+1,..., numsr-1, numsr] with the smallest length satisfying its sum ≥ target in the array, and return its length. If there is no eligible subarray, 0 is returned.

Source: LeetCode
Title Description brute force

```    private static int check(int[] arr, int target) {
int result = Integer.MAX_VALUE;
int sum = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = i; j < arr.length; j++) {
sum+=arr[j];
if(sum>=target){
//Statistical length
int length = j-i+1;
result = result<length?result:length;
}
}
sum=0;
}
return result<Integer.MAX_VALUE?result:0;
}
```

## Sliding window algorithm

```    public static int check2(int[] arr, int target){
int left  = 0;
int sum= 0;
int result = Integer.MAX_VALUE;
for (int right=0;right<arr.length;right++){
sum+=right;
while (sum>=target){
//Window shrinkage
result = result<right-left+1?result:right-left+1;
sum-=arr[left++];
}
}
return result<Integer.MAX_VALUE?result:0;
}
```

# 7, Spiral matrix (high frequency)

Give you a positive integer n to generate an n x n square matrix containing all elements from 1 to n2 and the elements are spirally arranged in clockwise order. ```    public static int[][] generateMatrix(int n) {
int[][] arr = new int[n][n];
//Lower right upper left
int loop = n/2;//Number of cycles / / 1
int t = 1;
int Xstart = 0;//Start position of x-axis for each cycle
int Ystart = 0;//Start position of y-axis for each cycle
int offset = 1;//Offset

int mid = n/2;
while (loop>0){
int i = Xstart;
int j = Ystart;
//upper
for (;j<Ystart+n-offset;++j){
arr[Xstart][j]=t++;
}

//right
for (;i<Xstart+n-offset;++i){
arr[i][j]=t++;
}

//Left
//At this time, i=3,j=3
for (;j>Ystart;j--){
arr[i][j]=t++;
}

//At this time, I = 3 and j = 0
for (;i>Xstart;i--){
arr[i][j]=t++;
}
Xstart+=1;
Ystart+=1;
offset+=2;
loop--;
}
if (n%2==1){
arr[mid][mid]=t;
}
return arr;
}
```

Posted on Sat, 20 Nov 2021 06:36:05 -0500 by stevenrhiggins