1. 并查集
/*
-1 -1 -1 -1 -1 -1 -1 -1
{1, 2} {2, 3} {4, 5} {1, 2}
*/
#include<iostream>
using namespace std;
class UnionSet
{
public:
UnionSet(int n) :_size(n + 1)
{
_a = new int[n + 1];
memset(_a, -1, sizeof(int)*(n + 1));
}
void merge(int x1, int x2)
{
int root1 = _getRoot(x1);
int root2 = _getRoot(x2);
if (root1 != root2)
{
_a[root1] += _a[root2];
_a[root2] = root1;
}
}
int getSize()
{
return _getSize();
}
protected:
int _getSize()
{
int count=0;
for (int i = 0; i < _size; i++)
{
if (_a[i] < 0)
count++;
}
return count-1;
}
int _getRoot(int x)
{
int root = x;
while (_a[root] >= 0)
root = _a[root];
return root;
}
private:
int *_a;
size_t _size;
};
int main()
{
const int cols = 2;
const int rows = 6;
UnionSet s(5);
int arr[rows][cols] = { { 1, 2 }, { 2, 3 }, { 4, 5 }, { 1, 3 }, { 5, 4 }, { 2, 5 } };
for (int i = 0; i < rows; i++)
{
s.merge(arr[i][0], arr[i][1]);
}
cout << s.getSize() << endl;
system("pause");
}
2. 打印大数1-n
#include<iostream>
using namespace std;
void PrintNumber(char *arr)
{
bool flag = true;
int len = strlen(arr);
for (int i = 0; i < len; i++)
{
if (flag&&arr[i] != '0')
flag = false;
if (!flag)
cout << arr[i];
}
}
void PrintNum(char *arr, int index, int len)
{
if (index == len - 1)
{
PrintNumber(arr);
return;
}
for(int i = 0; i < 10; i++)
{
arr[index+1] = i + '0';
PrintNum(arr, index + 1, len);
}
}
void Print(int n)
{
char *arr = new char[n + 1];
memset(arr, 0, sizeof(char)*(n + 1));
arr[n] = '\0';
for (int i = 0; i < 10; i++)
{
arr[0] = i + '0';
PrintNum(arr, 0, n);
}
delete[]arr;
}
int main()
{
int n;
while (cin >> n)
{
Print(n);
cout << endl;
}
system("pause");
}
3. 奇数在前偶数在后
#include<iostream>
using namespace std;
bool func(int *arr, int key)
{
if (arr[key] & 0x1)
return true;
return false;
}
void ReOrder(int *arr, int len,bool (*func)(int *arr,int key))
{
int begin = 0;
int end = len - 1;
while (begin < end)
{
while (begin < end&&func(arr,begin))
++begin;
while (begin < end&&!func(arr, end))
--end;
swap(arr[begin], arr[end]);
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int len = sizeof(arr) / sizeof(arr[0]);
ReOrder(arr, len,func);
for (int i = 0; i < len; i++)
cout << arr[i] << " ";
cout << endl;
system("pause");
return 0;
}
4. 正则 表达式匹配
/*******************************************************************
Copyright(c) 2016, Harry He
All rights reserved.
Distributed under the BSD license.
(See accompanying file LICENSE.txt at
https://github.com/zhedahht/CodingInterviewChinese2/blob/master/LICENSE.txt)
*******************************************************************/
//==================================================================
// 《剑指Offer——名企面试官精讲典型编程题》代码
// 作者:何海涛
//==================================================================
// 面试题19:正则表达式匹配
// 题目:请实现一个函数用来匹配包含'.'和'*'的正则表达式。模式中的字符'.'
// 表示任意一个字符,而'*'表示它前面的字符可以出现任意次(含0次)。在本题
// 中,匹配是指字符串的所有字符匹配整个模式。例如,字符串"aaa"与模式"a.a"
// 和"ab*ac*a"匹配,但与"aa.a"及"ab*a"均不匹配。
#include <cstdio>
#include<iostream>
using namespace std;
bool matchCore(const char* str, const char* pattern);
bool match(const char* str, const char* pattern)
{
if (str == nullptr || pattern == nullptr)
return false;
return matchCore(str, pattern);
}
bool matchCore(const char* str, const char* pattern)
{
if (*str == '\0' && *pattern == '\0')
return true;
if (*str != '\0' && *pattern == '\0')
return false;
if (*(pattern + 1) == '*')
{
if (*pattern == *str || (*pattern == '.' && *str != '\0'))
// 进入有限状态机的下一个状态
return matchCore(str + 1, pattern + 2)
// 继续留在有限状态机的当前状态
|| matchCore(str + 1, pattern)
// 略过一个'*'
|| matchCore(str, pattern + 2);
else
// 略过一个'*'
return matchCore(str, pattern + 2);
}
if (*str == *pattern || (*pattern == '.' && *str != '\0'))
return matchCore(str + 1, pattern + 1);
return false;
}
// ====================测试代码====================
void Test(const char* testName, const char* string, const char* pattern, bool expected)
{
if (testName != nullptr)
printf("%s begins: ", testName);
if (match(string, pattern) == expected)
printf("Passed.\n");
else
printf("FAILED.\n");
}
int main(int argc, char* argv[])
{
Test("Test01", "", "", true);
Test("Test02", "", ".*", true);
Test("Test03", "", ".", false);
Test("Test04", "", "c*", true);
Test("Test05", "a", ".*", true);
Test("Test06", "a", "a.", false);
Test("Test07", "a", "", false);
Test("Test08", "a", ".", true);
Test("Test09", "a", "ab*", true);
Test("Test10", "a", "ab*a", false);
Test("Test11", "aa", "aa", true);
Test("Test12", "aa", "a*", true);
Test("Test13", "aa", ".*", true);
Test("Test14", "aa", ".", false);
Test("Test15", "ab", ".*", true);
Test("Test16", "ab", ".*", true);
Test("Test17", "aaa", "aa*", true);
Test("Test18", "aaa", "aa.a", false);
Test("Test19", "aaa", "a.a", true);
Test("Test20", "aaa", ".a", false);
Test("Test21", "aaa", "a*a", true);
Test("Test22", "aaa", "ab*a", false);
Test("Test23", "aaa", "ab*ac*a", true);
Test("Test24", "aaa", "ab*a*c*a", true);
Test("Test25", "aaa", ".*", true);
Test("Test26", "aab", "c*a*b", true);
Test("Test27", "aaca", "ab*a*c*a", true);
Test("Test28", "aaba", "ab*a*c*a", false);
Test("Test29", "bbbba", ".*a*a", true);
Test("Test30", "bcbbabab", ".*a*a", false);
system("pause");
return 0;
}
链表问题总结
#include<iostream>
#include<cassert>
using namespace std;
struct ListNode
{
int _data;
ListNode *_pNext;
ListNode(int data)
:_pNext(nullptr),
_data(data)
{}
};
void PushFront(ListNode *&pNode,int data)
{
if (pNode == NULL)
{
pNode = new ListNode(data);
}
else
{
ListNode *pNew = new ListNode(data);
pNew->_pNext = pNode;
pNode = pNew;
}
}
void PushBack(ListNode *&pNode, int data)
{
if (pNode == NULL)
{
pNode = new ListNode(data);
}
else
{
ListNode *pCur = pNode;
ListNode *pNew = new ListNode(data);
while (pCur->_pNext)
{
pCur = pCur->_pNext;
}
pCur->_pNext = pNew;
}
}
ListNode *FindNode(ListNode *&pHead, int data)
{
assert(pHead);
ListNode*pCur = pHead;
while (pCur)
{
if (pCur->_data == data)
return pCur;
pCur = pCur->_pNext;
}
return nullptr;
}
void PopBack(ListNode *&pHead)
{
if (pHead == nullptr)
return;
ListNode *pCur = pHead;
ListNode *pPre = pCur;
if (pHead->_pNext == nullptr)
{
delete pHead;
pHead == nullptr;
return;
}
while (pCur->_pNext)
{
pPre = pCur;
pCur = pCur->_pNext;
}
pPre->_pNext = nullptr;
delete pCur;
pCur = nullptr;
}
void Reverse(ListNode *&pHead)
{
assert(pHead);
/*ListNode *pCur = pHead;
ListNode *pNew = nullptr;
ListNode *pNext = pCur->_pNext;
while (pNext)
{
pCur->_pNext = pNew;
pNew = pCur;
pCur = pNext;
pNext = pNext->_pNext;
}
pCur->_pNext = pNew;
pHead = pCur;*/
ListNode *pNewHead = nullptr;
ListNode *pTemp = nullptr;
ListNode *pCur = pHead;
while (pCur)
{
pTemp = pCur->_pNext;
pCur->_pNext = pNewHead;
pNewHead = pCur;
pCur = pTemp;
}
pHead = pNewHead;
}
ListNode *MeetingNode(ListNode *&pHead)
{
assert(pHead);
ListNode *pSlow = pHead->_pNext;
if (nullptr == pSlow)
return nullptr;
ListNode *pFast = pSlow->_pNext;
while (pFast&&pSlow)
{
if (pFast == pSlow)
return pSlow;
pSlow = pSlow->_pNext;
pFast = pFast->_pNext;
//注意快指针有可能为空
if (pFast)
pFast = pFast->_pNext;
}
return nullptr;
}
void Merge(ListNode *&pHead1,ListNode *&pHead2)
{
assert(pHead1&&pHead2);
ListNode *head = pHead1->_data > pHead2->_data ? pHead2 : pHead1;
ListNode *head1 = head;
ListNode *head2 = head == pHead1 ? pHead2 : pHead1;
ListNode *pNext = nullptr;
ListNode *pPre = nullptr;
while (head1&&head2)
{
if (head1->_data <= head2->_data)
{
pPre = head1;
head1 = head1->_pNext;
}
else
{
pNext = head2->_pNext;
pPre->_pNext = head2;
head2->_pNext = head1;
pPre = head2;
head2 = pNext;
}
}
pPre->_pNext = head1 == nullptr ? head2 : head1;
}
void SelectSort(ListNode *&pHead)
{
assert(pHead);
ListNode *pCur = pHead;
if (pHead->_pNext == nullptr)
return;
while (pCur)
{
ListNode *p = pCur->_pNext;
ListNode *min = pCur;
while (p)
{
if (min->_data > p->_data)
min = p;
p = p->_pNext;
}
if (min != p)
swap(min->_data, p->_data);
pCur = pCur->_pNext;
}
}
ListNode *EntryNodeOfLoop(ListNode *pHead)
{
ListNode *meetingNode = MeetingNode(pHead);
if (nullptr == meetingNode)
return nullptr;
ListNode *pCur = pHead;
while (pCur!=meetingNode)
{
pCur = pCur->_pNext;
meetingNode = meetingNode->_pNext;
}
return pCur;
}
void RemoveRepeate(ListNode *&pHead)
{
if (pHead == nullptr || pHead->_pNext == nullptr)
return;
ListNode *pCur = pHead;
ListNode *pPre = nullptr;
while (pCur)
{
ListNode *pNext = pCur->_pNext;
bool needDelete = false;
if (pNext&&pNext->_data == pCur->_data)
needDelete = true;
if (!needDelete)
{
pPre = pCur;
pCur = pCur->_pNext;
}
else
{
int data = pCur->_data;
ListNode *pDel = pCur;
while (pDel&&pDel->_data == data)
{
pNext = pDel->_pNext;
delete pDel;
pDel = nullptr;
pDel = pNext;
}
if (nullptr == pPre)
pHead = pNext;
else
pPre->_pNext = pNext;
pCur = pNext;
}
}
}
void RemoveListNode(ListNode *&pHead,ListNode *&pNode)
{
if (pNode == nullptr)
return;
if (pNode->_pNext != nullptr)
{
pNode->_data = pNode->_pNext->_data;
ListNode *pTemp=pNode->_pNext;
pNode->_pNext = pTemp->_pNext;
delete pTemp;
pTemp = nullptr;
}
else
{
if (pNode == pHead)
{
delete pHead;
pHead = nullptr;
}
else
{
PopBack(pHead);
}
}
}
void ReversePrintList(ListNode *&pNode)
{
if (pNode&&pNode->_pNext)
ReversePrintList(pNode->_pNext);
if (pNode)
cout << pNode->_data<<" ";
}
int main()
{
ListNode* pHead = nullptr;
PushBack(pHead, 1);
//PushBack(pHead, 1);
//PushBack(pHead, 1);
PushBack(pHead, 2);
PushBack(pHead, 3);
// PushBack(pHead, 4);
// PushBack(pHead, 4);
PushBack(pHead, 4);
PushBack(pHead, 5);
PushBack(pHead, 6);
PushBack(pHead, 7);
RemoveRepeate(pHead);
// ListNode *pDel = FindNode(pHead,1);
Reverse(pHead);
// RemoveListNode(pHead, pDel);
ReversePrintList(pHead);
system("pause");
}