Estructura de los datos de base (C) + número feliz

cero móvil

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int ptr1 = 0,ptr2 = 1;
        if(nums.size()<=1){
            return;
        }
        while(ptr2<nums.size()){
            while(nums[ptr2]==0){   //是0则右移到非0位置,但不能超过边界       
                if(ptr2>=nums.size()-1)
                    break;
                ptr2++;
            }
            if(nums[ptr1]==0&&nums[ptr2]!=0){   //是0则交换
                nums[ptr1] = nums[ptr2];
                nums[ptr2] = 0;
            }
            ptr1++;
            if(ptr1>=ptr2)	//ptr1超过ptr2唯一的情况就是前面全是非0数
                ptr2 = ptr1 + 1;
        }
    }
};

Aunque es poco, pero es de 4 ms, la lógica también se considera que es muy claro.

lista

La lista está almacenada en cada nodo se determina de forma dinámica, y cada nodo tiene un puntero a un nodo al siguiente, ya que el almacenamiento es dinámico no continua, de modo que podemos tomar en el momento de la inserción y el nodo deleción O (1) excelente efecto.

Chain elementos esenciales: un puntero nodo (puede ser de dos, es decir, lista doblemente enlazada)

Algunos puntos importantes:

Comprobación de anillo: el uso de los indicadores de velocidad

El primer punto de intersección de las dos listas: desde la cola hasta la cabeza de búsqueda para encontrar los puntos de desacuerdo

La siguiente es una lista volteado, muy simple, pero debe prestar atención a un buen punto

/**
 * 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) {
        if(head==NULL)
            return NULL;
        ListNode* myhead = head->next;  //直接从第二跳开始，避免死循环
        ListNode* temp = head;  //永远指向前一跳,原先的head位置永远都是前一跳！！！
        while(myhead!=NULL){
            temp->next = myhead->next; //前一跳直接指向下一跳
            myhead-> next = head; //将该节点放在头部
            head = myhead;  //头部变换地址
            myhead = temp->next; //换成之前的下一跳
        }
        return head;
    }
};

La siguiente es una lista de rotación del código, la clave es de corte:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* rotateRight(ListNode* head, int k) {
        if(head==NULL||k==0||head->next==NULL)
            return head;
        int size = 1;//链表长度
        ListNode* end = head;//倒数
        while(end->next!=NULL){
            size+=1;
            end=end->next;
        }
        k = size-k%size; //确认切割位点在第几位
        ListNode* end_k = head;//倒数第k
        int i = 0;
        while(++i<k)
            end_k = end_k->next;
        end->next = head;
        head = end_k->next;
        end_k->next = NULL;
        return head;
    }
};

PICADILLO

hash es una relación de mapeado, podemos hash de los datos por una amplia gama de la reducción en el alcance del desarrollo de la cubeta también se puede asignar a la clave de contenido, para encontrar el destino en el tiempo O (1). En términos simples, puede visitar la matriz es el más simple de un mapeo de hash.

class MyHashSet {
private:
    bool a[1000100];
public:
    /** Initialize your data structure here. */
    MyHashSet() {
        for(int i=0;i<1000100;i++)
            a[i] = false;
    }
    
    void add(int key) {
        a[key] = true;
    }
    
    void remove(int key) {
        a[key] = false;
    }
    
    /** Returns true if this set contains the specified element */
    bool contains(int key) {
        return a[key];
    }
};

Lo anterior es la más simple, pero la realidad no lo utiliza. . . .