雙向量表雙向迴圈連結串列

阿新 • • 發佈：2018-12-24

雙向連結串列：有兩個位置指標，一個指向前一個，一個指向後一個。

標頭檔案：

#ifndef _LINKLIST_H
#define _LINKLIST_H

#define FAILURE    10000
#define SUCCESS    10001
#define TRUE       10002
#define FALSE      10003

typedef int ElemType; 

struct node     //雙向連結串列
{
	ElemType data;   //資料域
	struct node *next;   //指標域   指向下一個
	struct node *prior;           //指向前一個
};

typedef struct node Node;

int LinkInit(Node **l);
int LinkInsert(Node *l, int n, ElemType e);
int LinkTraverse(Node *l, void (*p)(ElemType));
int LinkLength(Node *l);
int LinkEmpty(Node *l);
int GetElem(Node *l, int p, ElemType *e);
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType));
int LinkDelete(Node *l, int p, ElemType *e);
int LinkClear(Node *l);
int LinkDestroy(Node **l);

#endif

函式檔案：

#include "LinkList.h"
#include <stdlib.h>
#include <stdio.h>

int LinkInit(Node **l)
{
	*l = (Node *)malloc(sizeof(Node) * 1);   //分配頭結點   l 就是頭指標
	if (NULL == *l)
	{
		return FAILURE;
	}

	(*l)->next = NULL;    //頭結點指標域為空
	(*l)->prior = NULL;   //雙向連結串列，頭結點prior指標為空

	return SUCCESS;
}

int LinkInsert(Node *l, int n, ElemType e)  //n 插入的位置
{
	Node *p = l;
	int k = 1;   //k 移動的次數

	if (NULL == l)
	{
		return FAILURE;
	}

	while (k < n && p != NULL)
	{
		p = p->next;
		k++;
	}

	if (k > n || p == NULL)
	{
		return FAILURE;
	}

	Node *q = (Node *)malloc(sizeof(Node) * 1);
	if (NULL == q)
	{
		return FAILURE;
	}

	q->data = e;
	q->prior = p;
	q->next = p->next;
	p->next = q;
	if (NULL != q->next)    //如果q不是最後一個結點
	{
		q->next->prior = q;
	}

	return SUCCESS;
}

int LinkTraverse(Node *l, void (*p)(ElemType))
{
	if (NULL == l)
	{
		return FAILURE;
	}
	Node *q = l;

	while (q->next)
	{
		q = q->next;
		p(q->data);
	}

	return SUCCESS;
}

int LinkLength(Node *l)
{
	if (NULL == l)
	{
		return FAILURE;
	}

	int len = 0;
	Node *p = l->next;

	while (p)
	{
		len++;
		p = p->next;
	}

	return len;
}

int LinkEmpty(Node *l)
{
	return (l->next == NULL) ? TRUE : FALSE;
}

int GetElem(Node *l, int p, ElemType *e)    //p 位置
{
	if (NULL == l || p < 1)   //入參判斷  p不能小於0
	{
		return FAILURE;
	}

	Node *q = l;
	int i;

	for (i = 0; i < p && q != NULL; i++)    //迴圈p次，同時滿足q不為空
	{
		q = q->next;
	}

	if (!q)      //如果q為空，說明p（位置）大於長度
	{
		return FAILURE;
	}

	*e = q->data;     //q已經指向第p個結點

	return SUCCESS;
}

int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType))
{
	if (NULL == l)
	{
		return FAILURE;
	}
	
	Node *q = l->next;
	int len = 1;

	while (q)
	{
		if (p(e, q->data) == TRUE)
		{
			return len;
		}
		q = q->next;
		len++;
	}

	return FAILURE;
}

int LinkDelete(Node *l, int p, ElemType *e)
{
	int k = 1;
	Node *q = l;

	if (l == NULL)
	{
		return FAILURE;
	}

	while (k < p && q != NULL)
	{
		q = q->next;
		k++;
	}

	if (k > p || q == NULL)
	{
		return FAILURE;
	}

	Node *n = q->next;
	*e = n->data;
	q->next = n->next;   
	if (n->next != NULL)     //如果不是最後一個  
	{
		n->next->prior = q;
	}
	free(n);

	return SUCCESS;
}

int LinkClear(Node *l)
{
	if (NULL == l)
	{
		return FAILURE;
	}

	Node *p = l->next;

	while (p)
	{
		l->next = p->next;
		//p->next->prior = l;
		free(p);
		p = l->next;
	}

	return SUCCESS;
}

int LinkDestroy(Node **l)
{
	if (l == NULL)
	{
		return FAILURE;
	}
	free(*l);
	(*l) = NULL;

	return SUCCESS;
}

int LinkReverse(Node **l)
{
	if (NULL == l)
	{
		return FAILURE;
	}

	/*Node *p = l->next;
	l->next = NULL;

	while (p != NULL)
	{
		Node *q = p;
		p = p->next;
		q->next = l->next;
		q->prior = l;
		l->next = q; 
	}*/

	Node *p = (*l)->next;
	Node *tmp;

	if (p == NULL)
	{
		return FAILURE;
	}

	if (p->next == NULL)
	{
		return FAILURE;
	}

	printf("xxxxx\n");
	while (p->next != NULL)
	{
		tmp = p->next;
		p->next = p->prior;
		p->prior = tmp;
		p = p->next;
	}
	
	printf("%d\n", p->data);
	tmp = p->next;
	p->next = p->prior;
	p->prior = (*l);

	(*l)->next = p;
	

	return SUCCESS;
}

測試檔案：

#include "LinkList.h"
#include <stdio.h>

void print(ElemType e)
{
	printf("%d ", e);
}

int equal(ElemType e1, ElemType e2)
{
	return (e1 == e2) ? TRUE : FALSE;
}
	

int main()
{
	int ret, i;
	Node *first = NULL;   //頭指標

	srand(time(NULL));

	ret = LinkInit(&first);
	if (ret == FAILURE)
	{
		printf("Init Failure!\n");
	}
	else
	{
		printf("Init Success!\n");
	}

	for (i = 0; i < 10; i++)
	{
		ret = LinkInsert(first, i + 1, rand() % 20);
		if (ret == FAILURE)
		{
			printf("Insert Failure!\n");
		}
		else
		{
			printf("Insert Success!\n");
		}
	}

	ret = LinkTraverse(first, print);
	if (ret == FAILURE)
	{
		printf("\nTraverse Falure!\n");
	}
	else
	{
		printf("\nTraverse Success!\n");
	}

	/*ret = LinkReverse(&first);
	if (ret == SUCCESS)
	{
		printf("Reverse Success!\n");
	}
	else
	{
		printf("Reverse Failure!\n");
	}

	ret = LinkTraverse(first, print);
	if (ret == FAILURE)
	{
		printf("\nTraverse Falure!\n");
	}
	else
	{
		printf("\nTraverse Success!\n");
	}*/


	ret = LinkLength(first);
	if (ret == FAILURE)
	{
		printf("Get Length Failure!\n");
	}
	else
	{
		printf("length %d\n", ret);
	}

	ret = LinkEmpty(first);
	if (ret == TRUE)
	{
		printf("List is empty!\n");
	}
	else if (ret == FALSE)
	{
		printf("List is not empty!\n");
	}

	int p = 10;
	ElemType e;
	ret = GetElem(first, p, &e);
	if (ret == FAILURE)
	{
		printf("Get element failure!\n");
	}
	else
	{
		printf("The %dth element is %d\n", p, e);
	}

	e = 10;
	ret = LocateElem(first, e, equal);
	if (FAILURE == ret)
	{
		printf("%d not exist!\n", e);
	}
	else
	{
		printf("%d is %dth element!\n", e, ret);
	}

	p = 10;
	ret = LinkDelete(first, p, &e);
	if (ret == FAILURE)
	{
		printf("Delete Failure!\n");
	}
	else
	{
		printf("Delete %d Success!\n", e);
	}

	ret = LinkTraverse(first, print);
	if (ret == FAILURE)
	{
		printf("\nTraverse Falure!\n");
	}
	else
	{
		printf("\nTraverse Success!\n");
	}

	ret = LinkClear(first);
	if (ret == SUCCESS)
	{
		printf("Clear Success!\n");
	}
	else
	{
		printf("Clear Failure!\n");
	}

	ret = LinkTraverse(first, print);
	if (ret == FAILURE)
	{
		printf("\nTraverse Falure!\n");
	}
	else
	{
		printf("\nTraverse Success!\n");
	}

	ret = LinkDestroy(&first);
	if (ret == SUCCESS)
	{
		printf("Destroy Success!\n");
	}
	else
	{
		printf("Destroy Failure!\n");
	}

	for (i = 0; i < 10; i++)
	{
		ret = LinkInsert(first, i + 1, rand() % 20);
		if (ret == FAILURE)
		{
			printf("Insert Failure!\n");
		}
		else
		{
			printf("Insert Success!\n");
		}
	}

	return 0;
}

雙向迴圈連結串列：

標頭檔案：

#ifndef _LINKLIST_H
#define _LINKLIST_H

#define FAILURE    10000
#define SUCCESS    10001
#define TRUE       10002
#define FALSE      10003

typedef int ElemType; 

struct node     //雙向迴圈連結串列
{
	ElemType data;   //資料域
	struct node *next;   //指標域   指向下一個
	struct node *prior;           //指向前一個
};

typedef struct node Node;

int LinkInit(Node **l);
int LinkInsert(Node *l, int n, ElemType e);
int LinkTraverse(Node *l, void (*p)(ElemType));
int LinkLength(Node *l);
int LinkEmpty(Node *l);
int GetElem(Node *l, int p, ElemType *e);
int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType));
int LinkDelete(Node *l, int p, ElemType *e);
int LinkClear(Node *l);
int LinkDestroy(Node **l);

#endif

函式檔案：

#include "LinkList.h"
#include <stdlib.h>
#include <stdio.h>

int LinkInit(Node **l)
{
	*l = (Node *)malloc(sizeof(Node) * 1);   //分配頭結點   l 就是頭指標
	if (NULL == *l)
	{
		return FAILURE;
	}

	(*l)->next = (*l);    //頭結點指標域為空
	(*l)->prior = (*l);   //雙向連結串列，頭結點prior指標為空 **

	return SUCCESS;
}

int LinkInsert(Node *l, int n, ElemType e)  //n 插入的位置
{
	Node *p = l;
	int k = 1;   //k 移動的次數

	if (NULL == l)    //入參判斷
	{
		return FAILURE;
	}

	if (n > LinkLength(l) + 1)    //**
	{
		return FAILURE;
	}

	while (k < n)     //***
	{
		p = p->next;
		k++;
	}


	if (k > n)    //**
	{
		return FAILURE;
	}

	Node *q = (Node *)malloc(sizeof(Node) * 1);
	if (NULL == q)
	{
		return FAILURE;
	}


	q->data = e;
	q->prior = p;
	q->next = p->next;
	p->next = q;
	if (l != q->next)    //如果q不是最後一個結點 **
	{
		q->next->prior = q;
	}

	return SUCCESS;
}

int LinkTraverse(Node *l, void (*p)(ElemType))
{
	if (NULL == l)
	{
		return FAILURE;
	}
	Node *q = l;

	while (q->next != l)     //不等於本身  **
	{
		q = q->next;
		p(q->data);
	}

	return SUCCESS;
}

int LinkLength(Node *l)
{
	if (NULL == l)
	{
		return FAILURE;
	}

	int len = 0;
	Node *p = l->next;

	while (p != l)   //不等於本身 **
	{
		len++;
		p = p->next;
	}

	return len;
}

int LinkEmpty(Node *l)
{
	return (l->next == l && l->prior == l) ? TRUE : FALSE;  //**
}

int GetElem(Node *l, int p, ElemType *e)    //p 位置
{
	if (NULL == l || p < 1)   //入參判斷  p不能小於0
	{
		return FAILURE;
	}

	Node *q = l->next;   //雙向迴圈連結串列，q指向第一個結點  //**
	int i;

	for (i = 1; i < p && q != l; i++)    //迴圈p次，同時滿足q不為空  雙向迴圈連結串列 i = 1**
	{
		q = q->next;
	}

	if (q == l)      //如果q為空，說明p（位置）大於長度  **
	{
		return FAILURE;
	}

	*e = q->data;     //q已經指向第p個結點

	return SUCCESS;
}

int LocateElem(Node *l, ElemType e, int (*p)(ElemType, ElemType))
{
	if (NULL == l)
	{
		return FAILURE;
	}
	
	Node *q = l->next;
	int len = 1;

	while (q != l)     //雙向迴圈連結串列  **
	{
		if (p(e, q->data) == TRUE)
		{
			return len;
		}
		q = q->next;
		len++;
	}

	return FAILURE;
}

int LinkDelete(Node *l, int p, ElemType *e)
{
	int k = 1;
	Node *q = l;

	if (l == NULL)
	{
		return FAILURE;
	}

	if (p > LinkLength(l) + 1)   //判斷位置p是否合法  **
	{
		return FAILURE;
	}

	while (k < p)  //**
	{
		q = q->next;
		k++;
	}

	if (k > p)  //**
	{
		return FAILURE;
	}

	Node *n = q->next;
	*e = n->data;
	q->next = n->next;   
					     //如果不是最後一個  **

	n->next->prior = q;
	free(n);

	return SUCCESS;
}

int LinkClear(Node *l)
{
	if (NULL == l)
	{
		return FAILURE;
	}

	Node *p = l->next;

	while (p != l)  //**
	{
		l->next = p->next;
		//p->next->prior = l;
		free(p);
		p = l->next;
	}

	l->prior = l;   //**

	return SUCCESS;
}

int LinkDestroy(Node **l)
{
	if (l == NULL)
	{
		return FAILURE;
	}
	free(*l);
	(*l) = NULL;

	return SUCCESS;
}

#if 0
int LinkReverse(Node **l)
{
	if (NULL == l)
	{
		return FAILURE;
	}

	/*Node *p = l->next;
	l->next = NULL;

	while (p != NULL)
	{
		Node *q = p;
		p = p->next;
		q->next = l->next;
		q->prior = l;
		l->next = q; 
	}*/

	Node *p = (*l)->next;
	Node *tmp;

	if (p == NULL)
	{
		return FAILURE;
	}

	if (p->next == NULL)
	{
		return FAILURE;
	}

	printf("xxxxx\n");
	while (p->next != NULL)
	{
		tmp = p->next;
		p->next = p->prior;
		p->prior = tmp;
		p = p->next;
	}
	
	printf("%d\n", p->data);
	tmp = p->next;
	p->next = p->prior;
	p->prior = (*l);

	(*l)->next = p;
	

	return SUCCESS;
}
#endif

測試檔案：

#include "LinkList.h"
#include <stdio.h>

void print(ElemType e)
{
	printf("%d ", e);
}

int equal(ElemType e1, ElemType e2)
{
	return (e1 == e2) ? TRUE : FALSE;
}
	

int main()
{
	int ret, i;
	Node *first = NULL;   //頭指標

	srand(time(NULL));

	ret = LinkInit(&first);
	if (ret == FAILURE)
	{
		printf("Init Failure!\n");
	}
	else
	{
		printf("Init Success!\n");
	}

	for (i = 0; i < 10; i++)
	{
		ret = LinkInsert(first, i + 1, rand() % 20);
		if (ret == FAILURE)
		{
			printf("Insert Failure!\n");
		}
		else
		{
			printf("Insert Success!\n");
		}
	}

	ret = LinkTraverse(first, print);
	if (ret == FAILURE)
	{
		printf("\nTraverse Falure!\n");
	}
	else
	{
		printf("\nTraverse Success!\n");
	}

	/*ret = LinkReverse(&first);
	if (ret == SUCCESS)
	{
		printf("Reverse Success!\n");
	}
	else
	{
		printf("Reverse Failure!\n");
	}

	ret = LinkTraverse(first, print);
	if (ret == FAILURE)
	{
		printf("\nTraverse Falure!\n");
	}
	else
	{
		printf("\nTraverse Success!\n");
	}*/


	ret = LinkLength(first);
	if (ret == FAILURE)
	{
		printf("Get Length Failure!\n");
	}
	else
	{
		printf("length %d\n", ret);
	}

	ret = LinkEmpty(first);
	if (ret == TRUE)
	{
		printf("List is empty!\n");
	}
	else if (ret == FALSE)
	{
		printf("List is not empty!\n");
	}

	int p = 10;
	ElemType e;
	ret = GetElem(first, p, &e);
	if (ret == FAILURE)
	{
		printf("Get element failure!\n");
	}
	else
	{
		printf("The %dth element is %d\n", p, e);
	}

	e = 10;
	ret = LocateElem(first, e, equal);
	if (FAILURE == ret)
	{
		printf("%d not exist!\n", e);
	}
	else
	{
		printf("%d is %dth element!\n", e, ret);
	}

	p = 1;
	ret = LinkDelete(first, p, &e);
	if (ret == FAILURE)
	{
		printf("Delete Failure!\n");
	}
	else
	{
		printf("Delete %d Success!\n", e);
	}

	ret = LinkTraverse(first, print);
	if (ret == FAILURE)
	{
		printf("\nTraverse Falure!\n");
	}
	else
	{
		printf("\nTraverse Success!\n");
	}

	ret = LinkClear(first);
	if (ret == SUCCESS)
	{
		printf("Clear Success!\n");
	}
	else
	{
		printf("Clear Failure!\n");
	}

	ret = LinkEmpty(first);
	if (ret == TRUE)
	{
		printf("List is empty!\n");
	}
	else if (ret == FALSE)
	{
		printf("List is not empty!\n");
	}

	ret = LinkDestroy(&first);
	if (ret == SUCCESS)
	{
		printf("Destroy Success!\n");
	}
	else
	{
		printf("Destroy Failure!\n");
	}

	for (i = 0; i < 10; i++)
	{
		ret = LinkInsert(first, i + 1, rand() % 20);
		if (ret == FAILURE)
		{
			printf("Insert Failure!\n");
		}
		else
		{
			printf("Insert Success!\n");
		}
	}

	return 0;
}

雙向量表雙向迴圈連結串列

雙向連結串列：有兩個位置指標，一個指向前一個，一個指向後一個。標頭檔案： #ifndef _LINKLIST_H #define _LINKLIST_H #define FAILURE 10000 #define SUCCESS 10001 #define TRUE

java中的順序連結串列，單鏈表，雙鏈表，迴圈連結串列

今天昨天學了集合框架，但是在List介面下有兩個子類涉及到了連結串列，書上又提到了一個關鍵的詞“雙向迴圈連結串列”，折騰了一整天終於搞懂了。首先我們得明白什麼是連結串列，連結串列是環環相扣的一組資料，而我們常用的陣列就是一組順序連結串列，在分配記憶體時記憶體將對陣列分配一組”連續的記憶體空間“

【資料結構與演算法】之單鏈表、雙鏈表、迴圈連結串列的基本介紹及其Java程式碼實現---第三篇

一、連結串列的基本介紹連結串列的定義：連結串列是一種遞迴的資料結構，它或者為空(null)，或者是指向一個結點(node)的引用，該結點含有一個泛型的元素和一個指向另一條連結串列的引用。----Algorithms Fourth Edition 常見的連結串

資料結構學習心得——雙鏈表和迴圈連結串列

雙鏈表若要尋查結點的前驅，則需要從表頭指標出發。為了克服單鏈表這種單向性的缺點，可以利用雙鏈表。顧名思義，在雙鏈表的結點中有兩個指標域，其一指向直接後繼，另一指向直接前驅。迴圈連結串列迴圈連結串列是另一種形式的鏈式儲存結構。它的特點是表中最後

C++ 雙向迴圈連結串列（簡稱：雙鏈表）

一、概念 1.在雙鏈表中的每個結點應有兩個連結指標： lLink -> 指向前驅結點&nb

資料結構與演算法（五）-線性表之雙向連結串列與雙向迴圈連結串列

前言：前面介紹了迴圈連結串列，雖然迴圈連結串列可以解決單鏈表每次遍歷只能從頭結點開始，但是對於查詢某一節點的上一節點，還是頗為複雜繁瑣，所以可以在結點中加入前一個節點的引用，即雙向連結串列一、簡介　　雙向連結串列：在連結串列中，每一個節點都有對上一個節點和下一個節點的引用或指標，即從一個節點出發可以有

資料結構導論-2.4 線性表的鏈式儲存之迴圈連結串列與雙向迴圈連結串列

迴圈連結串列與雙向迴圈連結串列一、迴圈連結串列 1.思路對於單鏈表而言，最後一個結點的指標域是空指標，如果將該連結串列頭指標置入該指標域，則使得連結串列頭尾結點相連，就構成了單迴圈連結串列。 2.特點無須增加儲存量，僅對錶的連結方式稍作改變，即可使得表處理更加

詳述線性表（單鏈表，雙鏈表，靜態連結串列和迴圈連結串列）

線性表：由零個或多個數據元素組成的有限序列。關鍵點：有限序列第一個元素有且僅有一個前驅結點，最後一個與元素有且僅有一個後繼結點，中間元素有一個前驅結點和一個後繼結點線性表

單鏈表改為雙向迴圈連結串列

package Linear; /* * 將單鏈表（結點有2個域pre，next，pre為空）改為雙向迴圈連結串列 */ public class I { public static void doubleDirection(Node h) { Node p =h.next; No

單鏈表，迴圈連結串列，雙鏈表及其基本操作（C++實現）

最近在學習嚴蔚敏教授的《資料結構》，有一些感想，在這裡寫下來，留做筆記，希望能對以後學習有所幫助。我們知道，線性表就是n個數據元素的有限序列，它有兩種實現方式，其一為順序表，即陣列+偽指標的方式實現，另一為連結串列，採用的是指標的方式實現。由於順序表的知識

單鏈表，迴圈連結串列和雙向連結串列

單鏈表：　　一.單鏈表與順序表相比：　　　1.順序表可以方便的隨機存取表中的任一節點，速度快；但是在表中插入刪除一個數據時，為了保持其他元素的相對次序不變，平均需要移動一半的元素，效率很低；還有若事先對錶長估計不足，過小會形成記憶體浪費，過大則需要拷貝到一個更大的陣列，時間開

資料結構之線性表（順序表，單鏈表，迴圈連結串列，雙向連結串列）-- 圖書管理系統

順序表 #include <iostream> #include <cstring> #include <cstdlib>///exit()標頭檔案exit(0):正常執行程式並退出程式。exit(1):非正常執行導致退出程式 #incl

C語言_雙向迴圈連結串列的基本操作

目錄： 1、初始化 2、頭部插入 3、頭部刪除 4、尾部插入 5、尾部刪除 6、列印連結串列 7、任意位置插入 8、查詢值為data的節點 9、指定位置刪除 10、銷燬連結串列 ###1、初始化：建立一個節點，給節點賦值為0；因為是迴圈連結串列，所以讓它的_pNext

實驗三：用雙鏈表、靜態連結串列以及間接定址實現基本的學生管理系統

實驗目的：鞏固線性表的資料的儲存方法和相關操作，學會針對具體應用，使用線性表的相關知識來解決具體問題。實驗內容：建立一個由n個學生成績的線性表，n的大小由自己確定，每個學生的成績資訊由自己確定，實現資料的對錶進行插入、刪除、查詢等操作。（1）用雙鏈表實現源程式： #incl

java建立雙向迴圈連結串列

/** * */ /** * @author jueying: * @version 建立時間：2018-10-23 下午01:26:47 * 類說明 */ /** * @author jueying * */ public class Test6 {

資料結構之雙向迴圈連結串列基本操作

#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<string.h>#define TRUE 1#define OK 1#define FALSE 0#define ERROR 0#def

雙向迴圈連結串列的實現

頭結點不位於連結串列裡面，只是用於定位，和核心連結串列不同。將LinuxList.h新增到我們的工程中。再新增一個DualCircleList.h檔案：測試程式如下：執行結果如下：使用以下程式訪問會得到死迴圈：因為當前是一個雙向迴圈連結串列。小結：思考題： .

雙向迴圈連結串列的排序

//排序 void sort(dlist_t head) { dlist_t tmp = head->next,p = NULL,q = NULL; //將連結串列置空 head->next = head; head->pr

UVa11925 生成排列（Generating Permutations）---雙向迴圈連結串列

題目描述：給你一個特定序列，要求你經過一定的變換規則將升序列變為給的特定序列。 https://vjudge.net/problem/UVA-11925 變換規則為：1.第一個元素和第二個元素交換. 2、首元素到尾部。題目分析：逆著處理，最後輸出的時候倒著輸出就行了。若第一個元素大於第

資料結構-----雙向迴圈連結串列

瞎扯:白天被迫改一個重現都無法重現的錯誤.各種百度，各種測試,頭髮掉了一地，然鵝還是沒解決出來。所以晚上覆習資料結構放鬆一下 DualCircleLinkList.h的程式碼(你也可以省略函式宣告) typedef int st

雙向量表 雙向迴圈連結串列

相關推薦

雙向量表雙向迴圈連結串列