笔记

String类的实现：

#include <iostream>
#include <assert.h>
using namespace std;
 
 
class String
{
public:
    String(const char* str = NULL);
    String(const String &other);
    ~String();
    String &operator= (const String &other);
private:
    char *m_data;
};
 
String::String(const char* str)
{
    if (str == NULL)
    {
        m_data = new char[1];
        assert(m_data != NULL);
 
        m_data = '\0';
    }
    else
    {
        int len = strlen(str);
        m_data = new char[len];
        assert(m_data != NULL);
 
        //memcpy(m_data, str, len); // 法1
        strcpy(m_data, str);
    }
}
 
String::String(const String &other)
{
    assert(this != &other);
    int len = strlen(other.m_data);
 
    m_data = new char[len];
    assert(m_data != NULL);
 
    strcpy(m_data, other.m_data);
}
 
String::~String(void)
{
    delete[] m_data;
    m_data = NULL;
}
 
String& String::operator=(const String &other)
{
    if (this == &other)
    {
        return *this;
    }
 
    delete[] m_data;
    m_data = NULL;
 
    int len = strlen(other.m_data);
    m_data = new char[len];
    assert(m_data != NULL);
 
    memcpy(m_data, other.m_data, len);
    // 法2：strcpy(m_data, other.m_data);
 
    return *this;
}
 
int main(char argc, char *argv)
{
    String s1;
    String s2("222");
    s1 = s2;
 
    return 0;
}

反转链表：

ListNode* ReverseList(ListNode* pHead) {
        ListNode *root=pHead; 
        ListNode *pre=NULL;  
        ListNode *next=NULL;
        if(pHead==NULL) return NULL; 
    while(root->next){  
        next=root->next;   
        root->next=pre;      
        pre=root;       
        root=next;     
    }    
        root->next=pre; 
        return root; 
    }

二分查找

 int binarySearch(int arr[], int len, int key)
  {
      int left = 0;
       int right = len - 1;
       int mid;
 
     while (left <= right) {
          mid = (left + right) / 2;
          if (key < arr[mid]) {//key在左边
              right = mid - 1;
          } else if (arr[mid] < key) {//key在右边
              left = mid + 1;
          } else {
              return mid;
          }
      }
      return -1;
  }

memcpy memmove

void *memmove(void *dest, const void *source, size_t count)  
{  
 assert((NULL != dest) && (NULL != source));  
 char *tmp_source, *tmp_dest;  
 tmp_source = (char *)source;  
 tmp_dest = (char *)dest;  
 if((dest + count<source) || (source + count) <dest))  
 {// 如果没有重叠区域  
   while(count--)  
     *tmp_dest++ = *tmp_source++;  
}  
else  
{ //如果有重叠  
 tmp_source += count - 1;  
 tmp_dest += count - 1;  
 while(count--)  
   *--tmp_dest = *--tmp;  
}  
return dest;  
}  
    
void *memcpy(void *dest, const void *source, size_t count)  
{  
 assert((NULL != dest) && (NULL != source));  
 char *tmp_dest = (char *)dest;  
 char *tmp_source = (char *)source;  
 while(count --)//不对是否存在重叠区域进行判断  
   *tmp_dest ++ = *tmp_source ++;  
 return dest;  
}