本博客目录
- 转圈打印矩阵
- 旋转正方形矩阵
- “之”字形打印矩阵
- 反转单向链表
- 打印有序链表的公共部分
- 判断一个链表是否为回文结构
转圈打印矩阵
给定整型矩阵,按照顺时针转圈打印矩阵
class printCircleMatrix
{
public:
printCircleMatrix();
~printCircleMatrix();
/*
要宏观调控
先打印最外面一圈,之后左上角+1,右下角-1
继续打印,知道左上角坐标小于右下角坐标停止
*/
void print(int matrix[3][4], int row, int column) {
int tR = 0;
int tC = 0;
int dR = row - 1;
int dC = column - 1;
while (tR <= dR && tC <= dC) {
printEdage(matrix, tR++, tC++, dR--, dC--);
}
}
/*
打印边界函数
分为三种情况
1.矩阵为一行的情况
2.矩阵位一列的情况
3.不止一行一列的情况
一定要注意边界的情况,传入的是矩阵的左上角下标和右下角下标
左上角下标不一定为(0,0)
*/
void printEdage(int matrix[3][4], int tR, int tC, int dR, int dC) {
if (tR == dR) {
for (int i = tC; i <= dC; i++) {
cout << matrix[tR][i] << " ";
}
}
else if (tC == dC) {
for (int i = tR; i <= dR; i++) {
cout << matrix[i][tC];
}
}
else {
int curC = tC; //控制横向移动
int curR = tR; //控制纵向移动
while (curC != dC) {
cout << matrix[tR][curC++] << " ";
}
while (curR != dR) {
cout << matrix[curR++][dC] << " ";
}
while (curC != tC) {
cout << matrix[dR][curC--] << " ";
}
while (curR != tR) {
cout << matrix[curR--][tC] << " ";
}
}
}
};
旋转正方形矩阵
给定一个正方形矩阵,顺时针旋转90度。
class rotateMatrix
{
public:
rotateMatrix();
~rotateMatrix();
void rotate(int** arr, int size) {
int tR = 0;
int tC = 0;
int dR = size - 1;
int dC = size - 1;
while (tR <= dR) {
rotateEdge(arr, tR++, tC++, dR--, dC--);
}
}
void rotateEdge(int** arr, int tR, int tC, int dR, int dC) {
int times = dR - tR;
int tmp = 0;
for (int i = 0; i != times; i++) {
tmp = arr[tR][tC + i];
arr[tR][tC + i] = arr[dR - i][tC];
arr[dR - i][tC] = arr[dR][tC - i];
arr[dR][tC - i] = arr[tR + i][dC];
arr[tR + i][dC] = tmp;
}
}
};
“之”字形打印矩阵
给定一个矩阵,按照之字走路打印矩阵
class zigZagPrint
{
public:
zigZagPrint();
~zigZagPrint();
void print(int **arr, int row, int column) {
int tR = 0;
int tC = 0;
int dR = 0;
int dC = 0;
int endR = row - 1;
int endC = column - 1;
bool fromUp = false;
while (tR != endR + 1) {
printLevel(arr, tR, tC, dR, dC, fromUp);
tR = tC == endC ? tR + 1 : tR;
tC = tC == endC ? tC : tC + 1;
dC = dR == endR ? dC + 1 : dC;
dR = dR == endR ? dR : dR + 1;
fromUp = !fromUp;
}
}
void printLevel(int **arr, int tR, int tC, int dR, int dC, bool fromUp) {
if (fromUp) {
while (tR != dR + 1) {
cout << arr[tR++][tC--] << " ";
}
}
else {
while (dR != tR - 1) {
cout << arr[dR--][dC++] << " ";
}
}
}
};
反转单向链表
实现一个反转链表的函数
class reverseList
{
public:
reverseList();
~reverseList();
/*
非递归版本
*/
ListNode* reverse(ListNode* head) {
if (head == NULL || head->next == NULL) {
return head;
}
ListNode* pre = NULL;
ListNode* next = NULL;
while (head != NULL) {
next = head->next;
head->next = pre;
pre = head;
head = next;
}
return pre;
}
/*
递归版本
*/
ListNode* recuision(ListNode* head) {
if (head == NULL || head->next == NULL) {
return head;
}
ListNode* reverseHead = recuision(head);
head->next->next = head;
head->next = NULL;
return reverseHead;
}
};
打印两个有序链表的公共部分
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};
class printCommonPart
{
public:
printCommonPart();
~printCommonPart();
void print(ListNode* head1, ListNode* head2) {
vector<int> tmp;
ListNode* node1 = head1;
ListNode* node2 = head2;
while (node1 != NULL && node2 != NULL) {
if (node1->val < node2->val) {
node1 = node1->next;
}
else if (node1->val > node2->val) {
node2 = node2->next;
}
else {
tmp.push_back(node1->val);
node1 = node1->next;
node2 = node2->next;
}
}
for (int i = 0; i < tmp.size(); i++) {
cout << tmp[i] << " ";
}
}
};
判断一个链表是否为回文结构
struct ListNode
{
int val;
struct ListNode* next;
};
class isPalindromeList
{
public:
isPalindromeList();
~isPalindromeList();
//空间O(N)
bool isPalindrome1(ListNode* head) {
stack<int> tmp;
ListNode* cur = head;
while (cur != NULL) {
tmp.push(cur->val);
cur = cur->next;
}
cur = head;
while (cur != NULL) {
if (cur->val != tmp.top()) {
return false;
}
else {
tmp.pop();
cur = cur->next;
}
}
return true;
}
//空间O(N/2)
/*
定义两个指针,一个快指针,一个慢指针
快指针一次走两步,慢指针一次走一步
当快指针走到最后,慢指针正好中间,当链表node个数为奇数和偶数时,走到的位置不一样,可以自己画图搞清楚
把后半段压入栈,一次比较
*/
bool isPalindrome2(ListNode* head) {
if (head == NULL || head->next == NULL) {
return true;
}
ListNode* slow = head;
ListNode* fast = head;
while (slow != NULL && fast != NULL) {
slow = slow->next;
fast = fast->next->next;
}
stack<int> tmp;
while (slow != NULL) {
tmp.push(slow->val);
slow = slow->next;
}
slow = head;
while (!tmp.empty()) {
if (slow->val != tmp.top()) {
return false;
}
else {
tmp.pop();
slow = slow->next;
}
}
return true;
}
//空间O(1)
/*
定义两个指针,一个快指针,一个慢指针
快指针一次走两步,慢指针一次走一步
当快指针走到最后,慢指针正好中间,当链表node个数为奇数和偶数时,走到的位置不一样,可以自己画图搞清楚
将后半段链表反转
然后依次比较
最后,别忘了将链表恢复原来的样子
*/
bool isPalindrome3(ListNode* head) {
if (head == NULL || head->next == NULL) {
return true;
}
ListNode* cur = head;
ListNode* fast = head;
while (fast != NULL) {
cur = cur->next;
fast = fast->next->next;
}
ListNode* pre = NULL;
while (cur != NULL) {
ListNode* next = cur->next;
cur->next = pre;
pre = cur;
cur = next;
}
ListNode* last = pre;
cur = head;
bool isP = true;
while (last != NULL) {
if (cur->val != last->val) {
isP = false;
break;
}
cur = cur->next;
last = last->next;
}
cur = pre;
pre = NULL;
while (cur != NULL) {
ListNode* next = cur->next;
cur->next = pre;
pre = cur;
cur = next;
}
return isP;
}
};
参考
牛客网左程云算法课