剑指offer学习笔记1

C++的标准不允许复制构造函数传值参数。

A(const A& other){}

，如果是传值参数，把形参复制到实参会调用复制构造函数，就会形成无休止的递归调用从而导致栈溢出。

赋值运算符函数

class CMyString
{
public:
CMyString(char *pData = NULL);
CMyString(const CMyString& str);
~CMyString();
CMyString& operator=(const CMyString& other);
private:
char *m_pData;
};

CMyString& CMyString::operator=(const CMyString& other)
{
if (this == &other)
{
return *this;
}
delete m_pData;
m_pData = new char[strlen(other.m_pData) + 1];
strcpy(m_pData, other.m_pData);
}

合并两个已排序数组，第一个数组足以容纳两个数组的所有元素

int merge(int num1[], int len1, int num2[], int len2)
{
int i = len1 + len2 - 1;
int j = len1 - 1;
int k = len2 - 1;
while (j >= 0 && k >= 0)
{
if (num1[j] > num1[k])
{
num1[i--] = num1[j--];
}
else
{
num1[i--] = num2[k--];
}
}
while (j >= 0)
{
num1[i--] = num1[j--];
}
while (k >= 0)
{
num1[i--] = num2[k--];
}

return len1 + len2;
}

链表中删除某个结点

ListNode* deleteNode(ListNode *head, int key)
{
if (head == NULL)
{
return head;
}
ListNode *cur = head;
ListNode *pre;
ListNode *temp;
while (cur->val != key)
{
pre = cur;
cur = cur->next;
}
temp = cur;
if (cur == head)
{
head = head->next;
}
else
{
pre->next = cur->next;
}
delete temp;

return head;
}

或

ListNode* deleteNode(ListNode *head, int key)
{
if (head == NULL)
{
return head;
}
ListNode *temp;
if (head->val == key)
{
temp = head;
head = head->next;
}
else
{
ListNode *p = head;
while (p->next != NULL && p->next->val != key)
{
p = p->next;
}
if (p->next != NULL && p->next->val == key)
{
temp = p->next;
p->next = p->next->next;
}
}
delete temp;

return head;
}

从尾到头打印链表

void print(ListNode *head)
{
if (head != NULL)
{
print(head->next);
cout<<head->val<<" ";
}
}

或

void print(ListNode *head)
{
stack<ListNode*> s;
while (head != NULL)
{
s.push(head);
head = head->next;
}
while (!s.empty())
{
cout<<s.top()->val<<" ";
s.pop();
}
}

重建二叉树

TreeNode* constructHelp(int *prestart, int *preend, int *instart, int *inend)
{
int *rootin = instart;
while (rootin <= inend && *rootin != *prestart)
{
++rootin;
}
int leftLen = rootin - instart;
int rightLen = inend - rootin;
TreeNode *root = new TreeNode(*prestart);
if (leftLen > 0)
{
root->left = constructHelp(prestart + 1, prestart + leftLen, instart, rootin - 1);
}
if (rightLen > 0)
{
root->right = constructHelp(prestart + leftLen + 1, preend, rootin + 1, inend);
}

return root;
}

TreeNode* construct(int preorder[], int inorder[], int len)
{
if (preorder == NULL || inorder == NULL || len <= 0)
{
return NULL;
}
return constructHelp(preorder, preorder + len - 1, inorder, inorder + len - 1);
}

两个栈实现一个队列

template<class T> class MyQueue
{
public:
void push(T t)
{
s1.push(t);
}

void pop()
{
if (s2.empty())
{
gather(s1, s2);
}
s2.pop();
}

T front()
{
if (s2.empty())
{
gather(s1, s2);
}
return s2.top();
}

bool empty()
{
return s1.empty() && s2.empty();
}
private:
void gather(stack<T> &s1, stack<T> &s2)
{
while (!s1.empty())
{
s2.push(s1.top());
s1.pop();
}
}
stack<T> s1;
stack<T> s2;
};

两个队列实现一个栈

template<class T> class MyStack
{
public:
void push(T t)
{
if (q1.empty())
{
q2.push(t);
}
else
{
q1.push(t);
}
}

T top()
{
T t = leaveOne(q2, q1);
push(t);

return t;
}

void pop()
{
leaveOne(q1, q2);
}

bool empty()
{
return q1.empty() && q2.empty();
}
private:
T leaveOne(queue<T> &q1, queue<T> &q2)
{
if (q1.size() == 0)
{
swap(q1, q2);
}
while (q1.size() > 1)
{
q2.push(q1.front());
q1.pop();
}
T t = q1.front();
q1.pop();

return t;
}
queue<T> q1;
queue<T> q2;
};

排序员工年龄（假设age>= 0 && age<=99）

void sort(int num[], int len)
{
int cnt[100] = {0};
for (int i = 0; i < len; i++)
{
cnt[num[i]]++;
}

int index = 0;
for (int i = 0; i < 100; i++)
{
for (int j = 0; j < cnt[i]; j++)
{
num[index++] = i;
}
}
}

旋转数组的最小数字

int findMinHelp(int num[], int left, int right)
{
int res = left;
for (int i = left + 1; i <= right; i++)
{
if (num[i] < num[res])
{
res = i;
}
}
return res;
}

int findMin(int num[], int len)
{
int left = 0;
int right = len - 1;
int mid = left;
while (num[left] >= num[right])
{
if (right - left == 1)
{
mid = right;
break;
}
mid = (left + right) / 2;
if (num[mid] == num[left] && num[mid] == num[right])
{
return findMinHelp(num, left, right);
}
if (num[mid] >= num[left])
{
left = mid;
}
else if (num[mid] <= num[right])
{
right = mid;
}
}
return mid;
}

三种错误处理方式优缺点比较

打印1到最大的n位数

void print(int num[], int len)
{
bool flag = false;
int index;
for (int i = 0; i < len; i++)
{
if (num[i] != 0)
{
index = i;
flag = true;
break;
}
}
if (flag)
{
for (int i = index; i < len; i++)
{
cout<<num[i];
}
cout<<" ";
}
}

void fun(int num[], int len, int pos)
{
for (int i = 0; i < 10; i++)
{
num[pos] = i;
if (pos == len - 1)
{
print(num, len);
}
else
{
fun(num, len, pos + 1);
}
}
}

在O(1)时间内删除链表结点

ListNode* deleteNode(ListNode *head, ListNode *del)
{
if (head == NULL || del == NULL)
{
return head;
}
if (del->next != NULL)
{
ListNode *temp = del->next;
del->val = temp->val;
del->next = temp->next;
delete temp;
}
else if (del == head)
{
delete head;
head == NULL;
}
else
{
ListNode *p  = head;
while (p->next != del)
{
p = p->next;
}
p->next = del->next;
delete del;
}

return head;
}

调整数组顺序使奇数位于偶数前面

void fun(int num[], int len)
{
if (num == NULL)
{
return;
}
int i = 0;
int j = len - 1;
while (i < j)
{
while (i < j && num[i] & 0x1)
{
i++;
}
while (i < j && !(num[j] & 0x1))
{
j--;
}
swap(num[i++], num[j--]);
}
}

此处有一种扩展方法，将第二个和第三个while的判断条件写成一个函数，然后为主函数增加一个参数，该参数为一个函数指针。

链表中倒数第K个结点

ListNode* findKth(ListNode *head, int k)
{
if (head == NULL || k == 0)
{
return NULL;
}
ListNode *p1 = head;
for (int i = 0; i < k - 1; i++)
{
if (p1->next != NULL)
{
p1 = p1->next;
}
else
{
return NULL;
}
}
ListNode *p2 = head;
while (p1->next != NULL)
{
p1 = p1->next;
p2 = p2->next;
}

return p2;
}

反转链表

ListNode* reverse(ListNode *head)
{
if (head == NULL)
{
return head;
}
ListNode *pre = head;
ListNode *cur = head->next;
while (cur != NULL)
{
pre->next = cur->next;
cur->next = head;
head = cur;
cur = pre->next;
}

return head;
}

ListNode* reverse2(ListNode *head)
{
if (head == NULL || head->next == NULL)
{
return head;
}
ListNode *newhead = reverse2(head->next);
head->next->next = head;
head->next = NULL;

return newhead;
}

合并两个排序的链表

ListNode* merge(ListNode *head1, ListNode *head2)
{
if (head1 == NULL)
{
return head2;
}
else if (head2 == NULL)
{
return head1;
}
ListNode *head;
if (head1->val < head2->val)
{
head = head1;
head1 = head1->next;
}
else
{
head = head2;
head2 = head2->next;
}
ListNode *pre = head;
while (head1 != NULL && head2 != NULL)
{
if (head1->val < head2->val)
{
pre->next = head1;
head1 = head1->next;
}
else
{
pre->next = head2;
head2 = head2->next;
}
pre = pre->next;
}
if (head1 != NULL)
{
pre->next = head1;
}
if (head2 != NULL)
{
pre->next = head2;
}

return head;
}

或

ListNode* merge(ListNode *head1, ListNode *head2)
{
if (head1 == NULL)
{
return head2;
}
else if (head2 == NULL)
{
return head1;
}
ListNode *head;
if (head1->val < head2->val)
{
head = head1;
head1 = head1->next;
}
else
{
head = head2;
head2 = head2->next;
}
head->next = merge(head1, head2);
return head;
}

链表排序

ListNode* sort(ListNode *head)
{
ListNode *p = head;
int len = 0;
while (p != NULL)
{
len++;
p = p->next;
}

for (int i = 0; i < len - 1; i++)
{
p = head;
for (int j = 0; j < len - 1 - i; j++)
{
if (p->val > p->next->val)
{
swap(p->val, p->next->val);
}
p = p->next;
}
}
return head;
}

树的子结构

bool subTreeHelp(TreeNode *root1, TreeNode *root2)
{
if (root2 == NULL)
{
return true;
}
if (root1 == NULL)
{
return false;
}
if (root1->val != root2->val)
{
return false;
}

return subTreeHelp(root1->left, root2->left) &&
subTreeHelp(root1->right, root2->right);
}

bool hasSubTree(TreeNode *root1, TreeNode *root2)
{
bool res = false;
if (root1 != NULL && root2 != NULL)
{
if (root1->val == root2->val)
{
res = subTreeHelp(root1, root2);
}
if (!res)
{
res = hasSubTree(root1->left, root2);
}
if (!res)
{
res = hasSubTree(root1->right, root2);
}
}

return res;
}

二叉树的镜像

void mirror(TreeNode *root)
{
if (root != NULL)
{
TreeNode *temp = root->left;
root->left = root->right;
root->right = temp;
if (root->left != NULL)
{
mirror(root->left);
}
if (root->right != NULL)
{
mirror(root->right);
}
}
}