2022-12-01

//伪代码
//因为是左闭右闭区间，所以意味着返回的数组下标在[left,right]中，所以当定义右边界值时，right应该等于数组长度减一
int left=0,int right=nums.length-1;
while(left<=right){  //这里判断等式在你定义的区间中是否成立，区间中包含了left和right的值，所以等式成立
    int mid=(left+right)/2; //两个int类型相加，有可能会溢出（left+（right-left）/2 
    if(nums[mid]>target){
        right=mid-1;         //当中间值大于目标值时，意味着目标值在区间的左边，所以重新定义区间时，此时上一个区间中已经包含了mid(因为是右闭区间，所以已经包含了mid)，再次定义区间的时候，right=mid-1；
    }else if(nums[mid]<target){
        left=mid+1;         //同理
    }else  {
        return mid;
}
}
return -1;   //数组中不存在目标值
java

//伪代码
//定义区间是左闭右开区间，意味着数组下标在[left,right)之间,right应该为数组的长度
int left=0,right=nums.lenth;
while(left<right){//这里等式取不取等于取决于你选择的区间范围，通过区间范围判断等式是否成立，因为这里是左闭右开区间，right的值是取不到的所以不能加等于
    int mid=(left+right)/2;
    if(nums[mid]>target){ //当中间值大于目标值时，意味着目标值在区间的左边，所以重新定义区间时，此时上一个区间中没有包含mid(因为是右开区间，所以没有包含mid)，再次定义区间的时候，right=mid；
        right=mid;
    }else if(nums[mid]<target){
        left=mid+1;
    }else{
        return mid;
}
    return -1;
}
java

java

//伪代码
int low;//定义一个慢指针，用来存新数组的下标
for(int fast=0;fast<nums.length;i++){
    if(nums[fast]!=target){  
        nums[low]=num[fast];  //将值赋值给新数组
        low++;
    }
}
return low;//返回新数组长度
java

 public int[] sortedSquares(int[] nums) {
        int[] reslut=new int[nums.length];
        for(int i=0;i<nums.length;i++){
            reslut[i]=nums[i]*nums[i];
        }
      Arrays.sort(reslut);
       return reslut;
    } 
java

int j=nums.length-1;
        int k=nums.length-1;
        int i=0;
        int[] result=new int[nums.length];
         while (i <= j) {
            if(nums[i]*nums[i]<nums[j]*nums[j]){
                result[k--]=nums[j]*nums[j];
                j--;

            }else{
                 result[k--]=nums[i]*nums[i];
                 i++;
                 
            }
        }
        return result;
    } 
java

public class ListNode {
    // 结点的值
    int val;

    // 下一个结点
    ListNode next;

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}
java

//伪代码
 public ListNode removeElements(ListNode head, int val) {
     //在头结点前面定义一个虚拟头结点dummy
    ListNode dummy= new ListNode(-1,head);
     ListNode pre=dummy;
     while(head!=null){//遍历链表直到（指针域指向最后一个位置的时候指针为空）
         if(head.val==val){//取原头结点的值与目标值相比较
             pre.next=head.next;/*相等移除元素，将虚拟节点的指针指向原结点的下一个位置*/
         }else{
             pre=head;//不相等就将节点的指针域给当前指针域的位置
         }
         head=head.next;//链表指向下一个位置再次比较
     }
 }
java

/**自定义链表结构
*/
class ListNode{
    int val;//值
    ListNode next;//指针域
    public ListNode(){}
    public ListNode(int val){
        this.val=val;
    }
}
class MyLinkedList {
    int size;
    ListNode head; //定义一个虚拟头结点
    public MyLinkedList() {
        size=0;
        head=new ListNode(0);
    }
    
    public int get(int index) {
        if(index<0 || index>=size){ /*index是链表节点，第零个节点是头结点，而Size是链表长度，所以当index等于size时index的数值也不合法*/
            return -1;
        }
        ListNode pre=head;
        //取得需要查询的当前节点的指针域位置
        for(int i=0;i<=index;i++){
            pre=pre.next;
        }
        return pre.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<=0){
            index=0;
        }
        if(index>size){//等于size的时候，插入尾部节点所以可以取到size的值
            return;
        }
        size++;
        ListNode pre=head;
        ListNode addval=new ListNode(val);
        for(int i=0;i<index;i++){
            pre=pre.next;//找到目标值前一个指针域
        }
        addval.next=pre.next;
        pre.next=addval;
    }
    
    public void deleteAtIndex(int index) {
         if(index>=0 && index<size){
        ListNode pre=head;
             //找到目标值前一个指针域
             for(int i=0;i<index;i++){
                 pre=pre.next;
             }
             size--;
             //将指针域给下下个节点
             pre.next=pre.next.next;
         }else{
             return ;
         }
    }
}
java

/**
 * 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 reverseList(ListNode head) {
        ListNode pre=null;
        ListNode temp=null; //作为临时指针存放cur的下一个节点
        ListNode cur=head;
        while(cur!=null){
            temp=cur.next;//先将cur的下一个指针存放在临时链表temp
            //链表反转
            cur.next=pre;
            pre=cur;
            //将cur重新赋值到原链表的头结点上
            cur=temp;
        }
        return pre;

    }
}
java