编程题小结

1. 找到两个链表的第一个共同节点位置

• 关键在于认识到，一旦出现共同节点，则两个链表后续所有节点都相同且链表的末尾相同；
• 故而，给两个链表赋指针，利用指针进行遍历和对比。
• 若两个链表不一样长，先将长的链表遍历到与短链表相同长度；再齐头并进对比两个指针；

例如：
a1 -> a2 -> c1->c2 ->c3; //链表1
b1->c1->c2->c3; //链表2

2. 左移
   基本思想是：YX = (X^T Y ^T)^T
   故而，左移n位等同于：
   将前n位位置交换（第一位和第n位交换），再将（n+1)位到最后一位的位置交换，最好从同到尾交换元素位置；

for(int i=0,j=n-1;i<j;++i,--j)
      swap(str[i],str[j]);
for(int i=n,j=len-1;i<j;++i,--j)
      swap(str[i],str[j]);
for(int i=0,j=len-1;i<j;++i,--j)
      swap(str[i],str[j]);

同理，右移n位：（总长len）

• 后n位，互相交换位置； （第n位和最后一位交换）
• 剩余的其它元素互相交换位置； （第1位和第len-n位交换）
• 从第1位到最后一位互相交换位置；（第1位和第len位交换）

3. 将字符串中的字符从空格中分离
   关键在于需要两个变量，一个进行移动，一个进行标记；
   如：
   I am a student.
   |
   i,m
   移动i，直到遇到空格；
   此时(i-1)和m之间就是字符；

string ReverseSentence(string str) {
        int mark=0;
        int i;
        int len=str.size();
        if(len==0) return str;
        str+=' ';				//在末尾加入空格，如此才能识别最后一个单词
        for(i=0;i<len+1;++i)	//由于加了空格，故而长度加1
        {
            if(str[i]==' ')
            {
                Reverse(str,i-1,mark);
                mark=i+1;
            }
        }
        str=str.substr(0,len);			//不取添加在最后的空格
        for(int j=len-1,i=0;i<j;++i,--j)
            swap(str[i],str[j]);
        return str;
    }
    void Reverse(string &str,int i,int m)
    {

        while(m<i)
        {
            swap(str[m],str[i]);
            m++;
            i--;
        }
    }

4. 找到出现一次的字母，找到出现2次的字母，找到出现n次的字母：
   基本思想：利用一个数组来记录各个元素出现了多少次，并按照要求输出；

// 已知vector为a;
int C[256]={0};
for(int i=0;i<a.size();++i)
{
	C[a[i]]=C[a[i]]+1; // 记录出现了几次
}
for(int i=0;i<a.size();++i)
{
	if(C[a[i]]==1)	//找到第一个只出现一次的元素
		return a[i];
}

5.链表中的环：
先说个定理：两个指针一个fast、一个slow同时从一个链表的头部出发；
fast一次走2步，slow一次走一步，如果该链表有环，两个指针必然在环内相遇
此时只需要把其中的一个指针重新指向链表头部，另一个不变（还在环内），
这次两个指针一次走一步，相遇的地方就是入口节点。

若要找这个环的长度，只需要将保持fast和slow的步长不变，当二者再次相遇的时候，slow走的总步数就是环的长度。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {
        if(pHead == NULL){
            return NULL;
        }
        ListNode* meetingnode = MeetingNode(pHead);
        if(meetingnode == NULL){
            return NULL;
        }
        ListNode* pNode1 = meetingnode;
        // 两个指针同时移动，找到环入口
        ListNode* pNode2 = pHead;
        while(pNode1 != pNode2){
            pNode1 = pNode1->next;
            pNode2 = pNode2->next;
        }
        return pNode1;
    }
private:
    // 使用快慢指针，找到任意的一个环中结点
    ListNode* MeetingNode(ListNode* pHead){
        ListNode* pSlow = pHead->next;
        if(pSlow == NULL){
            return NULL;
        }
        ListNode* pFast = pSlow->next;
        while(pFast != NULL && pSlow != NULL){
            if(pFast == pSlow){
                return pFast;
            }
            pSlow = pSlow->next;
            pFast = pFast->next;
            if(pFast != NULL){
                pFast = pFast->next;
            }
        }
        return NULL;
    }
};

https://blog.csdn.net/weixin_38075257/article/details/87921436