#include<iostream>
using namespace std;

// 1 定义一个队列
// 2 输入操作的次数
// 3 每次用户输入一个操作提示，根据提示进行相应的操作

int const N = 100010; // 定义一个整型常量，用来表示数组的长度
int q[N];   //数组模拟队列
int qh = 0; //队头指针
int qt = 0; //队尾指针


int main()
{
    // 输入操作次数
    int M;
    cin >> M;

    for (int i = 0; i < M; i++)
    {
        string op;
        cin >> op; // 输入操作提示

        if(op == "push")// 队尾插入一个数
        {
            int x;
            cin >> x;
            q[qt++] = x; // qt指向当前元素的下一个位置
        }
        else if(op == "pop") // 队头弹出一个数
        {
            qh++ ;
        }
        else if(op == "empty") // 判断队列是否为空
        {
            if(qh < qt) cout << "NO" <<endl; 
            else cout << "YES" <<endl;
        }
        else // 查队头元素
        {
            cout << q[qh] << endl;
        }

    }

    return 0; 
}

#include<iostream>  
using namespace std;  

int const N = 100010;  
int stk[N];  
int top = -1;  

int main()  
{  
    int n;  
    cin >> n;  

    for(int i = 0; i < n;i++)  
    {  
        int x;  
        scanf("%d",&x);  

        while(top >= 0 && stk[top] >= x) top--; //如果栈不为空，栈顶元素比当前元素大或者和当前元素相等，那就删除栈顶元素  
        if(top >= 0) printf("%d ",stk[top]); // 如果栈不为空就输出栈顶元素  
        else printf("%d ",-1);  

        stk[++top] = x;  
    }  

    return 0;  
}  

#include<iostream>
using namespace std;


// 1 定义栈和栈顶指针
// 2 用户输入操作次数

// 3 每一次用户输入一个字符串,根据用户输入的字符串执行相应的操作
   // 一共循环M次，循环里面用多分支语句进行选择



int const N = 100010;
int stk[N];
int top = -1;

int main()
{
    // 用户输入操作次数
    int M;
    cin >> M;

    for(int i = 0; i < M; i++)
    {
        // 定义一个字符串变量用来保存用户输入的字符串
        string s;
        cin >> s;

        if(s == "push")
        {
            int x;
            cin >> x;
            stk[++top]=x;
        }
        else if (s == "pop")
        {
            top--;
        }
        else if(s == "empty")
        {
            if(top < 0) cout << "YES"<<endl; // 栈是空的
            else cout << "NO" << endl;
        }
        else
        {
            cout << stk[top] << endl;
        }
    }


    return 0;
}

#include<iostream>
using namespace std;

int main()
{
    // 创建一个数组
    // 输入100个数
    // 输出不大于10的元素

    double A[100];

    for(int i = 0; i < 100; i++)
    {
        cin >> A[i];
    }

    for(int j = 0; j < 100; j++)
    {
        if(A[j]<=10) printf("A[%d] = %.1f\n",j,A[j]);
    }
    return 0;
}

class Solution {
public:
    ListNode* deleteDuplication(ListNode* head) {

       // 创建一个虚拟的结点，用来存放头节点的位置
       ListNode* dummy = new ListNode(-1);
       dummy->next = head;

       // 创建一个指针变量pre,用来存放当前需要判断结点的上一个结点
       // 则当前需要判断的结点是pre->next
       ListNode* pre = dummy;


       while(pre->next)
       {
           // 创建一个指针cur指向开始搜索的结点，即当前需要判断的结点的下一个结点
           ListNode* cur = pre->next->next;

           // 开始搜索，如果搜索的结点的值和当前需要判断的结点的值相等，搜索结点后移
           while(cur && cur->val == pre->next->val)
           {
               cur = cur->next;
           }

           // 判断搜索结点是不是当前结点的下一个结点
           if (cur == pre->next->next) pre = pre->next; // 如果是，需要判断的结点后移
           else pre->next = cur;//如果不是，把这一段删掉
       }

       return dummy->next;

    }
};

// 1 创建一个长度为10的数组
// 2 用户输入一个V
// 循环给每一个元素赋值

#include<iostream>
using namespace std;

int main()
{
    int N[10];

    int v;
    cin >> v;

    N[0]=v;
    for (int i=1 ; i<10; i++)
    {
        N[i] = 2*N[i-1];
    }

    for(int i = 0;i<10;i++)
    {
        cout << "N[" << i << "]" << " = " << N[i] << endl;
    }
    return 0;
}

1 题目描述

输入两个链表，找出它们的第一个公共结点。
当不存在公共节点时，返回空节点。
样例
给出两个链表如下所示：
A： a1 → a2
↘
c1 → c2 → c3
↗
B: b1 → b2 → b3

输出第一个公共节点c1

2 思路

• 创建两个指针，指针p指向A链表的第一个结点，指针q指向B链表的第一个结点
• 判断，p和q是否相等
  • 相等，退出循环
  • 不相等，p往后移动一位，q往后移动一位
    • 当p为空的时候，指向B链表的第一个结点，当q为空的时候指向A链
      的第一个结点

3 代码

class Solution {
public:
    ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB) {

        ListNode* p = headA;
        ListNode* q = headB;

       while(p!=q)
       {
           if(!p) p = headB;
           else p = p->next;

           if(!q) q = headA;
           else q = q->next;
       }

       return p;
    }
}; 

1 题目描述

输入两个链表，找出它们的第一个公共结点。
当不存在公共节点时，返回空节点。
样例
给出两个链表如下所示：
A： a1 → a2
↘
c1 → c2 → c3
↗
B: b1 → b2 → b3

输出第一个公共节点c1

2 思路

• 创建两个指针，指针p指向A链表的第一个结点，指针q指向B链表的第一个结点
• 判断，p和q是否相等
  • 相等，退出循环
  • 不相等，p往后移动一位，q往后移动一位
    • 当p为空的时候，指向B链表的第一个结点，当q为空的时候指向A链
      的第一个结点

3 代码

class Solution {
public:
    ListNode *findFirstCommonNode(ListNode *headA, ListNode *headB) {

        ListNode* p = headA;
        ListNode* q = headB;

       while(p!=q)
       {
           if(!p) p = headB;
           else p = p->next;

           if(!q) q = headA;
           else q = q->next;
       }

       return p;
    }
}; 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {

        // 判断，如果链表中没有节点或者只有一个节点的时候直接不用反转
        // 直接返回head
        if (head == NULL || head->next == NULL) return head;

        ListNode* p = head;
        ListNode* q = head->next;

        while (q)
        {
            // 先要创建一个指针，保存q指向节点的next指针
            // q->next = p;
            // q = q->next;// 此时q的next已经被修改了，指向q,又会指回去，不会后移
            // p = p->next;// 当p移到下一个节点的时候，下一个节点的next指针已经被修改了

            ListNode* o = q->next; // 创建一个指针，保存q的next指针的值，保存指向
            q->next = p; // 修改q的指向
            p = q;//p后移一位
            q = o;//q后移一位

        }
        head->next = NULL; // 反转后的尾节点的next指针要置空

        return p;

    }
};

class Solution {
public:
    void deleteNode(ListNode* node) {
        node->val = node->next->val;
        node->next =node->next->next;

    }
};