LinuxC编程一站式学习——堆栈

原創 huaweidong2011 2020-05-31 09:03

本科学习数据结构时实践比较少，因此最近开始复习，看到网站http://learn.akae.cn/media/ch12s03.html，既可以打基础，又可以顺便学习Linux的知识。

第12章讲“堆栈”，第3节讲“深度优先算法”寻找路径迷宫。代码已经给出了，为了方便其他同学下载调试，我这里也附上：

原始代码：

#include <stdio.h>
#define MAX_ROW 5
#define MAX_COL 5

struct point {
  int row;
  int col;
} stack[512];
int top = 0;

int maze[5][5] = {
  {0, 1, 0, 0, 0},
  {0, 1, 0, 1, 0},
  {0, 0, 0, 0, 0},
  {0, 1, 1, 1, 0},
  {0, 0, 0, 1, 0}
};

void push(struct point p)
{
  stack[top++] = p;
}

struct point pop()
{
  return stack[--top];
}

int is_empty()
{
  return top == 0;
}

void print_maze(void)
{
  int i, j;
  for (i = 0; i < MAX_ROW; i++) {
    for (j = 0; j < MAX_COL; j++)
      printf("%d ", maze[i][j]);
    putchar('\n');
  }
  printf("*********\n");
}

struct point predecessor[MAX_ROW][MAX_COL] = {
  {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
  {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
  {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
  {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
  {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}}
};

void visit(int row, int col, struct point pre)
{
  struct point visit_point = { row, col };
  maze[row][col] = 2;
  predecessor[row][col] = pre;
  push(visit_point);
}

int main()
{
  struct point p = { 0, 0 };
  maze[p.row][p.col] = 2;
  push(p);

  while (!is_empty()) {
    p = pop();
    if (p.row == MAX_ROW - 1 && p.col == MAX_COL - 1)
      break;
    if (p.col + 1 < MAX_COL && maze[p.row][p.col + 1] == 0)
      visit(p.row, p.col + 1, p);
    if (p.row + 1 < MAX_ROW && maze[p.row + 1][p.col] == 0)
      visit(p.row + 1, p.col, p);
    if (p.col > 0 && maze[p.row][p.col - 1] == 0)
      visit(p.row, p.col - 1, p);
    if (p.row > 0 && maze[p.row - 1][p.col] == 0)
      visit(p.row - 1, p.col, p);
    print_maze();
  }
  if (p.row == MAX_ROW - 1 && p.col == MAX_COL - 1) {
    printf("(%d, %d)\n", p.row, p.col);
    while (predecessor[p.row][p.col].row != -1) {
      p = predecessor[p.row][p.col];
      printf("(%d, %d)\n", p.row, p.col);
    }
  } else
    printf("No path!\n");
  return 0;
}

下面有三道习题。

1. 正向打印路径

文中已经分析“正向打印路径”原理上的不可行，因此我想到的方法是：

A：把输出到路径压到一个新的堆栈中，然后pop出来——这很好理解。

B：取巧的做法——把迷宫出口（4，4）当作起点，入口（0，0）当作终点，找到的路径（4，4）->（0，0）逆序输出即为（0，0）->（4，4），倘若没有路径，那么只会输出“No pathing！”

B方法代码更改的地方很少：

#include <stdio.h>
#define MAX_ROW 5
#define MAX_COL 5

struct point {
  int row;
  int col;
} stack[512];
int top = 0;

int maze[5][5] = {
  {0, 1, 0, 0, 0},
  {0, 1, 0, 1, 0},
  {0, 0, 0, 0, 0},
  {0, 1, 1, 1, 0},
  {0, 0, 0, 1, 0}
};

void push(struct point p)
{
  stack[top++] = p;
}

struct point pop()
{
  return stack[--top];
}

int is_empty()
{
  return top == 0;
}

void print_maze(void)
{
  int i, j;
  for (i = 0; i < MAX_ROW; i++) {
    for (j = 0; j < MAX_COL; j++)
      printf("%d ", maze[i][j]);
    putchar('\n');
  }
  printf("*********\n");
}

struct point predecessor[MAX_ROW][MAX_COL] = {
  {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
  {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
  {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
  {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}},
  {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}}
};

void visit(int row, int col, struct point pre)
{
  struct point visit_point = { row, col };
  maze[row][col] = 2;
  predecessor[row][col] = pre;
  push(visit_point);
}

int main()
{
  struct point p = { MAX_ROW-1, MAX_COL-1 };	// 起点为迷宫终点
  maze[p.row][p.col] = 2;
  push(p);

  while (!is_empty()) {
    p = pop();
    if (p.row == 0 && p.col == 0)	// 终止条件为达到起点
      break;
    if (p.col + 1 < MAX_COL && maze[p.row][p.col + 1] == 0)
      visit(p.row, p.col + 1, p);
    if (p.row + 1 < MAX_ROW && maze[p.row + 1][p.col] == 0)
      visit(p.row + 1, p.col, p);
    if (p.col > 0 && maze[p.row][p.col - 1] == 0)
      visit(p.row, p.col - 1, p);
    if (p.row > 0 && maze[p.row - 1][p.col] == 0)
      visit(p.row - 1, p.col, p);
    print_maze();
  }
  if (p.row == 0 && p.col == 0) {
    printf("(%d, %d)\n", p.row, p.col);
    while (predecessor[p.row][p.col].row != -1) {	// 最后只剩下起点以及未被访问到点到predecessor值为（-1，-1）
      p = predecessor[p.row][p.col];
      printf("(%d, %d)\n", p.row, p.col);
    }
  } else
    printf("No path!\n");
  return 0;
}

读者会发现，这种方法最终的结果maze矩阵中出现了0,原因是：本算法是深度优先算法，假如第一条路径就能够到达终点，那么算法就不会再计算了。

由此读者可以想到延伸的问题：求迷宫有几条路径可以达到终点？进而延伸：每条路径的长度是多少？这两个问题等到我以后再研究时会再练习，本文就先略去了。


2. 缩小空间

原来predecessor存储的是point的二维数组，我首先想到的是将其改为二维整形数据——代表指向前一个位置的“方向”。visit函数需要传入这个方向值；最后逆序输出时也需要根据方向值找到下一个位置点。首先，四个方向宏定义。

#include <stdio.h>
#define MAX_ROW 5
#define MAX_COL 5
#define RIGHT	1
#define LEFT	2
#define UP	3
#define DOWN	4

struct point {
	int row;
	int col;
} stack[512];
int top = 0;

int maze[5][5] = {
	{0, 1, 0, 0, 0},
	{0, 1, 0, 1, 0},
	{0, 0, 0, 0, 0},
	{0, 1, 1, 1, 0},
	{0, 0, 0, 1, 0}
};

void push(struct point p)
{
	stack[top++] = p;
}

struct point pop()
{
	return stack[--top];
}

int is_empty()
{
	return top == 0;
}

void print_maze(void)
{
	int i, j;
	for (i = 0; i < MAX_ROW; i++) {
		for (j = 0; j < MAX_COL; j++)
			printf("%d ", maze[i][j]);
		putchar('\n');
	}
	printf("*********\n");
}

int predecessor[MAX_ROW][MAX_COL] = {
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0}
};

void visit(int row, int col, struct point pre, int Dir)
{
	struct point visit_point = { row, col };
	maze[row][col] = 2;
	predecessor[row][col] = Dir;
	push(visit_point);
}

int main()
{
	struct point p = { 0, 0 };
	maze[p.row][p.col] = 2;
	push(p);

	while (!is_empty()) {
		p = pop();
		if (p.row == MAX_ROW - 1 && p.col == MAX_COL - 1)
			break;
		if (p.col + 1 < MAX_COL && maze[p.row][p.col + 1] == 0)
			visit(p.row, p.col + 1, p, LEFT);
		if (p.row + 1 < MAX_ROW && maze[p.row + 1][p.col] == 0)
			visit(p.row + 1, p.col, p, UP);
		if (p.col > 0 && maze[p.row][p.col - 1] == 0)
			visit(p.row, p.col - 1, p, RIGHT);
		if (p.row > 0 && maze[p.row - 1][p.col] == 0)
			visit(p.row - 1, p.col, p, DOWN);
		print_maze();
	}
	if (p.row == MAX_ROW - 1 && p.col == MAX_COL - 1) {
		printf("(%d, %d)\n", p.row, p.col);
		while (predecessor[p.row][p.col] != 0) {
			switch (predecessor[p.row][p.col]) {
			case UP:
				p.row -= 1;
				break;
			case DOWN:
				p.row += 1;
				break;
			case LEFT:
				p.col -= 1;
				break;
			case RIGHT:
				p.col += 1;
				break;
			}
			// p = predecessor[p.row][p.col];
			printf("(%d, %d)\n", p.row, p.col);
		}
	} else
		printf("No path!\n");
	return 0;
}
起先设置predecessor的初始值都是0，最终找到的路径上点到predecessor的值则为LEFT/UP/RIGHT/DOWN，因此沿着已知的方向依次判断下个座标点到位置，直到preecessor值=0的起点。


更进一步，我想，predecessor和maze都是2维整形数组，为什么不能把两者合并呢？于是修改如下：（为了防止数据混淆，修改原来到宏定义）

#include <stdio.h>
#define MAX_ROW 5
#define MAX_COL 5
#define RIGHT	3
#define LEFT	4
#define UP	5
#define DOWN	6

struct point {
	int row;
	int col;
} stack[512];
int top = 0;

int maze[5][5] = {
	{0, 0, 0, 0, 0},
	{1, 0, 1, 1, 0},
	{0, 0, 1, 1, 1},
	{0, 1, 0, 0, 0},
	{0, 0, 0, 1, 0}
};

void push(struct point p)
{
	stack[top++] = p;
}

struct point pop()
{
	return stack[--top];
}

int is_empty()
{
	return top == 0;
}

void print_maze(void)
{
	int i, j;
	for (i = 0; i < MAX_ROW; i++) {
		for (j = 0; j < MAX_COL; j++)
			printf("%d ", maze[i][j]);
		putchar('\n');
	}
	printf("*********\n");
}

/*
int predecessor[MAX_ROW][MAX_COL] = {
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0},
	{0, 0, 0, 0, 0}
};
*/

void visit(int row, int col, struct point pre, int Dir)
{
	struct point visit_point = { row, col };
	maze[row][col] = Dir;
	// predecessor[row][col] = Dir;
	push(visit_point);
}

int main()
{
	struct point p = { 0, 0 };
	maze[p.row][p.col] = 2;	// 起始点的方向设置为2，代表无方向。
	push(p);

	while (!is_empty()) {
		p = pop();
		if (p.row == MAX_ROW - 1 && p.col == MAX_COL - 1)
			break;
		if (p.col + 1 < MAX_COL && maze[p.row][p.col + 1] == 0)
			visit(p.row, p.col + 1, p, LEFT);
		if (p.row + 1 < MAX_ROW && maze[p.row + 1][p.col] == 0)
			visit(p.row + 1, p.col, p, UP);
		if (p.col > 0 && maze[p.row][p.col - 1] == 0)
			visit(p.row, p.col - 1, p, RIGHT);
		if (p.row > 0 && maze[p.row - 1][p.col] == 0)
			visit(p.row - 1, p.col, p, DOWN);
		print_maze();
	}	// 倘若有路径，那么最后pop出的p即（4，4）
	if (p.row == MAX_ROW - 1 && p.col == MAX_COL - 1) {
		printf("(%d, %d)\n", p.row, p.col);
		// 起点的方向是2，其他皆为1/3/4/5/6
		// 0代表尚未访问到点：当第一条路径就打到终点时，其它路径也就没有再访问了
		while (maze[p.row][p.col] != 2) {	
			switch (maze[p.row][p.col]) {
			case UP:
				p.row -= 1;
				break;
			case DOWN:
				p.row += 1;
				break;
			case LEFT:
				p.col -= 1;
				break;
			case RIGHT:
				p.col += 1;
				break;
			}
			// p = predecessor[p.row][p.col];
			printf("(%d, %d)\n", p.row, p.col);
		}
	} else	// 倘若最后pop出的非（4，4），那么就没有路径
		printf("No path!\n");
	return 0;
}


3. 堆栈变递归

待续。。。


發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Re：从零开始的DS学习 十大排序算法我都整理好了

Re：從零開始的DS學習 十大排序算法我都整理好了，詳細介紹了冒泡、選擇、插入、希爾、歸併、快速、堆、計數、桶、基數、外部排序的算法流程和源碼。供讀者理解與學習，適合點贊+收藏。有什麼錯誤希望大家直接指出~ 冒泡排序 選擇排序 插入排

小明同学 付明才 2020-07-06 22:57:21

求两个长方形是否有交集

取X軸正方向指向上，Y軸正方向指向右，長方形由左下角的座標和右上角的座標表示，則現有兩個長方形分別表示爲（X11，Y11，X12，Y12）和（X21，Y21，X22，Y22）。 主要解題思路如下： 令 minX=max(X11,X21)

tdmyl 2020-07-05 22:18:38

数据结构与算法 —— Java 实现（线性表）

數據結構與算法 （Java 語言實現） —— 線性表一、Java 數組的回顧學習二、使用 OOP 編寫變長數組2.0 準備2.1 實現 add 動態添加一個元素2.2 實現 delete 刪除任意一個位置的元素2.3 實現 siz

Gorit 2020-07-05 07:51:00

算法分析与时间复杂度

算法分析的數學基礎 使用以下四個定義： 如果存在正常數c與n0，使得當N≥n0時，T(N) ≤ cf(N)，則記爲T(N) = O(f(N)). 也就是大O表示法 如果存在正常數c與n0，使得當N≥n0時，T(N) ≥ cf(N

powder_snow 2020-07-05 04:22:24

剑指offer —— 二维数组中的查找

問題描述：在一個二維數組中，每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數，輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數。 問題分析： 兩種方案： 方案一：因爲矩陣每一行從左到

IceCaptain 2020-07-04 17:21:25

数据结构与算法分析（五）--- 递推与递归 + 减治排序

文章目錄一、遞推二、遞歸三、遞歸設計---遞推實現3.1 尾遞歸四、遞歸應用示例4.1 求解最大公約數4.2 插入排序算法4.3 希爾排序算法更多文章： 人有人的思維，計算機有計算機的思維，它們很不相同。如果你要問其中最大的不同

Flow_AI 2020-07-04 03:10:00

数据结构与算法分析（三）--- 队列、栈的实现与应用

文章目錄一、隊列的實現1.1 順序隊列的實現1.2 鏈式隊列的實現二、棧的實現2.1 順序棧的實現2.2 鏈式棧的實現三、隊列與棧的STL容器3.1 隊列STL容器（C++11）3.2 棧STL容器（C++11）四、隊列與棧的應用

Flow_AI 2020-07-04 03:10:00

数据结构与算法分析（七）--- 排序算法分析 + 排序优化

文章目錄一、如何分析一個排序算法1.1 排序算法的執行效率1.2 排序算法的內存消耗1.3 排序算法的穩定性二、基礎排序算法分析2.1 插入排序算法分析2.2 冒泡排序算法分析2.3 選擇排序算法分析三、高級排序算法分析3.1 歸

Flow_AI 2020-07-04 03:09:57

数据结构与算法分析（十一）--- 平衡二叉树 + 红黑树

文章目錄一、什麼是平衡二叉查找樹1.1 AVL如何維護二叉樹的平衡1.2 左旋與右旋操作1.3 實現平衡的四種情況二、什麼是紅黑樹2.1 如何定義一棵紅黑樹？2.2 爲什麼說紅黑樹是“近似平衡”的？三、實現紅黑樹的基本思想3.1

Flow_AI 2020-07-04 03:09:56

数据结构与算法分析（六）--- 分治与减治 + 分治排序与二分查找

文章目錄一、分治算法1.1 分治與減治1.2 歸併排序二、快速排序2.1 C標準庫函數qsort三、二分查找3.1 查找第K大的元素值3.2 C標準庫函數bsearch更多文章： 一、分治算法 分治（divide and conq

Flow_AI 2020-07-04 03:09:55

一周一论文（翻译）——[Acta 1996] The Log-Structured Merge-Tree (LSM-Tree)

Abstract 高性能事務系統通常會通過向一個歷史表中插入記錄以追蹤各項活動行爲；與此同時事務系統也會因系統恢復的需要而生成日誌記錄。這兩種類型的生成信息都可以從高效的索引方式中獲益。衆所周知的一個例子，TPC-A benchmark{

MasterT-J 2020-07-04 00:50:04

什么是平衡二叉树 AVL

淺顯定義："平衡"二字表明根節點的左右子樹高度差不會太大（>1），成平衡狀態。 準確定義：它是一棵空樹或它的左右兩個子樹的高度差的絕對值不超過1，並且左右兩個子樹都是一棵平衡二叉樹。 作用？如何實現？如何是否爲平衡二叉樹？  

cxm1995 2020-07-04 00:09:41

选择排序原理及实现

選擇排序實現是每趟將循環的一一個數據與後面的數據相比較，得到最小元素，存儲在循環開始出，然後接着重複執行。 實現： public class Test{ public static void main(String[] args){

HUT_jing 2020-07-03 20:59:11

Re：从零开始的DS生活 图论学这一篇就够了

引言：Re：從零開始的DS生活 圖論學這一篇就夠了，詳細介紹了圖的基本概念;圖的存儲結構,鄰接矩陣,鄰接表;圖的遍歷,廣度度優先遍歷和深度優先遍歷;最小生成樹基本概念,Prim算法,Kruskal算法;最短路徑問題,Dijkstra算法

小明同学 付明才 2020-07-01 17:11:50

LeetCode题解-接雨水Python实现

LeetCode題解-接雨水一、題目描述二、題解實現1. 方法一-暴力求解1.1 解題思路1.2 代碼實現1.3 複雜度分析2. 方法二-動態規劃2.1 解題思路2.2 代碼實現2.3 複雜度分析3. 方法三-雙指針法3.1 解

算法之美DL 2020-07-01 16:33:10