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