数组
while(不变量)--不变量循环
704.二分查找
https://leetcode.cn/problems/binary-search/
题目要求
-
数组升序
-
无重复数字
方法一-左闭右闭[]
-
左闭右闭区间[left,right]，若nums[middle]！=target，则边界一定不包含middle；
-
用while循环，当找到了则直接返回，若没有则在while循环外返回-1；
class Solution {
public:
int search(vector<int>& nums, int target) {
int left=0;
int right=nums.size()-1;
while(left<=right){
int middle=left+(right-left)/2; //=(left+right)/2
if(nums[middle]<target){
left=middle+1;
}else if(nums[middle]>target){
right=middle-1;
}else{
return middle;
}
}
return -1;
}
};
方法二-左闭右开[,)
class Solution {
public:
int search(vector<int>& nums, int target) {
int left=0;
int right=nums.size();
while(left<right){ //[left,right) left=right时没有意义，当right=left+1时，则就是left这个数
int middle=left+(right-left)/2; //=(left+right)/2
if(nums[middle]<target){
left=middle+1; //left是包含的，所以middle绝对不是的情况下，移动到middle+1
}else if(nums[middle]>target){
right=middle; //right是不包含的，所以刚好排除了middle
}else{
return middle;
}
}
return -1;
}
};
//2 python中整除
>>1右移一位，==整除2
59.螺旋矩阵II
https://leetcode.cn/problems/spiral-matrix-ii/
我自己的想法：模拟顺时针++过程
问题：如何++；如何终止？
class Solution {
public:
vector<vector<int>> generateMatrix(int n) {
vector<vector<int>> matrix;
for(int col1=0;col1<n;col1++){
for(int row1=0;row1<n;row1++){
matrix[row1][col1]++;
for(int col2=n-1;col2>=0;col2--){
for(int row2=n-1;row2>=0;row2--){
matrix[]
}
}
}
}
}
};
思路：
-
严格控制边界，明确左闭右开（每行每列）。所以注意遍历时
j<n-offset-1(若刚开始offset=0)时，否则是遍历了左闭右闭。 -
注意每个循环包含上下两行，左右两列同时缩减1，所以体现在
`offset+1，loop边界从n/2开始，loop==0跳出不变量循环，可以用n=1,2,3模拟判断。 -
注意n=1,2,3时，都是1圈，n=3时，多了一个中间的值
`nums[middle][middle]=n*n。可以类比奇偶螺旋数组的情况。
class Solution {
public:
vector<vector<int>> generateMatrix(int n) {
vector<vector<int>> matrix(n,vector<int>(n,0));
int startx=0,starty=0;
int loop=n/2;
int i,j;
int count=1;
int offset=1; //左闭右开
int middle=n/2;
while(loop--){ //每次循环组，左闭右开
i=startx;
j=starty;
//上行，左到右
for(j=starty;j<n-offset;j++){ //如果offset=0，则j<n-offset-1，否则是左闭右闭
matrix[startx][j]=count++;
}
//右列，上到下
for(i=startx;i<n-offset;i++){
matrix[i][j]=count++;
}
//下行，右到左
for(;j>starty;j--){
matrix[i][j]=count++;
}
//左列，下到上
for(;i>startx;i--){
matrix[i][j]=count++;
}
offset++;
startx++;
starty++;
}
//奇数n，单独给中间的元素赋值
if(n%2==1){
matrix[middle][middle]=n*n;
}
return matrix;
}
};
链表
链表基础
-
内存中可能不连续存放
-
头指针，尾指针；每个节点包含数据域和指针域；
-
单链表、双链表、循环链表（头尾相连）
-
链表的结构定义代码
203. 移除链表元素
虚拟头节点
-
节点的声明：
ListNode* vnode= new ListNode();ListNode* cur=vnode;后一个是同一个指针，不要重复删除； -
指针域、数据域的引用：
vnode->next,vnode->val -
指针的移动：
vnode=vode->next
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
ListNode* virhead=new ListNode();
virhead->next=head; //虚拟头节点，以防头节点就是空结点，或头节点的值=val
ListNode* p=virhead;//遍历链表的索引节点，从虚拟结点开始
while(p->next!=nullptr){ //不变量是遍历到链表末尾，特征是指针域=nullptr
if(p->next->val==val){
p->next=p->next->next;
}else{
p=p->next;
}
}
return virhead->next;
}
};
包含内存回收
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
ListNode* virhead=new ListNode();
virhead->next=head; //虚拟头节点，以防头节点就是空结点，或头节点的值=val
ListNode* p=virhead;//遍历链表的索引节点，从虚拟结点开始
while(p->next!=nullptr){ //不变量是遍历到链表末尾，特征是指针域=nullptr
if(p->next->val==val){
ListNode* temp=p->next;
p->next=p->next->next;
delete temp; //内存回收，delete关键字
}else{
p=p->next;
}
}
head=virhead->next;
delete virhead;
return head; //返回新的头节点
}
};
不带虚拟头节点
-
头节点连续等于val，
while删除；判断删除后的头节点是否为null，直接返回null； -
头节点不是val或者null，则正常判断删除操作。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
//不设置虚拟节点
while(head!=nullptr && head->val==val ){
head=head->next;
} //while 而不是if，新头节点
// if(head==nullptr){
// return nullptr;
// } //单独判断如果头节点为空，处理过后的头节点
ListNode* p=head;
while(head!=nullptr && p->next!=nullptr){
if(p->next->val==val){
p->next=p->next->next;
}
else{
p=p->next;
}
}
return head; //如果head是nullptr，直接返回即可
}
};
标签：ListNode,val,int,nullptr,next,链表,middle,数组,Day1 From： https://www.cnblogs.com/good-mind/p/18116544