初学者记录LeetCode每日一题

Day 1
19.给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：
给定的 n 保证是有效的。
进阶：
你能尝试使用一趟扫描实现吗？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

C语言：
思路：首先遍历整个链表计算链表长度

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeNthFromEnd(struct ListNode* head, int n){
    int record=1 ;
    struct ListNode* l1= head  ;
    while(l1->next != NULL){
        record++;
        l1 = l1->next ;
    }    
    struct ListNode* l2 = NULL ;
    if (record-n == 0) {     
        return head = head->next;
    } 
    else{
        l1 = head ;  
        for(int i=0 ;i<record-n-1 ;i++){
        l1 = l1->next;
        }
        l2=l1->next;
        if(l1->next != NULL){
            l1->next = l2->next;
        } 
        free(l2);
        return head;
    }
}

Day 2
844. 比较含退格的字符串
思路：定义两个字符栈用于存放两个字符串，非#入栈，#时出栈，最后比较两个栈中的字符是否相同；
给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

示例 1：
输入：S = “ab#c”, T = “ad#c”
输出：true
解释：S 和 T 都会变成 “ac”。
示例 2：
输入：S = “ab##”, T = “c#d#”
输出：true
解释：S 和 T 都会变成 “”。
示例 3：
输入：S = “a##c”, T = “#a#c”
输出：true
解释：S 和 T 都会变成 “c”。
示例 4：
输入：S = “a#c”, T = “b”
输出：false
解释：S 会变成 “c”，但 T 仍然是 “b”。
提示：
1 <= S.length <= 200
1 <= T.length <= 200
S 和 T 只含有小写字母以及字符 ‘#’。

bool backspaceCompare(char * S, char * T){
    char stack1[200],stack2[200];
    int i;
    for(i=0 ;i<200 ;i++){
        stack1[i] =stack2[i] ='-';
    }
    int j=0,k=0 ;
    int m=-1,n=-1;
    while(S[j]!='\0'){
        if(m<0 && S[j]=='#') j++;
        else if(m>=0 && S[j]=='#') {
            stack1[m--]='-';
            j++;
        } 
        else if(S[j]!='#'){
            stack1[++m]=S[j++];
        }
    }
    while(T[k]!='\0'){
        if(n<0 && T[k]=='#') k++;
        else if(n>=0 && T[k]=='#') {
            stack2[n--]='-';
            k++;
        } 
        else if(T[k]!='#'){
            stack2[++n]=T[k++];
        }
    }
    if(m != n) return false;
    for(i=0 ;i<200 ;i++){
        if (stack1[i]!=stack2[i]) return false;
    }
    return true;
}

Day 3
143. 重排链表
给定一个单链表 L：L0→L1→…→Ln-1→Ln ，
将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→…

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1:

给定链表 1->2->3->4, 重新排列为 1->4->2->3.
示例 2:

给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

//思路：首先遍历节点个数，计算需要插入到前面的节点个数，将需要插入到前面的节点先进行倒序
//用新的节点P指向倒序链表，将原链表与P链表组合
void reorderList(struct ListNode* head){
    int i=0,j=0;
    struct ListNode*L=head;
    while(L!=NULL){          //计算链表中的节点个数
        i++;
        L=L->next;
	}
    L=head;

    while(j<i/2){   //通过观察发现，不管是奇数个还是偶数个节点，都需要遍历到第i/2+1个节点
        L=L->next;  //第i/2+1个节点后的所有节点需要进行倒序，可以创建一个新的节点P指向该倒序链表
        j++;
	}

    struct ListNode*P1=NULL;
    if(L!=NULL && L->next!=NULL){
        P1=L->next;
    }
    struct ListNode*P2=NULL,*P=NULL,*P3;
    while(P1!=NULL){     //使用前插法将i/2+1个节点后的所有节点倒插进P链表；
        P2=P1;
        P1=P1->next;
        P2->next=P;
        P=P2; 
	}
    //因为将第i/2+1个节点后的节点都倒插入了P链表，所以要将head链表尾结点指向null；
    if(L!=NULL) L->next = NULL;
    L=head;           
    while(P!=NULL){
        P1=L->next;
        P2=P->next;
        P->next=L->next;
        L->next=P;
        L=P1;
        P=P2;
	 }
}

Day 4
925. 长按键入
你的朋友正在使用键盘输入他的名字 name。偶尔，在键入字符 c 时，按键可能会被长按，而字符可能被输入 1 次或多次。
你将会检查键盘输入的字符 typed。如果它对应的可能是你的朋友的名字（其中一些字符可能被长按），那么就返回 True。

示例 1：
输入：name = “alex”, typed = “aaleex”
输出：true
解释：‘alex’ 中的 ‘a’ 和 ‘e’ 被长按。
示例 2：
输入：name = “saeed”, typed = “ssaaedd”
输出：false
解释：‘e’ 一定需要被键入两次，但在 typed 的输出中不是这样。
示例 3：
输入：name = “leelee”, typed = “lleeelee”
输出：true
示例 4：
输入：name = “laiden”, typed = “laiden”
输出：true
解释：长按名字中的字符并不是必要的。

提示：
name.length <= 1000
typed.length <= 1000
name 和 typed 的字符都是小写字母。

//思路：遍历name字符串以及typed字符串，当前字符相同则向下遍历；
//当前字符不同：一、正在遍历typed的第一个字符，则直接返回false；
//当前字符不同：二、正在遍历typed[0]后面的字符，则判断typed[j]与前一个字符typed[j-1]是否相等，若相等，则向后遍历，再与name比较；若不相等，则返回false；
bool isLongPressedName(char * name, char * typed){	
    int i=0,j=0;
	while(name[i]!='\0' || typed[j]!='\0'){
		if(typed[j]==name[i]){
			j++;
			i++;
		}
		else if(typed[j]!=name[i] && (j==0 || typed[j]!=typed[j-1])){
            return false;
		}
		else if(typed[j]!=name[i] &&typed[j]==typed[j-1] ){
			j++;
		}
	}
	return true;
}

Day 5
763. 划分字母区间
字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一个字母只会出现在其中的一个片段。返回一个表示每个字符串片段的长度的列表。
示例 1：
输入：S = “ababcbacadefegdehijhklij”
输出：[9,7,8]
解释：
划分结果为 “ababcbaca”, “defegde”, “hijhklij”。
每个字母最多出现在一个片段中。
像 “ababcbacadefegde”, “hijhklij” 的划分是错误的，因为划分的片段数较少。
提示：
S的长度在[1, 500]之间。
S只包含小写字母 ‘a’ 到 ‘z’ 。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

//借鉴了一下某大佬的思路，太棒了
//1、首先看第一个字母，找到它在串里最后的一个位置，记作last或一段的最后位置。
//2、在从0~last这个范围里，挨个查其他字母，看他们的最后位置是不是比刚才的last或一段的最后位置大。

int* partitionLabels(char * S, int* returnSize){
    int i=0,last=0,j,k,flag,record[500];
    for(i=0 ;i<500 ;i++)  record[i]=0 ;
	i=0;
    int * len = malloc(sizeof(int) * strlen(S));
    *returnSize =0 ;

	while(S[i] != '\0') {
		last = i ;
		flag = i;
		for(j=i+1 ;S[j] != '\0' ;j++){
			if(S[j] == S[i] && j>last) last=j;
		}
		//printf("last的值：%d\n",last);
		while(i < last){
			for(k = last+1 ;S[k]!='\0' ;k++){
				if(S[k] == S[i] && k>last )  last=k;
			}
			i++;
		}
		record[i] = last-flag+1;
		i = last+1 ;
	}
    j=0 ;
    
	 for(i=0 ;i<500 ;i++){
        if(record[i] != 0)  len[(*returnSize)++]=record[i] ;
    }
    return len;
}

Day 6
234. 回文链表
请判断一个链表是否为回文链表。
示例 1:
输入: 1->2
输出: false
示例 2:
输入: 1->2->2->1
输出: true
进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

//思路：遍历表长度i，将节点中的数值存储到数组中（从num[i]往前存），存完后，再遍历链表与数组，将num[i]与节点中的数值比较，出现不同就返回false，遍历完成则返回true
bool isPalindrome(struct ListNode* head){
    int i=0,j=0,num[50000];
    struct ListNode* L=head;
    while(L!=NULL){
        i++;
        L=L->next;
    }
    L=head;
    for(j=i-1 ;j>=0 ;j--){
        num[j] = L->val;
        L=L->next ;
    }
    L=head,i=0;
    while(L!=NULL){
        if(num[i++] != L->val) return false;
        L=L->next;
    }
    return true;
}

Day 11
1207. 独一无二的出现次数
给你一个整数数组 arr，请你帮忙统计数组中每个数的出现次数。
如果每个数的出现次数都是独一无二的，就返回 true；否则返回 false。
示例 1：
输入：arr = [1,2,2,1,1,3]
输出：true
解释：在该数组中，1 出现了 3 次，2 出现了 2 次，3 只出现了 1 次。没有两个数的出现次数相同。
示例 2：
输入：arr = [1,2]
输出：false
示例 3：
输入：arr = [-3,0,1,-3,1,1,1,-3,10,0]
输出：true

提示：
1 <= arr.length <= 1000
-1000 <= arr[i] <= 1000

bool uniqueOccurrences(int* arr, int arrSize){
    int i, j, k;
    int record[1000][2];
    for(i=0; i<1000; i++){
        record[i][0] = 1001;
        record[i][1] = 0;
    }

    for(i=0; i<arrSize; i++){

        int flag = 0;

        for(k=0; k<i; k++){
            if(record[k][0] == arr[i]) flag = 1;
        }

        if(flag == 0){
            record[i][1] ++;
            record[i][0] = arr[i];
            for(j=i+1; j<arrSize; j++){
                if(arr[j] == arr[i]) record[i][1] ++;
            }
        } 
        
    }

    for(i=0; i<1000; i++){
        for(j=i+1 ;j<1000; j++){
            if(record[j][1] == record[i][1] && record[i][0] != 1001) return false ;
        }
    }

    return true;

}