diff --git a/README.md b/README.md index 5b0ef81..bb0b515 100644 --- a/README.md +++ b/README.md @@ -8,7 +8,7 @@ - [`DataStructure`**（数据结构）**](数据结构/) - [x] 数据结构1800题 - [ ] 数据结构1800题分题目详解 - - [x] 严版教材PPT&课后习题答案 + - [x] 严版教材PPT&课后习题答案&书中算法 - [x] 王道考研数据结构PPT - [x] 冒泡排序 - [x] 王道数据结构思维导图 diff --git a/数据结构/README.md b/数据结构/README.md index b0f409b..c826131 100644 --- a/数据结构/README.md +++ b/数据结构/README.md @@ -1,7 +1,7 @@ - [x] 数据结构1800题 - [ ] 数据结构1800题分题目详解 - [x] 王道数据结构课件 -- [x] 严版教材PPT&课后习题答案 +- [x] 严版教材PPT&课后习题答案&书中算法 - [x] 冒泡排序 - [x] 王道数据结构思维导图 - [x] 时间复杂度 diff --git a/数据结构/严版教材/数据结构实验1必做部分OJ版-配套实验.pdf b/数据结构/严版教材/数据结构实验1必做部分OJ版-配套实验.pdf new file mode 100644 index 0000000..ab0e3ac Binary files /dev/null and b/数据结构/严版教材/数据结构实验1必做部分OJ版-配套实验.pdf differ diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.1-2.5/2.1-2.5.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.1-2.5/2.1-2.5.cpp new file mode 100644 index 0000000..de21bef --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.1-2.5/2.1-2.5.cpp @@ -0,0 +1,171 @@ +#include +#include +#include +#include +using namespace std; +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef int Status; //Status ǺֵֵͣǺ״̬롣 +typedef int ElemType; //ElemType ΪɶͣΪint + +#define MAXSIZE 100 //˳ܴﵽ󳤶 +struct Book { + string id;//ISBN + string name;// + double price;// +}; +typedef struct { + Book *elem; //洢ռĻַ + int length; //ǰ +} SqList; + +Status InitList_Sq(SqList &L) { //㷨2.1 ˳ijʼ + //һյ˳L + L.elem = new Book[MAXSIZE]; //Ϊ˳һСΪMAXSIZEռ + if (!L.elem) + exit(OVERFLOW); //洢ʧ˳ + L.length = 0; //ձΪ0 + return OK; +} + +Status GetElem(SqList L, int i, Book &e) {//㷨2.2˳ȡֵ + if (i < 1 || i > L.length) + return ERROR; //жiֵǷERROR + e = L.elem[i - 1]; //elem[i-1]Ԫ洢iԪ + return OK; +} + +int LocateElem_Sq(SqList L, double e) { //㷨2.3 ˳IJ + //˳IJ + for (int i = 0; i < L.length; i++) + if (L.elem[i].price == e) + return i + 1;//ҳɹi+1 + return 0;//ʧܣ0 +} + +Status ListInsert_Sq(SqList &L, int i, Book e) { //㷨2.4 ˳IJ + //˳Lеiλ֮ǰµԪe + //iֵĺϷΧ1<=i<=L.length+1 + if ((i < 1) || (i > L.length + 1)) + return ERROR; //iֵϷ + if (L.length == MAXSIZE) + return ERROR; //ǰ洢ռ + for (int j = L.length - 1; j >= i - 1; j--) + L.elem[j + 1] = L.elem[j]; //λü֮Ԫغ + L.elem[i - 1] = e; //Ԫeiλ + ++L.length; //1 + return OK; +} + +Status ListDelete_Sq(SqList &L, int i) { //㷨2.5 ˳ɾ + //˳LɾiԪأeֵ + //iֵĺϷΧ1<=i<=L.length + if ((i < 1) || (i > L.length)) + return ERROR; //iֵϷ + for (int j = i; j <= L.length; j++) + L.elem[j - 1] = L.elem[j]; //ɾԪ֮Ԫǰ + --L.length; //1 + return OK; +} + +int main() { + SqList L; + int i = 0, temp, a, c, choose; + double price; + Book e; + string head_1, head_2, head_3; + cout << "1. \n"; + cout << "2. \n"; + cout << "3. ȡֵ\n"; + cout << "4. \n"; + cout << "5. \n"; + cout << "6. ɾ\n"; + cout << "7. \n"; + cout << "0. ˳\n\n"; + + choose = -1; + while (choose != 0) { + cout << "ѡ:"; + cin >> choose; + switch (choose) { + case 1://˳ + if (InitList_Sq(L)) + cout << "ɹ˳\n\n"; + else + cout << "˳ʧ\n\n"; + break; + case 2: {//˳Ϣ + i = 0; + L.elem = new Book[MAXSIZE]; + if (!L.elem) + exit(OVERFLOW); + L.length = 0; + fstream file; + file.open("book.txt"); + if (!file) { + cout << "δҵļ" << endl; + exit(ERROR); + } + file >> head_1 >> head_2 >> head_3; + while (!file.eof()) { + file >> L.elem[i].id >> L.elem[i].name >> L.elem[i].price; + i++; + } + cout << " book.txt Ϣ\n\n"; + L.length = i; + file.close(); + } + break; + case 3://˳ȡֵ + cout << "һλȡֵ\n"; + cin >> i; + temp = GetElem(L, i, e); + if (temp != 0) { + cout << "ҳɹ\n"; + cout << "" << i << "ͼϢǣ\n"; + cout << left << setw(15) << e.id << "\t" << left << setw(50) + << e.name << "\t" << left << setw(5) << e.price << endl + << endl; + } else + cout << "ʧܣλóΧ\n\n"; + break; + case 4: //˳IJ + cout << "ҪҼ۸:"; + cin >> price; + temp = LocateElem_Sq(L, price); + if (temp != 0) { + cout << "ҳɹ\n"; + cout << "ü۸ӦΪ" << L.elem[temp - 1].name << endl << endl; + } else + cout << "ʧܣû۸Ӧ鼮\n\n"; + break; + case 5: //˳IJ + cout << "λú鱾Ϣ ۸ÿո:"; + cin >> a; + cin >> e.id >> e.name >> e.price; //abaλãbֵ鱾Ϣ + if (ListInsert_Sq(L, a, e)) + cout << "ɹ.\n\n"; + else + cout << "ʧ.\n\n"; + break; + case 6: //˳ɾ + cout << "Ҫɾ鼮λ:"; + cin >> c; + if (ListDelete_Sq(L, c)) + cout << "ɾɹ.\n\n"; + else + cout << "ɾʧ.\n\n"; + break; + case 7: //˳ + cout << "ǰͼϵͳϢ˳:\n"; + for (i = 0; i < L.length; i++) + cout << left << setw(15) << L.elem[i].id << "\t" << left + << setw(50) << L.elem[i].name << "\t" << left + << setw(5) << L.elem[i].price << endl; + cout << endl; + break; + } + } + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.1-2.5/book.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.1-2.5/book.txt new file mode 100644 index 0000000..3701fc8 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.1-2.5/book.txt @@ -0,0 +1,17 @@ +ISBN +9787302257646 ƻ 25 +9787302219972 ƬӦ 32 +9787302203513 ԭ 46 +9787811234923 Գƽ̳ 21 +9787512100831 ϵͳ 17 +9787302265436 ʵָ 18 +9787302180630 ʵݽṹ 29 +9787302225065 ݽṹC԰棩 38 +9787302171676 C# 39 +9787302250692 CԳ 42 +9787302150664 ݿԭ 35 +9787302260806 Javaʵ 56 +9787302252887 JavaӦý̳ 39 +9787302198505 Ƕʽϵͳ 25 +9787302169666 24 +9787811231557 EclipseӦ 35 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.13-2.14/2.13-2.14.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.13-2.14/2.13-2.14.cpp new file mode 100644 index 0000000..f830fad --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.13-2.14/2.13-2.14.cpp @@ -0,0 +1,189 @@ +#include +#include +#include +#include +using namespace std; + +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef int Status; //Status ǺֵֵͣǺ״̬롣 +typedef int ElemType; //ElemType ΪɶͣΪint + +struct Book { + string id;//ISBN + string name;// + double price;// +}; +typedef struct DuLNode { + Book data; // + struct DuLNode *prior; //ֱǰ + struct DuLNode *next; //ֱӺ +} DuLNode, *DuLinkList; + +string head_1, head_2, head_3; +int length; + +Status InitDuList_L(DuLinkList &L) { + //һյ˫L + L = new DuLNode; //½Ϊͷ㣬ͷָLָͷ + L->next = NULL; //ͷָÿ + L->prior = NULL; + return OK; +} + +DuLNode *GetElemP_DuL(DuLinkList L, int i) { + //ڴͷ˫LвҵiԪأؽĵַ + int j; + DuLinkList p; + p = L->next; + j = 1; //ʼpָһ㣬jΪ + while (j < i && p) { //˳ɨ裬ֱpָiԪػpΪ + p = p->next; + ++j; + } + if (!p || j > i) + return NULL; //iԪز + return p; +} //GetElemP_DuL + +Status ListInsert_DuL(DuLinkList &L, int i, Book e) { //㷨2.13 ˫IJ + //ڴͷ˫Lеiλ֮ǰԪeiĺϷֵΪ1<=i<=+1 + DuLinkList s, p; + if (!(p = GetElemP_DuL(L, i))) //LȷiԪصλָp + return ERROR; //pΪNULLʱiԪز + if (i == 1) {//˫ĵһԪϲ + s = new DuLNode; //½s + s->data = e; //sΪe + DuLinkList p = L->next; + L->next = s; + s->prior = L; + s->next = p;//*sL + p->prior = s; + ++length; + } else if (i == length) {//˫һԪϲ + s = new DuLNode; //½s + s->data = e; //sΪe + DuLinkList p = L; + while (p->next) + p = p->next;//LinkList pָ˫β + p->next = s; + s->prior = p;//*s뵽pĺ棬뵽L + s->next = NULL; + ++length; + } else { + s = new DuLNode; //½*s + s->data = e; //*sΪe + s->prior = p->prior; //*sLУ˲Ӧͼ2.20 + p->prior->next = s; //Ӧͼ2.20 + s->next = p; //Ӧͼ2.20 + p->prior = s; //Ӧͼ2.20 + ++length; + } + return OK; +} //ListInsert_DuL + +Status ListDelete_DuL(DuLinkList &L, int i) { //㷨2.14 ˫ɾ + //ɾͷ˫Lеiλ֮ǰԪeiĺϷֵΪ1<=i<= + DuLinkList p; + if (!(p = GetElemP_DuL(L, i))) //LȷiԪصλָp + return ERROR; //pΪNULLʱiԪز + if (i == 1)//ɾ˫ĵһԪ + L = L->next; + else if (i == length) {//ɾ˫һԪ + p->prior->next = NULL; + delete p; + --length; + return OK; + } else { + p->prior->next = p->next; //޸ıɾǰĺָ룬Ӧͼ2.21 + p->next->prior = p->prior; //޸ıɾĺ̽ǰָ룬Ӧͼ2.21 + delete p; //ͷűɾĿռ + --length; + return OK; + } +}//ListDelete_DuL + +void CreateDuList_L(DuLinkList &L) { + //λnԪصֵͷ˫Lͬʱǰָ + DuLinkList r, p; + L = new DuLNode; + L->next = NULL; //ȽһͷĿ + r = L;//βָrָͷ + length = 0; + fstream file; + file.open("book.txt"); + if (!file) { + cout << "δҵļ޷򿪣" << endl; + exit(ERROR); + } + file >> head_1 >> head_2 >> head_3; + while (!file.eof()) { + p = new DuLNode; //½ + file >> p->data.id >> p->data.name >> p->data.price; //Ԫֵ + p->next = NULL; + r->next = p; //뵽β + r = p; //rָµβ + p->prior = L->prior; //뵽ͷ + L->prior = p; + length++; + } + file.close(); +} //CreateDuList_L + +int main() { + int a, choose; + Book e; + DuLinkList L, p; + cout << "1. \n"; + cout << "2. \n"; + cout << "3. \n"; + cout << "4. ɾ\n"; + cout << "5. \n"; + cout << "0. ˳\n\n"; + + choose = -1; + while (choose != 0) { + cout << "ѡ:"; + cin >> choose; + switch (choose) { + case 1: //һ˫ + if (InitDuList_L(L)) + cout << "ɹ˫!\n\n"; + break; + case 2: //ʹú巨˫ + CreateDuList_L(L); + cout << " book.txt Ϣ\n\n"; + break; + case 3: //˫IJ + cout << "ֱλúֵϢ&&۸:"; + cin >> a; + cin >> e.id >> e.name >> e.price; + if (ListInsert_DuL(L, a, e)) + cout << "ɹ.\n\n"; + else + cout << "ʧ!\n\n"; + break; + case 4: //˫ɾ + cout << "Ҫɾ鼮λ:"; + cin >> a; + if (ListDelete_DuL(L, a)) + cout << "ɾɹ!\n\n"; + else + cout << "ɾʧ!\n\n"; + break; + case 5: //˫ + cout << "ǰͼϵͳϢ:\n"; + p = L->next; + while (p) { + cout << left << setw(15) << p->data.id << "\t" << left << setw( + 50) << p->data.name << "\t" << left << setw(5) + << p->data.price << endl; + p = p->next; + } + cout << endl; + break; + } + } + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.13-2.14/book.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.13-2.14/book.txt new file mode 100644 index 0000000..3701fc8 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.13-2.14/book.txt @@ -0,0 +1,17 @@ +ISBN +9787302257646 ƻ 25 +9787302219972 ƬӦ 32 +9787302203513 ԭ 46 +9787811234923 Գƽ̳ 21 +9787512100831 ϵͳ 17 +9787302265436 ʵָ 18 +9787302180630 ʵݽṹ 29 +9787302225065 ݽṹC԰棩 38 +9787302171676 C# 39 +9787302250692 CԳ 42 +9787302150664 ݿԭ 35 +9787302260806 Javaʵ 56 +9787302252887 JavaӦý̳ 39 +9787302198505 Ƕʽϵͳ 25 +9787302169666 24 +9787811231557 EclipseӦ 35 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(链表)/2.15(链表).cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(链表)/2.15(链表).cpp new file mode 100644 index 0000000..97e1347 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(链表)/2.15(链表).cpp @@ -0,0 +1,109 @@ +#include +#include +#include +using namespace std; + +#define ERROR 0 + +typedef struct LNode { + int data; // + struct LNode *next; //ָ +} LNode, *List; //LinkListΪָṹLNodeָ + +int n, m; +char st = 'A'; + +void InitList(List &L) // +{ + L = new LNode; + L->next = NULL; +} + +void ListInput(List &L, int n) //ݵ +{ + int i; + List p, r; + r = L; + char filename[20] = { 0 }; + cout << "˳L" << st << "ļƣļ+.txtList" << st << ".txt" << endl; + ++st; + gets(filename); + fstream file; + file.open(filename); + if (!file) { + cout << "δҵļ޷򿪣" << endl; + exit(ERROR); + } + while (!file.eof()) { + p = new LNode; + file >> p->data; + p->next = NULL; + r->next = p; + r = p; + n++; + } + file.close(); +} + +bool LocateElem(List L, int e) //жListûeԪ +{ + List p; + p = L->next; + while (p != NULL) { + if (p->data == e) + return true; + p = p->next; + } + return false; +} + +void ListInsert(List &L, int e) //e뵽List +{ + List p; + p = new LNode; + p->data = e; + p->next = L->next; + L->next = p; +} + +void ListOutput(List L) //List +{ + List p; + p = L->next; + while (p != NULL) { + cout << p->data << " "; + p = p->next; + } + cout << endl; +} + +void unionList(List &LA, List LB) //㷨2.15 Աĺϲ +{ + //ԱLBеLAеԪز뵽LA + int e; + List p; + p = LB->next; + while (p != NULL) { + e = p->data; + if (!LocateElem(LA, e)) //LAвںeͬԪأ֮ + ListInsert(LA, e); + p = p->next; + } +} //unionList + +int main() { + List LA, LB; + + InitList(LA); + + InitList(LB); + + ListInput(LA, n); + ListInput(LB, m); + + unionList(LA, LB); + + cout << "LALBϲļΪ\n"; + ListOutput(LA); + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(链表)/ListA.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(链表)/ListA.txt new file mode 100644 index 0000000..6f2b0bc --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(链表)/ListA.txt @@ -0,0 +1 @@ +7 5 3 11 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(链表)/ListB.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(链表)/ListB.txt new file mode 100644 index 0000000..8a56b96 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(链表)/ListB.txt @@ -0,0 +1 @@ +2 6 3 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(顺序表)/2.15(顺序表).cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(顺序表)/2.15(顺序表).cpp new file mode 100644 index 0000000..1a1eb80 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(顺序表)/2.15(顺序表).cpp @@ -0,0 +1,100 @@ +#include +#include +using namespace std; +#define MAXSIZE 100 +#define ERROR 0 +typedef struct { //˳ + int *elem; + int length; +} List; +int n, m; +char st = 'A'; + +void InitList(List &L) //˳ +{ + L.elem = new int[MAXSIZE]; + L.length = 0; +} + +void ListInput(List &L, int n) //˳ݵ +{ + int i = 0; + char filename[20] = { 0 }; + cout << "˳L" << st << "ļƣļ+.txtList" << st << ".txt" << endl; + ++st; + gets(filename); + fstream file; + file.open(filename); + if (!file) { + cout << "δҵļ޷򿪣" << endl; + exit(ERROR); + } + while (!file.eof()) { + file >> L.elem[i]; + i++; + } + L.length = i; + +} + +int ListLength(List L) //˳ij +{ + return L.length; +} + +void GetElem(List L, int i, int &e) //˳ĵiԪأe +{ + e = L.elem[i - 1]; +} + +bool LocateElem(List L, int e) //жListûeԪ +{ + int i; + for (i = 0; i < L.length; i++) + if (e == L.elem[i]) + return true; + return false; +} + +void ListInsert(List &L, int e) //e뵽List +{ + L.elem[L.length] = e; + L.length++; +} + +void ListOutput(List L) //List +{ + int i; + for (i = 0; i < L.length; i++) + cout << L.elem[i] << " "; + cout << endl; +} + +void unionList(List &LA, List LB) //㷨2.14 Աĺϲ˳ +{ + //ԱLBеLAеԪز뵽LA + int LA_len, LB_len, i, e; + LA_len = ListLength(LA); + LB_len = ListLength(LB); //Աij + for (i = 1; i <= LB_len; i++) { + GetElem(LB, i, e); //ȡLBеiԪظe + if (!LocateElem(LA, e)) //LAвںeͬԪأ֮ + ListInsert(LA, e); + } +} //unionList + +int main() { + List LA, LB; + InitList(LA); + InitList(LB); + + ListInput(LA, n); + + ListInput(LB, m); + + unionList(LA, LB); + + cout << "LALBϲļΪ\n"; + ListOutput(LA); + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(顺序表)/ListA.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(顺序表)/ListA.txt new file mode 100644 index 0000000..6f2b0bc --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(顺序表)/ListA.txt @@ -0,0 +1 @@ +7 5 3 11 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(顺序表)/ListB.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(顺序表)/ListB.txt new file mode 100644 index 0000000..8a56b96 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.15(顺序表)/ListB.txt @@ -0,0 +1 @@ +2 6 3 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.16/2.16.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.16/2.16.cpp new file mode 100644 index 0000000..25081e0 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.16/2.16.cpp @@ -0,0 +1,93 @@ +#include +#include +using namespace std; +#define MAXSIZE 100 +#define ERROR 0 + +typedef struct //˳ +{ + int *elem; + int length; +} SqList; +int num_a = 0, num_b = 0; +char st = 'A'; + +void InitList_Sq(SqList &L, int n) //˳ +{ + L.elem = new int[MAXSIZE]; + if (!L.elem) + exit(0); + L.length = 0; +} + +void input(SqList &L, int n) //˳L +{ + int i = 0; + char filename[20] = { 0 }; + cout << "ǵݼԱ" << st << "ļƣļ+.txtList" << st << ".txt" << endl; + ++st; + gets(filename); + fstream file; + file.open(filename); + if (!file) { + cout << "δҵļ޷򿪣" << endl; + exit(ERROR); + } + while (!file.eof()) { + file >> L.elem[i]; + i++; + } + L.length = i; +} + +void output(SqList L) //˳ÿԪ +{ + int i; + for (i = 0; i < L.length; i++) { + if (i) + cout << ","; + cout << L.elem[i]; + } +} + +void MergeList_Sq(SqList LA, SqList LB, SqList &LC) //㷨2.16 ˳ĺϲ +{ + //֪˳LALBԪذֵǵݼ + //鲢LALBõµ˳LCLCԪҲֵǵݼ + int *pa, *pb, *pc, *pa_last, *pb_last; + pa = LA.elem; + pb = LB.elem; //ָpapbijֱֵָĵһԪ + LC.length = LA.length + LB.length; //±Ϊϲij֮ + LC.elem = new int[LC.length]; //Ϊϲ±һռ + pc = LC.elem; //ָpcָ±ĵһԪ + pa_last = LA.elem + LA.length - 1; //ָpa_lastָLAһԪ + pb_last = LB.elem + LB.length - 1; //ָpb_lastָLBһԪ + while (pa <= pa_last && pb <= pb_last) //ǿ + { + if (*pa <= *pb) //ΡժȡֵСĽ뵽LC + *pc++ = *pa++; + else + *pc++ = *pb++; + } + while (pa <= pa_last) //LBѵβνLAʣԪزLC + *pc++ = *pa++; + while (pb <= pb_last) //LAѵβνLBʣԪزLC + *pc++ = *pb++; +} //MergeList_List + +int main() { + SqList La, Lb, Lc; + + InitList_Sq(La, num_a); //LaĴ + input(La, num_a); //˳La + + InitList_Sq(Lb, num_b); //LbĴ + input(Lb, num_b); //˳La + + MergeList_Sq(La, Lb, Lc); //˳LaLbкϲ + + cout << "ǵݼԱABϲķǵݼԱCΪ\n"; //ϲ˳Lc + output(Lc); + cout << endl; + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.16/ListA.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.16/ListA.txt new file mode 100644 index 0000000..601ea4a --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.16/ListA.txt @@ -0,0 +1 @@ +3 5 8 11 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.16/ListB.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.16/ListB.txt new file mode 100644 index 0000000..f8f292f --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.16/ListB.txt @@ -0,0 +1 @@ +2 6 8 9 11 15 20 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.17/2.17.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.17/2.17.cpp new file mode 100644 index 0000000..8eb909e --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.17/2.17.cpp @@ -0,0 +1,104 @@ +#include +#include +using namespace std; +#define ERROR 0 + +typedef struct LNode //嵥 +{ + int data; + struct LNode *next; +} LNode, *LinkList; + +int num_a, num_b; +char st = 'A'; + +void InitList_L(LinkList &L) // +{ + L = new LNode; + L->next = NULL; +} + +void input(LinkList &L, int n) //L +{ + int i; + LNode *p, *r; + r = L; + char filename[20] = { 0 }; + cout << "ǵݼ" << st << "ļƣļ+.txtList" << st << ".txt" << endl; + ++st; + gets(filename); + fstream file; + file.open(filename); + if (!file) { + cout << "δҵļ޷򿪣" << endl; + exit(ERROR); + } + while (!file.eof()) { + p = new LNode; + file >> p->data; + p->next = NULL; + r->next = p; + r = p; + n++; + } + file.close(); +} + +void output(LinkList L) //ÿԪ +{ + int i = 0; + LNode *p; + p = L->next; + while (p) { + if (i) + cout << ","; + cout << p->data; + p = p->next; + i = 1; + } +} + +void MergeList_L(LinkList &LA, LinkList &LB, LinkList &LC) //㷨2.17 ʽĺϲ +{ + //֪LALBԪذֵǵݼ + //鲢LALBõµĵLCLCԪҲֵǵݼ + LinkList pa, pb, pc; + pa = LA->next; + pb = LB->next; //papbijֱֵָĵһ + LC = LA; //LAͷΪLCͷ + pc = LC; //pcijֵָLCͷ + while (pa && pb) //ǿ + { + if (pa->data <= pb->data) //"ժȡ"ֵСĽ뵽LC + { + pc->next = pa; //paָӵpcָ֮ + pc = pa; + pa = pa->next; + } else { + pc->next = pb; //pbָӵpcָ֮ + pc = pb; + pb = pb->next; + } + } + pc->next = pa ? pa : pb; //ǿձʣ + delete LB; //ͷLBͷ +} //MergeList_L() + +int main() { + LinkList La, Lb, Lc; + + InitList_L(La); //LaĴ + input(La, num_a); //La + + InitList_L(Lb); //LbĴ + input(Lb, num_b); //La + + InitList_L(Lc); + MergeList_L(La, Lb, Lc); //LaLbкϲ + + + cout << "ǵݼABϲķǵݼCΪ\n"; //ϲĵLc + output(Lc); + cout << endl; + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.17/ListA.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.17/ListA.txt new file mode 100644 index 0000000..601ea4a --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.17/ListA.txt @@ -0,0 +1 @@ +3 5 8 11 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.17/ListB.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.17/ListB.txt new file mode 100644 index 0000000..f8f292f --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.17/ListB.txt @@ -0,0 +1 @@ +2 6 8 9 11 15 20 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.18-2.19/2.18-2.19.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.18-2.19/2.18-2.19.cpp new file mode 100644 index 0000000..a8c6141 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.18-2.19/2.18-2.19.cpp @@ -0,0 +1,124 @@ +#include +#include +#include +using namespace std; +#define ERROR 0 + +typedef struct PNode { + float coef; //ϵ + int expn; //ָ + struct PNode *next; +} PNode, *Polynomial; +string head_1, head_2; +int temp; +char st = 'A'; + +void CreatPolyn(Polynomial &P, int m) //㷨2.18 ʽĴ +{ + //mϵָʾһʽP + Polynomial q, pre, s; + int i; + P = new PNode; + P->next = NULL; //Ƚһͷĵ + char filename[20] = { 0 }; + cout << "йضʽp" << char(st + 32) << "ϵָļƣļ+.txtPoly" << st << ".txt" << endl; + ++st; + gets(filename); + fstream file; + file.open(filename); + if (!file) { + cout << "δҵļ޷򿪣" << endl; + exit(ERROR); + } + file >> head_1 >> head_2; + while (!file.eof()) + { + s = new PNode; //½ + file >> s->coef >> s->expn; //Ԫֵ + pre = P; //preڱqǰֵΪͷ + q = P->next; + while (q && q->expn < s->expn) //ͨȽָҵһָq + { + pre = q; + q = q->next; + } //while + s->next = q; //s뵽qǰpre֮ + pre->next = s; + }//for + file.close(); +} //CreatPolyn + +void AddPolyn(Polynomial &Pa, Polynomial &Pb) //㷨2.19 ʽ +{ + //ʽӷPa=Pa+PbʽĽ㹹ɡͶʽ + Polynomial r, p1, p2, p3; + float sum; + p1 = Pa->next; + p2 = Pb->next; //p1p2ֱֵָPaPbĵһ + p3 = Pa; //p3ָͶʽĵǰ㣬ֵΪPa + while (p1 && p2) //p1p2ǿ + { + if (p1->expn == p2->expn) //ָ + { + sum = p1->coef + p2->coef; //sumϵ + if (sum != 0) //ϵͲΪ0 + { + p1->coef = sum; //޸Paǰp1ϵֵΪϵĺ + p3->next = p1; + p3 = p1; //޸ĺPaǰp1p3֮p3ָp1 + p1 = p1->next; //p1ָһ + r = p2; + p2 = p2->next; + delete r; //ɾPbǰr + } else //ϵΪ0 + { + r = p1; + p1 = p1->next; + delete r; //ɾPbǰp1 + r = p2; + p2 = p2->next; + delete r; //ɾPbǰp2 + } + } else if (p1->expn < p2->expn) //Paǰp1ֵָС + { + p3->next = p1; //p1p3֮ + p3 = p1; //p3ָp1 + p1 = p1->next; //p1ָһ + } else //Paǰp2ֵָС + { + p3->next = p2; //p2p3֮ + p3 = p2; //p3ָp2 + p2 = p2->next; //p2ָһ + } + } //while + p3->next = p1 ? p1 : p2; //ǿնʽʣ + delete Pb; //ͷPbͷ +} //AddPolyn + + +int main() { + Polynomial Pa, Pb; + Polynomial p; + int i; + + //ʽPa + CreatPolyn(Pa, temp); //úPaÿһϵָ + + //ʽPb + CreatPolyn(Pb, temp); //úPaÿһϵָ + + AddPolyn(Pa, Pb); + cout << "ʽPaPbӺĽǣ\n"; + p = Pa->next; + i = 0; + while (p) //ӺĽÿһx^nʾ + { + if (i) + cout << " + "; + cout << "(" << p->coef << ") * x^" << p->expn; + p = p->next; + i = 1; + } + cout << endl; + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.18-2.19/PolyA.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.18-2.19/PolyA.txt new file mode 100644 index 0000000..d5f72c1 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.18-2.19/PolyA.txt @@ -0,0 +1,5 @@ +ϵp ָ +7 0 +3 1 +9 8 +5 17 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.18-2.19/PolyB.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.18-2.19/PolyB.txt new file mode 100644 index 0000000..5100be2 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.18-2.19/PolyB.txt @@ -0,0 +1,4 @@ +ϵp ָ +8 1 +22 7 +-9 8 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.6-2.12/2.6-2.12.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.6-2.12/2.6-2.12.cpp new file mode 100644 index 0000000..c180a07 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.6-2.12/2.6-2.12.cpp @@ -0,0 +1,227 @@ +#include +#include +#include +#include +using namespace std; + +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef int Status; //Status ǺֵֵͣǺ״̬롣 +typedef int ElemType; //ElemType ΪɶͣΪint + +struct Book { + string id;//ISBN + string name;// + double price;// +}; +typedef struct LNode { + Book data; // + struct LNode *next; //ָ +} LNode, *LinkList; //LinkListΪָṹLNodeָ + +string head_1, head_2, head_3; +int length; + +Status InitList_L(LinkList &L) { //㷨2.6 ijʼ + //һյĵL + L = new LNode; //½Ϊͷ㣬ͷָLָͷ + L->next = NULL; //ͷָÿ + return OK; +} + +Status GetElem_L(LinkList L, int i, Book &e) { //㷨2.7 ȡֵ + //ڴͷĵLвҵiԪ + //eLеiԪصֵ + int j; + LinkList p; + p = L->next; + j = 1; //ʼpָһ㣬jΪ + while (j < i && p) { //˳ɨ裬ֱpָiԪػpΪ + p = p->next; //pָһ + ++j; //jӦ1 + } + if (!p || j > i) + return ERROR; //iֵϷini<=0 + e = p->data; //ȡi + return OK; +} //GetElem_L + +LNode *LocateElem_L(LinkList L, int e) { //㷨2.8 ֵ + //ڴͷĵLвֵΪeԪ + LinkList p; + p = L->next; + while (p && p->data.price != e)//˳ɨ裬ֱpΪջpָe + p = p->next; //pָһ + return p; //ҳɹֵΪeĽַpʧpΪNULL +} //LocateElem_L + +Status ListInsert_L(LinkList &L, int i, Book &e) { //㷨2.9 IJ + //ڴͷĵLеiλòֵΪe½ + int j; + LinkList p, s; + p = L; + j = 0; + while (p && j < i - 1) { + p = p->next; + ++j; + }//ҵi?1㣬pָý + if (!p || j > i - 1) + return ERROR; //in+1i1 + s = new LNode; //½*s + s->data = e; //*sΪe + s->next = p->next; //*sָָai + p->next = s; //*pָָ*s + ++length; + return OK; +} //ListInsert_L + +Status ListDelete_L(LinkList &L, int i) { //㷨2.9 ɾ + //ڴͷĵLУɾiλ + LinkList p, q; + int j; + p = L; + j = 0; + while ((p->next) && (j < i - 1)) //ҵi?1㣬pָý + { + p = p->next; + ++j; + } + if (!(p->next) || (j > i - 1)) + return ERROR; //i>ni<1ʱɾλò + q = p->next; //ʱ汻ɾĵַԱͷ + p->next = q->next; //ıɾǰָ + delete q; //ͷɾĿռ + --length; + return OK; +} //ListDelete_L + +void CreateList_H(LinkList &L, int n) { //㷨2.11 ǰ巨 + //λnԪصֵͷĵL + LinkList p; + L = new LNode; + L->next = NULL; //ȽһͷĿ + length = 0; + fstream file; + file.open("book.txt"); + if (!file) { + cout << "δҵļ޷򿪣" << endl; + exit(ERROR); + } + file >> head_1 >> head_2 >> head_3; + while (!file.eof()) { + p = new LNode; //½*p + file >> p->data.id >> p->data.name >> p->data.price; //Ԫֵ½*p + p->next = L->next; + L->next = p; //½*p뵽ͷ֮ + length++;//ͬʱȽͳ + } + file.close(); +} //CreateList_F + +void CreateList_R(LinkList &L, int n) { //㷨2.12 巨 + //λnԪصֵͷĵL + LinkList p, r; + L = new LNode; + L->next = NULL; //ȽһͷĿ + r = L; //βָrָͷ + length = 0; + fstream file; //ļжд + file.open("book.txt"); + if (!file) { + cout << "δҵļ޷򿪣" << endl; + exit(ERROR); + } + file >> head_1 >> head_2 >> head_3; + while (!file.eof()) { //ļеϢú巨뵽 + p = new LNode;//½ + file >> p->data.id >> p->data.name >> p->data.price;//Ԫֵ½*p + p->next = NULL; + r->next = p;//½*pβ*r֮ + r = p;//rָµβ*p + length++; //ͬʱȽͳ + } + file.close(); +} //CreateList_L + +int main() { + int a, n, choose; + double price; + Book e; + LinkList L, p; + cout << "1. \n"; + cout << "2. \n"; + cout << "3. ȡֵ\n"; + cout << "4. \n"; + cout << "5. \n"; + cout << "6. ɾ\n"; + cout << "7. \n"; + cout << "0. ˳\n\n"; + + choose = -1; + while (choose != 0) { + cout << "ѡ:"; + cin >> choose; + switch (choose) { + case 1: //һ + if (InitList_L(L)) + cout << "ɹ!\n\n"; + break; + case 2: //ʹú巨 + CreateList_R(L, length); + cout << " book.txt Ϣ\n\n"; + break; + case 3: //İȡֵ + cout << "һλȡֵ:"; + cin >> a; + if (GetElem_L(L, a, e)) { + cout << "ҳɹ\n"; + cout << "" << a << "ͼϢǣ\n"; + cout << left << setw(15) << e.id << "\t" << left << setw(50) + << e.name << "\t" << left << setw(5) << e.price << endl + << endl; + } else + cout << "ʧ\n\n"; + break; + case 4: //İֵ + cout << "ҪҼ۸:"; + cin >> price; + if (LocateElem_L(L, price) != NULL) { + cout << "ҳɹ\n"; + cout << "ü۸ӦΪ" << LocateElem_L(L, price)->data.name + << endl << endl; + } else + cout << "ʧ! " << price << " ûҵ\n\n"; + break; + case 5: //IJ + cout << "λúϢ ۸ÿո:"; + cin >> a; + cin >> e.id >> e.name >> e.price; + if (ListInsert_L(L, a, e)) + cout << "ɹ.\n\n"; + else + cout << "ʧ!\n\n"; + break; + case 6: //ɾ + cout << "Ҫɾ鼮λ:"; + cin >> a; + if (ListDelete_L(L, a)) + cout << "ɾɹ!\n\n"; + else + cout << "ɾʧ!\n\n"; + break; + case 7: // + cout << "ǰͼϵͳϢ:\n"; + p = L->next; + while (p) { + cout << left << setw(15) << p->data.id << "\t" << left << setw( + 50) << p->data.name << "\t" << left << setw(5) + << p->data.price << endl; + p = p->next; + } + cout << endl; + break; + } + } + return 0; +} diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.6-2.12/book.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.6-2.12/book.txt new file mode 100644 index 0000000..3701fc8 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第2章/2.6-2.12/book.txt @@ -0,0 +1,17 @@ +ISBN +9787302257646 ƻ 25 +9787302219972 ƬӦ 32 +9787302203513 ԭ 46 +9787811234923 Գƽ̳ 21 +9787512100831 ϵͳ 17 +9787302265436 ʵָ 18 +9787302180630 ʵݽṹ 29 +9787302225065 ݽṹC԰棩 38 +9787302171676 C# 39 +9787302250692 CԳ 42 +9787302150664 ݿԭ 35 +9787302260806 Javaʵ 56 +9787302252887 JavaӦý̳ 39 +9787302198505 Ƕʽϵͳ 25 +9787302169666 24 +9787811231557 EclipseӦ 35 \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.1-3.4/3.1-3.4.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.1-3.4/3.1-3.4.cpp new file mode 100644 index 0000000..0d2ca92 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.1-3.4/3.1-3.4.cpp @@ -0,0 +1,117 @@ +/***˳ջʵ***/ + +#include +#include +using namespace std; + +//˳ջ +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +#define MAXSIZE 100//˳ջ洢ռijʼ +typedef int Status; +typedef char SElemType; + +typedef struct { + SElemType *base;//ջָ + SElemType *top;//ջָ + int stacksize;//ջõ +} SqStack; + +//㷨3.1˳ջijʼ +Status InitStack(SqStack &S) { + //һջS + S.base = new SElemType[MAXSIZE];//Ϊ˳ջ̬һΪMAXSIZEռ + if (!S.base) + exit(OVERFLOW); //洢ʧ + S.top = S.base; //topʼΪbaseջ + S.stacksize = MAXSIZE; //stacksizeΪջMAXSIZE + return OK; +} +//㷨3.2˳ջջ +Status Push(SqStack &S, SElemType e) { + // ԪeΪµջԪ + if (S.top - S.base == S.stacksize) + return ERROR; //ջ + *(S.top++) = e; //Ԫeѹջջָ1 + return OK; +} +//㷨3.3˳ջijջ +Status Pop(SqStack &S, SElemType &e) { + //ɾSջԪأeֵ + if (S.base == S.top) + return ERROR;//ջ + e = *(--S.top); //ջָ1ջԪظe + return OK; +} +//㷨3.4ȡ˳ջջԪ +char GetTop(SqStack S) {//SջԪأ޸ջָ + if (S.top != S.base) //ջǿ + return *(S.top - 1); //ջԪصֵջָ벻 +} + +int main() { + SqStack s; + int choose, flag = 0; + SElemType j, e, t; + cout << "1.ʼ\n"; + cout << "2.ջ\n"; + cout << "3.ջԪ\n"; + cout << "4.ջ\n"; + cout << "0.˳\n\n"; + + choose = -1; + while (choose != 0) { + cout << "ѡ:"; + cin >> choose; + switch (choose) { + case 1://㷨3.1˳ջijʼ + if (InitStack(s)) { + flag = 1; + cout << "ɹջгʼ\n\n"; + } else + cout << "ʼջʧ\n\n"; + break; + case 2: {//㷨3.2˳ջջ + fstream file; + file.open("SqStack.txt");// + if (!file) { + cout << "δҵļ\n\n" << endl; + exit(ERROR); + } + if (flag) { + flag = 1; + cout << "ջԪΪ\n"; + while (!file.eof()) { + file >> j; + if (file.fail()) + break; + else { + Push(s, j); + cout << j << " "; + } + } + cout << endl << endl; + } else + cout << "ջδѡ\n\n"; + file.close(); + } + break; + case 3://㷨3.3˳ջijջ + if(flag != -1 && flag != 0) + cout << "ջԪΪ\n" << GetTop(s) << endl << endl; + else + cout << "ջԪأѡ\n" << endl; + break; + case 4://㷨3.4ȡ˳ջջԪ + cout << "εջԪΪ:\n"; + while (Pop(s, t)){ + flag = -1; + cout << t << " "; + } + cout << endl << endl; + break; + } + } + return 0; +} diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.1-3.4/SqStack.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.1-3.4/SqStack.txt new file mode 100644 index 0000000..1f30c63 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.1-3.4/SqStack.txt @@ -0,0 +1,4 @@ +A +B +C +D \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.10/3.10.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.10/3.10.cpp new file mode 100644 index 0000000..9d3880e --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.10/3.10.cpp @@ -0,0 +1,16 @@ +/***Hanoi***/ + +#include"3.10.h" + +int main() { + int n; + char a, b, c; + a = '1'; + b = '2'; + c = '3'; + cout << "ʼһϵԲ̸" << endl; + cin >> n; + cout << "һϵԲȫƶϵĹΪ" << endl; + Hanoi(n, a, b, c); + return 0; +} diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.10/3.10.h b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.10/3.10.h new file mode 100644 index 0000000..a8a2692 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.10/3.10.h @@ -0,0 +1,20 @@ +#include +using namespace std; + +int m = 0;//mdzֵΪ0ȫֱ԰ᶯ +void move(char A, int n, char C) // ᶯ +{ + cout << "" << ++m << "," << "Ϊ" << n << "Բ̴ӵ" << A << "Ƶ" << C + << "" << endl; +} + +//㷨3.10Hanoiĵݹ㷨 +void Hanoi(int n, char A, char B, char C) {//AϵnԲ̰ᵽCϣB + if (n == 1) + move(A, 1, C); //Ϊ1Բ̴AƵC + else { + Hanoi(n - 1, A, C, B); //AϱΪ1n-1ԲƵBC + move(A, n, C);//ΪnԲ̴AƵC + Hanoi(n - 1, B, A, C); //BϱΪ1n-1ԲƵCA + } +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.11-3.15/3.11-3.15.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.11-3.15/3.11-3.15.cpp new file mode 100644 index 0000000..572dc49 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.11-3.15/3.11-3.15.cpp @@ -0,0 +1,123 @@ +/***ѭл***/ + +#include +#include +using namespace std; + +#define MAXQSIZE 100 +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef char QElemType; +typedef char SElemType; +typedef int Status; + +typedef struct { + QElemType *base;//ʼʱ̬洢ռ + int front;//ͷָ + int rear;//βָ +} SqQueue; + +//㷨3.11ѭеijʼ +Status InitQueue(SqQueue &Q) {//һնQ + Q.base = new QElemType[MAXQSIZE]; //ΪзһΪMAXSIZEռ + if (!Q.base) + exit(OVERFLOW); //洢ʧ + Q.front = Q.rear = 0; //ͷָβָΪ㣬Ϊ + return OK; +} + +//㷨3.12ѭеij +int QueueLength(SqQueue Q) {//QԪظеij + return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE; +} + +//㷨3.13ѭе +Status EnQueue(SqQueue &Q, QElemType e) {//ԪeΪQµĶβԪ + if ((Q.rear + 1) % MAXQSIZE == Q.front) //βָѭϼ1ͷָ룬 + return ERROR; + Q.base[Q.rear] = e; //Ԫزβ + Q.rear = (Q.rear + 1) % MAXQSIZE; //βָ1 + return OK; +} + +//㷨3.14ѭеij +Status DeQueue(SqQueue &Q, QElemType &e) {//ɾQĶͷԪأeֵ + if (Q.front == Q.rear) + return ERROR; //ӿ + e = Q.base[Q.front]; //ͷԪ + Q.front = (Q.front + 1) % MAXQSIZE; //ͷָ1 + return OK; +} + +//㷨3.15ȡѭеĶͷԪ +SElemType GetHead(SqQueue Q) {//QĶͷԪأ޸Ķͷָ + if (Q.front != Q.rear) //зǿ + return Q.base[Q.front]; //ضͷԪصֵͷָ벻 +} + +int main() { + int choose, flag = 0; + SqQueue Q; + QElemType e, j; + cout << "1.ʼ\n"; + cout << "2.\n"; + cout << "3.ͷԪ\n"; + cout << "4.\n"; + cout << "0.˳\n\n"; + + choose = -1; + while (choose != 0) { + cout << "ѡ:"; + cin >> choose; + switch (choose) { + case 1://㷨3.16ӵijʼ + if (InitQueue(Q)) { + flag = 1; + cout << "ɹԶнгʼ\n\n"; + } else + cout << "ʼʧ\n\n"; + break; + case 2: {//㷨3.17ӵ + fstream file; + file.open("QNode.txt"); + if (!file) { + cout << "δҵļ\n\n" << endl; + exit(ERROR); + } + if (flag) { + flag = 1; + cout << "ӵԪΪ\n"; + while (!file.eof()) { + file >> j; + if (file.fail()) + break; + else { + EnQueue(Q, j); + cout << j << " "; + } + } + cout << endl << endl; + } else + cout << "δѡ\n\n"; + file.close(); + } + break; + case 3://㷨3.19ȡӵĶͷԪ + if (flag != -1 && flag != 0) + cout << "ͷԪΪ\n" << GetHead(Q) << endl << endl; + else + cout << "Ԫأѡ\n" << endl; + break; + case 4://㷨3.18ӵij + cout << "εĶͷԪΪ:\n"; + while (DeQueue(Q, e)) { + flag = -1; + cout << e << " "; + } + cout << endl << endl; + break; + } + } + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.11-3.15/QNode.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.11-3.15/QNode.txt new file mode 100644 index 0000000..1f30c63 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.11-3.15/QNode.txt @@ -0,0 +1,4 @@ +A +B +C +D \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.16-3.19/3.16-3.19.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.16-3.19/3.16-3.19.cpp new file mode 100644 index 0000000..abb928f --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.16-3.19/3.16-3.19.cpp @@ -0,0 +1,126 @@ +/***ӵĻ***/ + +#include +#include +using namespace std; + +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef char QElemType; +typedef int Status; +typedef char SElemType; + +//- - - - - еʽ洢ṹ- - - - - +typedef struct QNode { + QElemType data; + struct QNode *next; +} QNode, *QueuePtr; +typedef struct { + QueuePtr front; //ͷָ + QueuePtr rear; //βָ +} LinkQueue; + +//㷨3.16ӵijʼ +Status InitQueue(LinkQueue &Q) {//һնQ + Q.front = Q.rear = new QNode; //½Ϊͷ㣬ͷͶβָָ˽ + Q.front->next = NULL; //ͷָÿ + return OK; +} + +//㷨3.17ӵ +Status EnQueue(LinkQueue &Q, QElemType e) {//ԪeΪQµĶβԪ + QueuePtr p; + p = new QNode; //ΪԪطռ䣬ָpָ + p->data = e; //½Ϊe + p->next = NULL; + Q.rear->next = p; //½뵽β + Q.rear = p; //޸Ķβָ + return OK; +} + +//㷨3.18ӵij +Status DeQueue(LinkQueue &Q, QElemType &e) {//ɾQĶͷԪأeֵ + QueuePtr p; + if (Q.front == Q.rear) + return ERROR; //пգ򷵻ERROR + p = Q.front->next; //pָͷԪ + e = p->data; //eͷԪصֵ + Q.front->next = p->next; //޸ͷָ + if (Q.rear == p) + Q.rear = Q.front; //һԪرɾβָָͷ + delete p; //ͷԭͷԪصĿռ + return OK; +} + +//㷨3.19ȡӵĶͷԪ +SElemType GetHead(LinkQueue Q) {//QĶͷԪأ޸Ķͷָ + if (Q.front != Q.rear) //зǿ + return Q.front->next->data; //ضͷԪصֵͷָ벻 +} + +int main() { + int choose, flag = 0; + LinkQueue Q; + QElemType e, j; + cout << "1.ʼ\n"; + cout << "2.\n"; + cout << "3.ͷԪ\n"; + cout << "4.\n"; + cout << "0.˳\n\n"; + + choose = -1; + while (choose != 0) { + cout << "ѡ:"; + cin >> choose; + switch (choose) { + case 1://㷨3.16ӵijʼ + if (InitQueue(Q)) { + flag = 1; + cout << "ɹԶнгʼ\n\n"; + } else + cout << "ʼʧ\n\n"; + break; + case 2: {//㷨3.17ӵ + fstream file; + file.open("QNode.txt"); + if (!file) { + cout << "δҵļ\n\n" << endl; + exit(ERROR); + } + if (flag) { + flag = 1; + cout << "ӵԪΪ\n"; + while (!file.eof()) { + file >> j; + if (file.fail()) + break; + else { + EnQueue(Q, j); + cout << j << " "; + } + } + cout << endl << endl; + } else + cout << "δѡ\n\n"; + file.close(); + } + break; + case 3://㷨3.19ȡӵĶͷԪ + if (flag != -1 && flag != 0) + cout << "ͷԪΪ\n" << GetHead(Q) << endl << endl; + else + cout << "Ԫأѡ\n" << endl; + break; + case 4://㷨3.18ӵij + cout << "εĶͷԪΪ:\n"; + while (DeQueue(Q, e)) { + flag = -1; + cout << e << " "; + } + cout << endl << endl; + break; + } + } + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.16-3.19/QNode.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.16-3.19/QNode.txt new file mode 100644 index 0000000..1f30c63 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.16-3.19/QNode.txt @@ -0,0 +1,4 @@ +A +B +C +D \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.20/3.20.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.20/3.20.cpp new file mode 100644 index 0000000..e89215f --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.20/3.20.cpp @@ -0,0 +1,69 @@ +/***ջʵƵת***/ + +#include +using namespace std; + +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 + +typedef int Status; +typedef struct SNode { + int data; + struct SNode *next; +} SNode, *LinkStack; + +Status InitStack(LinkStack &S) { + S = NULL; + return OK; +} +bool StackEmpty(LinkStack S) { + if (!S) + return true; + return false; +} +Status Push(LinkStack &S, int e) { + LinkStack p; + p = new SNode; + if (!p) { + return OVERFLOW; + } + p->data = e; + p->next = S; + S = p; + return OK; +} +Status Pop(LinkStack &S, int &e) { + LinkStack p; + if (!S) + return ERROR; + e = S->data; + p = S; + S = S->next; + delete p; + return OK; +} +//㷨3.20Ƶת(ջʵ) +void conversion(int N) {//һǸʮӡֵİ˽ + int e; + LinkStack S; + InitStack(S); //ʼջS + while (N) //Nʱ,ѭ + { + Push(S, N % 8); //N8õİ˽ѹջS + N = N / 8; //NΪN8 + } + while (!StackEmpty(S)) //ջSǿʱѭ + { + Pop(S, e); //ջԪe + cout << e; //e + } +} +int main() {//һǸʮӡֵİ˽ + int n, e; + cout << "һǸʮ:" << endl; + cin >> n; + + conversion(n); + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.21/3.21.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.21/3.21.cpp new file mode 100644 index 0000000..abbc702 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.21/3.21.cpp @@ -0,0 +1,96 @@ +/***ջʵƥ***/ + +#include +using namespace std; + +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef char SElemType; +typedef int Status; +typedef struct SNode { + int data; + struct SNode *next; +} SNode, *LinkStack; + +Status InitStack(LinkStack &S) { + S = NULL; + return OK; +} +bool StackEmpty(LinkStack S) { + if (!S) + return true; + return false; +} +Status Push(LinkStack &S, SElemType e) { + SNode *p = new SNode; + if (!p) { + return OVERFLOW; + } + p->data = e; + p->next = S; + S = p; + return OK; +} +Status Pop(LinkStack &S, SElemType &e) { + SNode *p; + if (!S) + return ERROR; + e = S->data; + p = S; + S = S->next; + delete p; + return OK; +} +Status GetTop(LinkStack &S) { + if (!S) + return ERROR; + return S->data; +} + +//㷨3.21ŵƥ +Status Matching() {//ʽǷȷƥ䣬ƥ䣬򷵻true򷵻false + //ʽԡ# + char ch; + SElemType x; + LinkStack S; + InitStack(S); //ʼջ + int flag = 1; //ƥԿѭؽ + cin >> ch; //һַ + while (ch != '#' && flag) //ʽԡ#β + { + switch (ch) { + case '[' : + case '(': //ţѹջ + Push(S, ch); + break; + case ')': //ǡ)ݵǰջԪصֵ + if (!StackEmpty(S) && GetTop(S) == '(') + Pop(S, x); //ջǿջԪǡ(ȷƥ + else + flag = 0; //ջջջԪزǡ(ʧ + break; + case ']': //ǡ]ݵǰջԪصֵ + if (!StackEmpty(S) && GetTop(S) == '[') + Pop(S, x); //ջǿջԪǡ[ȷƥ + else + flag = 0; //ջջջԪزǡ[ƥ + break; + } //switch + cin >> ch; //һַ + } //while + if (StackEmpty(S) && flag) + return true; //ƥɹ + else + return false; //ƥʧ +} +int main() { + LinkStack S; + cout << "ƥıʽԡ#" << endl; + int flag = (int) Matching(); + if (flag) + cout << "ƥɹ" << endl; + else + cout << "ƥʧܣ" << endl; + return 0; +} diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.22/3.22.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.22/3.22.cpp new file mode 100644 index 0000000..7f1635b --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.22/3.22.cpp @@ -0,0 +1,29 @@ +#include"3.22.h" + +int menu() { + int c; + cout << "0-9ڵĶʽ" << endl; + cout << "1." << endl; + cout << "0.˳\n" << endl; + cout << "ѡ"; + cin >> c; + return c; +} + +void main() { + while (1) { + switch (menu()) { + case 1: { + cout << "Ҫıʽͽ0-9ķΧڣ#" << endl; + char res = EvaluateExpression();//㷨3.22ʽֵ + cout << "Ϊ" << res - 48 << endl << endl; + } + break; + case 0: + cout << "˳ɹ\n" << endl; + exit(0); + default: + break; + } + } +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.22/3.22.h b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.22/3.22.h new file mode 100644 index 0000000..d21e0f4 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.22/3.22.h @@ -0,0 +1,117 @@ +/***ջʵֱʽֵ***/ + +#include +using namespace std; + +const char oper[7] = { '+', '-', '*', '/', '(', ')', '#' }; +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef char SElemType; +typedef int Status; +typedef struct SNode { + int data; + struct SNode *next; +} SNode, *LinkStack; + +Status InitStack(LinkStack &S) { + S = NULL; + return OK; +} +bool StackEmpty(LinkStack S) { + if (!S) + return true; + return false; +} +Status Push(LinkStack &S, SElemType e) { + SNode *p = new SNode; + if (!p) { + return OVERFLOW; + } + p->data = e; + p->next = S; + S = p; + return OK; +} +Status Pop(LinkStack &S, SElemType &e) { + SNode *p; + if (!S) + return ERROR; + e = S->data; + p = S; + S = S->next; + delete p; + return OK; +} +Status GetTop(LinkStack &S) { + if (!S) + return ERROR; + + return S->data; +} +bool In(char ch) {//жchǷΪ + for (int i = 0; i < 7; i++) { + if (ch == oper[i]) { + return true; + } + } + return false; +} +char Precede(char theta1, char theta2) {//жȼ + if ((theta1 == '(' && theta2 == ')') || (theta1 == '#' && theta2 == '#')) { + return '='; + } else if (theta1 == '(' || theta1 == '#' || theta2 == '(' || (theta1 + == '+' || theta1 == '-') && (theta2 == '*' || theta2 == '/')) { + return '<'; + } else + return '>'; +} +char Operate(char first, char theta, char second) {// + switch (theta) { + case '+': + return (first - '0') + (second - '0') + 48; + case '-': + return (first - '0') - (second - '0') + 48; + case '*': + return (first - '0') * (second - '0') + 48; + case '/': + return (first - '0') / (second - '0') + 48; + } + return 0; +} + +//㷨3.22ʽֵ +char EvaluateExpression() {//ʽֵ㷨OPTROPNDֱΪջͲջ + LinkStack OPTR, OPND; + char ch, theta, a, b, x, top; + InitStack(OPND); //ʼOPNDջ + InitStack(OPTR); //ʼOPTRջ + Push(OPTR, '#'); //ʽʼ#ѹOPTRջ + cin >> ch; + while (ch != '#' || (GetTop(OPTR) != '#')) //ʽûɨϻOPTRջԪزΪ# + { + if (!In(ch)) { + Push(OPND, ch); + cin >> ch; + } //chOPNDջ + else + switch (Precede(GetTop(OPTR), ch)) //ȽOPTRջԪغchȼ + { + case '<': + Push(OPTR, ch); + cin >> ch; //ǰַchѹOPTRջһַch + break; + case '>': + Pop(OPTR, theta); //OPTRջ + Pop(OPND, b); + Pop(OPND, a); //OPNDջ + Push(OPND, Operate(a, theta, b)); //ѹOPNDջ + break; + case '=': //OPTRջԪǡ(chǡ) + Pop(OPTR, x); + cin >> ch; //OPTRջġ(һַch + break; + } //switch + } //while + return GetTop(OPND); //OPNDջԪؼΪʽֵ +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.23/3.23.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.23/3.23.cpp new file mode 100644 index 0000000..b7edff7 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.23/3.23.cpp @@ -0,0 +1,18 @@ +#include"3.23.h" + +Person dancer[MAXQSIZE]; +int main() { + int i = 0; + fstream file; + file.open("DancePartner.txt"); + if (!file) { + cout << "δҵļ\n\n" << endl; + exit( ERROR); + } + while (!file.eof()) { + file >> dancer[i].name >> dancer[i].sex; + i++; + } + DancePartner(dancer, i + 1); + return 0; +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.23/3.23.h b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.23/3.23.h new file mode 100644 index 0000000..fb2721d --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.23/3.23.h @@ -0,0 +1,89 @@ +#include +#include +#include +#define MAXQSIZE 100//пܴﵽ󳤶 +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +using namespace std; + +typedef struct { + char name[20]; // + char sex; //Ա'F'ʾŮԣ'M'ʾ +} Person; + +//- - - - - е˳洢ṹ- - - - - +typedef struct { + Person *base; //ԪΪPerson + int front; //ͷָ + int rear; //βָ +} SqQueue; + +SqQueue Mdancers, Fdancers; //ֱʿŮʿ߶ + +int InitQueue(SqQueue &Q) {//һնQ + Q.base = new Person[MAXQSIZE]; //ΪзһΪMAXSIZEռ + if (!Q.base) + exit( OVERFLOW); //洢ʧ + Q.front = Q.rear = 0; //ͷָβָΪ㣬Ϊ + return OK; +} + +int EnQueue(SqQueue &Q, Person e) {//ԪeΪQµĶβԪ + if ((Q.rear + 1) % MAXQSIZE == Q.front) //βָѭϼ1ͷָ룬 + return ERROR; + Q.base[Q.rear] = e; //Ԫزβ + Q.rear = (Q.rear + 1) % MAXQSIZE; //βָ1 + return OK; +} + +int QueueEmpty(SqQueue &Q) { + if (Q.front == Q.rear) //ӿ + return OK; + else + return ERROR; +} + +int DeQueue(SqQueue &Q, Person &e)//ɾQĶͷԪأeֵ +{ + if (Q.front == Q.rear) + return ERROR; //ӿ + e = Q.base[Q.front]; //ͷԪ + Q.front = (Q.front + 1) % MAXQSIZE; //ͷָ1 + return OK; +} + +Person GetHead(SqQueue Q) {//QĶͷԪأ޸Ķͷָ + if (Q.front != Q.rear) //зǿ + return Q.base[Q.front]; //ضͷԪصֵͷָ벻 +} + +//㷨3.23 +void DancePartner(Person dancer[], int num) {//ṹdancerдŮnum + InitQueue(Mdancers); //ʿгʼ + InitQueue(Fdancers); //Ůʿгʼ + Person p; + for (int i = 0; i < num; i++) //ν߸Ա + { + p = dancer[i]; + if (p.sex == 'F') + EnQueue(Fdancers, p); //Ů + else + EnQueue(Mdancers, p); //ж + } + cout << "The dancing partners are:" << endl; + while (!QueueEmpty(Fdancers) && !QueueEmpty(Mdancers)) {//Ů + DeQueue(Fdancers, p); //Ůʿ + cout << p.name << " "; //Ůʿ + DeQueue(Mdancers, p); //ʿ + cout << p.name << endl; //ʿ + } + if (!QueueEmpty(Fdancers)) { //ŮʿзǿգͷŮʿ + p = GetHead(Fdancers); //ȡŮʿͷ + cout << "The first man to get a partner is: " << endl; + cout << p.name << endl; + } else if (!QueueEmpty(Mdancers)) { //ʿзǿգͷʿ + p = GetHead(Mdancers); //ȡʿͷ + cout << "The first woman to get a partner is: " << p.name << endl; + } +} \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.23/DancePartner.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.23/DancePartner.txt new file mode 100644 index 0000000..2f9b4ec --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.23/DancePartner.txt @@ -0,0 +1,18 @@ +۳ѩ F + F +Դ F + F +ȽСϪ F + F +˼ F + F + M + M +˼ M + M +ܽ M + M +˶ M +С M + M + M \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.5-3.8/3.5-3.8.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.5-3.8/3.5-3.8.cpp new file mode 100644 index 0000000..4eef629 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.5-3.8/3.5-3.8.cpp @@ -0,0 +1,115 @@ +/***ջʵ***/ +#include +#include +using namespace std; + +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef int Status; +typedef char SElemType; + +typedef struct StackNode { + SElemType data; + struct StackNode *next; +} StackNode, *LinkStack; + +//㷨3.5ջijʼ +Status InitStack(LinkStack &S) { // һջ Sջָÿ + S = NULL; + return OK; +} + +//㷨3.6ջջ +Status Push(LinkStack &S, SElemType e) {//ջԪe + LinkStack p; + p = new StackNode; //½ + p->data = e; //½Ϊe + p->next = S; //½ջ + S = p; //޸ջָΪp + return OK; +} + +//㷨3.7ջijջ +Status Pop(LinkStack &S, SElemType &e) {//ɾSջԪأeֵ + LinkStack p; + if (S == NULL) + return ERROR; //ջ + e = S->data; //ջԪظe + p = S; //pʱջԪؿռ䣬Աͷ + S = S->next; //޸ջָ + delete p; //ͷԭջԪصĿռ + return OK; +} +//㷨3.8ȡջջԪ +SElemType GetTop(LinkStack S) {//SջԪأ޸ջָ + if (S != NULL) //ջǿ + return S->data; //ջԪصֵջָ벻 +} + +int main() { + LinkStack s; + int choose, flag = 0; + SElemType j, t; + cout << "1.ʼ\n"; + cout << "2.ջ\n"; + cout << "3.ջԪ\n"; + cout << "4.ջ\n"; + cout << "0.˳\n\n"; + + choose = -1; + while (choose != 0) { + cout << "ѡ:"; + cin >> choose; + switch (choose) { + case 1://㷨3.5ջijʼ + if (InitStack(s)) { + flag = 1; + cout << "ɹջгʼ\n\n"; + } else + cout << "ʼջʧ\n\n"; + break; + case 2: {//㷨3.6ջջ + fstream file; + file.open("SqStack.txt"); + if (!file) { + cout << "δҵļ\n\n" << endl; + exit(ERROR); + } + if (flag) { + flag = 1; + cout << "ջԪΪ\n"; + while (!file.eof()) { + file >> j; + if (file.fail()) + break; + else { + Push(s, j); + cout << j << " "; + } + } + cout << endl << endl; + } else + cout << "ջδѡ\n\n"; + file.close(); + } + break; + case 3://㷨3.8ȡջջԪ + if (flag != -1 && flag != 0) + cout << "ջԪΪ\n" << GetTop(s) << endl << endl; + else + cout << "ջԪأѡ\n" << endl; + break; + case 4://㷨3.7ջijջ + if (flag) { + cout << "εջԪΪ:\n"; + while (Pop(s, t)) + cout << t << " "; + cout << endl << endl; + } else + cout << "ջδѡ\n\n"; + break; + } + } + return 0; +} diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.5-3.8/SqStack.txt b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.5-3.8/SqStack.txt new file mode 100644 index 0000000..1f30c63 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.5-3.8/SqStack.txt @@ -0,0 +1,4 @@ +A +B +C +D \ No newline at end of file diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.9/3.9.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.9/3.9.cpp new file mode 100644 index 0000000..9dad058 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第3章/3.9/3.9.cpp @@ -0,0 +1,53 @@ +/***еĸ***/ + +#include +using namespace std; + +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef int Status; +typedef char ElemType; +typedef struct LNode { + ElemType data; // + LNode *next; //ָ +} LNode, *LinkList;//ͷָ + +//巨㷨 +void CreateList_L(LinkList &L, int n) { + L = new LNode; + L->next = NULL; + LNode *p, *r; + r = L; + for (int i = 0; i < n; i++) { + p = new LNode; + cin >> p->data; + p->next = NULL; + r->next = p; + r = p; + } +} + +//㷨3.9иĵݹ㷨 +void TraverseList(LinkList p) { + if (p == NULL) + return; //ݹֹ + else { + cout << p->data << endl; //ǰ + TraverseList(p->next); //pָָݹ + } +} + +int main() { + int n; + LinkList L; + //InitList(L); + cout << "Ԫظ" << endl; + cin >> n; + cout << "Ԫ(Կոس)" << endl; + CreateList_L(L, n); //巨㷨 + cout << "еԪΪ" << endl; + TraverseList(L->next); + cout << endl; + return 0; +} diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第4章/4.1.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第4章/4.1.cpp new file mode 100644 index 0000000..330d34b --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第4章/4.1.cpp @@ -0,0 +1,60 @@ +/***ַƥ㷨***/ +#include +#include +using namespace std; + +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef int Status; +#define MAXSTRLEN 255 //û255ڶ +typedef char SString[MAXSTRLEN+1]; //0ŵԪŴij + +Status StrAssign(SString T, char *chars) { //һֵcharsĴT + int i; + if (strlen(chars) > MAXSTRLEN) + return ERROR; + else { + T[0] = strlen(chars); + for (i = 1; i <= T[0]; i++) + T[i] = *(chars + i - 1); + return OK; + } +} + +//㷨4.1BF㷨 +int Index(SString S, SString T, int pos) +{ + //ģʽTSеposַ֮sһγֵλáڣ򷵻ֵΪ0 + //УTǿգ1posStrLength(S) + int i = pos; + int j = 1; + while(i <= S[0]&&j <= T[0]) + { + if(S[i]==T[j]) + { + ++i; + ++j; + } //ȽϺַ + else + { + i=i-j+2; + j=1; + } //ָ¿ʼƥ + } + if (j > T[0]) + return i - T[0]; + else + return 0; + return 0; +}//Index + +int main() +{ + SString S; + StrAssign(S,"bbaaabbaba") ; + SString T; + StrAssign(T,"abb") ; + cout<<"Ӵڵ"< +#include +using namespace std; + +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef int Status; +#define MAXSTRLEN 255 //û255ڶ +typedef char SString[MAXSTRLEN+1]; //0ŵԪŴij + +Status StrAssign(SString T, char *chars) { //һֵcharsĴT + int i; + if (strlen(chars) > MAXSTRLEN) + return ERROR; + else { + T[0] = strlen(chars); + for (i = 1; i <= T[0]; i++) + T[i] = *(chars + i - 1); + return OK; + } +} +//㷨4.3nextֵ +void get_next(SString T, int next[]) +{ //ģʽTnextֵnext + int i = 1, j = 0; + next[1] = 0; + while (i < T[0]) + if (j == 0 || T[i] == T[j]) + { + ++i; + ++j; + next[i] = j; + } + else + j = next[j]; +}//get_next + +//㷨4.2KMP㷨 +int Index_KMP(SString S, SString T, int pos, int next[]) +{ // ģʽTnextTSеposַ֮λõKMP㷨 + //УTǿգ1posStrLength(S) + int i = pos, j = 1; + while (i <= S[0] && j <= T[0]) + if (j == 0 || S[i] == T[j]) // ȽϺ + { + ++i; + ++j; + } + else + j = next[j]; // ģʽƶ + if (j > T[0]) // ƥɹ + return i - T[0]; + else + return 0; +}//Index_KMP + +int main() +{ + SString S; + StrAssign(S,"aaabbaba") ; + SString T; + StrAssign(T,"abb") ; + int *p = new int[T[0]+1]; // Tnext + get_next(T,p); + cout<<"Ӵڵ"< +#include +using namespace std; + +#define OK 1 +#define ERROR 0 +#define OVERFLOW -2 +typedef int Status; +#define MAXSTRLEN 255 //û255ڶ +typedef char SString[MAXSTRLEN+1]; //0ŵԪŴij + +Status StrAssign(SString T, char *chars) { //һֵcharsĴT + int i; + if (strlen(chars) > MAXSTRLEN) + return ERROR; + else { + T[0] = strlen(chars); + for (i = 1; i <= T[0]; i++) + T[i] = *(chars + i - 1); + return OK; + } +} + +//㷨4.4nextֵ +void get_nextval(SString T, int nextval[]) +{ // ģʽTnextֵnextval + int i = 1, j = 0; + nextval[1] = 0; + while (i < T[0]) + if (j == 0 || T[i] == T[j]) + { + ++i; + ++j; + if (T[i] != T[j]) + nextval[i] = j; + else + nextval[i] = nextval[j]; + } else + j = nextval[j]; +}//get_nextval + +//㷨4.2KMP㷨 +int Index_KMP(SString S, SString T, int pos, int next[]) +{ // ģʽTnextTSеposַ֮λõKMP㷨 + //УTǿգ1posStrLength(S) + int i = pos, j = 1; + while (i <= S[0] && j <= T[0]) + if (j == 0 || S[i] == T[j]) // ȽϺ + { + ++i; + ++j; + } + else + j = next[j]; // ģʽƶ + if (j > T[0]) // ƥɹ + return i - T[0]; + else + return 0; +}//Index_KMP + +int main() +{ + SString S; + StrAssign(S,"babaaaabbaba") ; + SString T; + StrAssign(T,"abb") ; + int *p = new int[T[0]+1]; // Tnext + get_nextval(T,p); + cout<<"Ӵڵ"< +#include +#include +using namespace std; + +typedef struct{ + char ch[600]; //Ƿǿմ򰴴洢chΪNULL + int len; // +}HString; + + +int Index_BF(HString S,HString T,int pos) +{//ģʽTSеposַʼһγֵλáڣ򷵻ֵΪ0 + //УTǿգ1posStrLength(S) + int i,j; + i=pos; j=1; + while(i<=S.len&&j<=T.len) + { + if(S.ch[i]==T.ch[j]){++i;++j;} //ȽϺַ + else{i=i-j+2;j=1;} //ָ¿ʼƥ + } + if(j>T.len) return i-T.len; + else return 0; +} + +void Virus_detection() +{ + int num,m,flag,i,j; char Vir[600]; + HString Virus,Person,temp; + ifstream inFile("Ⱦ.txt"); + ofstream outFile("Ⱦ.txt"); + inFile>>num;//ȡ + while(num--) //μÿԲDNA˵DNAǷƥ + { + inFile>>Virus.ch+1;//ȡDNA + inFile>>Person.ch+1;//ȡ˵DNA + strcpy(Vir,Virus.ch); + Virus.len=strlen(Virus.ch)-1; + Person.len=strlen(Person.ch)-1; + flag=0;//ʶǷƥ䣬ʼΪ0ƥΪ0 + m=Virus.len; + for(i=m+1,j=1;j<=m;j++) Virus.ch[i++]=Virus.ch[j]; + //򲡶Ϊ״ʽij2 + //ȡгΪVirus.lenַ + Virus.ch[2*m+1]='\0'; //ӽ + for(i=0;i +using namespace std; +typedef struct BiNode{ // + char data; + struct BiNode *lchild,*rchild; +}BiTNode,*BiTree; + +//㷨5.3 ˳ +void CreateBiTree(BiTree &T){ + //нֵһַʾĶT + char ch; + cin >> ch; + if(ch=='#') T=NULL; //ݹ + else{ + T=new BiTNode; + T->data=ch; //ɸ + CreateBiTree(T->lchild); //ݹ鴴 + CreateBiTree(T->rchild); //ݹ鴴 + } //else +} //CreateBiTree + +void InOrderTraverse(BiTree T){ + //Tĵݹ㷨 + if(T){ + InOrderTraverse(T->lchild); + cout << T->data; + InOrderTraverse(T->rchild); + } +} + +void main(){ + BiTree tree; + cout<<"뽨У\n"; + CreateBiTree(tree); + cout<<"ĽΪ\n"; + InOrderTraverse(tree); + cout< +using namespace std; +typedef struct +{ + int weight; + int parent,lchild,rchild; +}HTNode,*HuffmanTree; + +void Select(HuffmanTree HT,int len,int &s1,int &s2) +{ + int i,min1=0x3f3f3f3f,min2=0x3f3f3f3f;//ȸֵ + for(i=1;i<=len;i++) + { + if(HT[i].weight>HT[i].weight; + /*DDDDDDDDDDʼ濪ʼշDDDDDDDDDD*/ + for(i=n+1;i<=m;++i) + { //ͨn-1εѡɾϲշ + Select(HT,i-1,s1,s2); + //HT[k](1ki-1)ѡ˫Ϊ0ȨֵСĽ, + // HTеs1s2 + HT[s1].parent=i; + HT[s2].parent=i; + //õ½iɭɾs1s2s1s2˫0Ϊi + HT[i].lchild=s1; + HT[i].rchild=s2 ; //s1,s2ֱΪiҺ + HT[i].weight=HT[s1].weight+HT[s2].weight; //i ȨֵΪҺȨֵ֮ + } //for + } // CreatHuffmanTree + +void main() +{ + HuffmanTree HT; + int n; + cout<<"Ҷӽĸ\n"; + cin>>n; + CreatHuffmanTree(HT,n); + cout<<"ϣ\n"; +} diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.11.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.11.cpp new file mode 100644 index 0000000..e48a92f --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.11.cpp @@ -0,0 +1,105 @@ +//㷨5.11 ݺշշ +#include +using namespace std; +typedef struct +{ + int weight; + int parent,lchild,rchild; +}HTNode,*HuffmanTree; +typedef char **HuffmanCode; + +void Select(HuffmanTree HT,int len,int &s1,int &s2) +{ + int i,min1=0x3f3f3f3f,min2=0x3f3f3f3f;//ȸֵ + for(i=1;i<=len;i++) + { + if(HT[i].weight>HT[i].weight; + /*DDDDDDDDDDʼ濪ʼշDDDDDDDDDD*/ + for(i=n+1;i<=m;++i) + { //ͨn-1εѡɾϲշ + Select(HT,i-1,s1,s2); + //HT[k](1ki-1)ѡ˫Ϊ0ȨֵСĽ, + // HTеs1s2 + HT[s1].parent=i; + HT[s2].parent=i; + //õ½iɭɾs1s2s1s2˫0Ϊi + HT[i].lchild=s1; + HT[i].rchild=s2 ; //s1,s2ֱΪiҺ + HT[i].weight=HT[s1].weight+HT[s2].weight; //i ȨֵΪҺȨֵ֮ + } //for +} + // CreatHuffmanTree +void CreatHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n) +{ + //Ҷӵÿַĺշ룬洢ڱHC + int i,start,c,f; + HC=new char*[n+1]; //nַͷָʸ + char *cd=new char[n]; //ʱűĶ̬ռ + cd[n-1]='\0'; // + for(i=1;i<=n;++i) + { //ַշ + start=n-1; //startʼʱָ󣬼λ + c=i; + f=HT[i].parent; //fָc˫׽ + while(f!=0) + { //Ҷӽ㿪ʼϻݣֱ + --start; //һstartǰָһλ + if(HT[f].lchild==c) + cd[start]='0'; //cfӣɴ0 + else + cd[start]='1'; //cfҺӣɴ1 + c=f; + f=HT[f].parent; //ϻ + } //iַı + HC[i]=new char[n-start]; // Ϊi ַռ + strcpy(HC[i], &cd[start]); //õıʱռcdƵHCĵǰ + } + delete cd; //ͷʱռ +} // CreatHuffanCode +void show(HuffmanTree HT,HuffmanCode HC) +{ + for(int i=1;i<=sizeof(HC)+1;i++) + cout<>n; //շҶӽ + CreatHuffmanTree(HT,n); + CreatHuffmanCode(HT,HC,n); + show(HT,HC); +} diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.12-5.13.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.12-5.13.cpp new file mode 100644 index 0000000..63cdde9 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.12-5.13.cpp @@ -0,0 +1,201 @@ +#include +#include +#define ERROR -1 +#define MAXSIZE 100 +using namespace std; + +typedef struct BiTNode{ //Ķ洢ʾ + char data; + struct BiTNode *lchild,*rchild; +}BiTNode,*BiTree; + +typedef struct{ // ַջ + char *base; + char *top; + int stacksize; +}SqStack; + +typedef struct{ //ջ + BiTree *base; + BiTree *top; + int stacksize; +}BiTreeStack; + + +void InitStack(SqStack &S){ //ַջʼ + S.base=new char[MAXSIZE]; + if(!S.base) exit(-1); + S.top=S.base; + S.stacksize=MAXSIZE; +} + + +void InitBiTreeStack(BiTreeStack &S){ //ջʼ + S.base=new BiTree[MAXSIZE]; + if(!S.base) exit(-1); + S.top=S.base; + S.stacksize=MAXSIZE; +} + + +void Push(SqStack &S,char e) //ַջջ +{ + if(S.top-S.base==S.stacksize) return ; + *S.top=e; + S.top++; + +} +void PushBiTree(BiTreeStack &S,BiTree e) //ջջ +{ + if(S.top-S.base==S.stacksize) return ; + *S.top=e; + S.top++; + +} +void Pop(SqStack &S,char &e) //ַջջ +{ + if(S.top==S.base) return; + e=*--S.top; + +} + +void PopBiTree(BiTreeStack &S,BiTree &e) //ջջ +{ + if(S.top==S.base) return; + e=*--S.top; + +} + + +char GetTop(SqStack &S) //ַջõջ +{ + if(S.top==S.base) exit(1); + return *(S.top-1); +} + +char Precede(char t1,char t2) + { /* ݽ̿3.1жŵȹϵ */ + char f; + switch(t2) + { + case '+':if(t1=='('||t1=='#') + f='<'; + else + f='>'; + break; + case '-':if(t1=='('||t1=='#') + f='<'; + else + f='>'; + break; + case '*':if(t1=='*'||t1=='/'||t1==')') + f='>'; + else + f='<'; + break; + case '/':if(t1=='*'||t1=='/'||t1==')') + f='>'; + else + f='<'; + break; + case '(':if(t1!=')') + f='<'; + break; + case')':if(t1=='(') + f='='; + else + f='>'; + break; + case'#':if(t1=='#') + f='='; + else + f='>'; + } + + return f; + } +int In(char c) + { /* жcǷΪ */ + switch(c) + { + case '+': + case'-': + case'*': + case '/': + case'#': + case '(': + case')':return 1;break; + default:return 0; + } + } +int GetValue(char theta,int a,int b) //ĺ + { + int c; + switch(theta) + { + case '+':c=a+b;break; + case'-':c=a-b;break; + case'*':c=a*b;break; + case'/':c=a/b;break; + default: + break; + } + return c; + } + +void CreateExpTree(BiTree &T,BiTree a,BiTree b,char ch){ //򵥶Ĵ + T=new BiTNode; + T->data=ch; + T->lchild=a; + T->rchild=b; +} + + + void InitExpTree(BiTree &T) //㷨5.12 ʽĴ + { + SqStack OPTR; + BiTreeStack EXPT; + char ch,theta,x; + BiTree a,b; + InitStack(OPTR);Push(OPTR,'#'); + InitBiTreeStack(EXPT);cin>>ch; + while(ch!='#'||GetTop(OPTR)!='#'){ + if(!In(ch)){CreateExpTree(T,NULL,NULL,ch);PushBiTree(EXPT,T);cin>>ch;}//*q + else + switch(Precede(GetTop(OPTR),ch)){ + case'<': + Push(OPTR,ch);cin>>ch; + break; + case'>': + Pop(OPTR,theta); + PopBiTree(EXPT,b);PopBiTree(EXPT,a); + CreateExpTree(T,a,b,theta); //* + PushBiTree(EXPT,T); + break; + case'=': + Pop(OPTR,x);cin>>ch; + break; + } + } + } + + int EvaluateExTree(BiTree T){ //㷨5.13 ʽֵ + int lvalue,rvalue; + lvalue=rvalue=0; + if(T->lchild==NULL&&T->rchild==NULL) + return T->data-'0'; + else{ + lvalue=EvaluateExTree(T->lchild); + rvalue=EvaluateExTree(T->rchild); + return GetValue(T->data,lvalue,rvalue); //㺯 + } + } + + void main() + { + cout<<"ʽ,#,мҪǸλ."< +using namespace std; + +//Ķ洢ʾ +typedef struct BiNode +{ + char data; // + struct BiNode *lchild,*rchild; //Һָ +}BiTNode,*BiTree; + +//ջĶ +typedef struct StackNode +{ + BiTNode data; + struct StackNode *next; +}StackNode,*LinkStack; + +//㷨5.3 ˳ +void CreateBiTree(BiTree &T) +{ + //нֵһַʾĶT + char ch; + cin >> ch; + if(ch=='#') T=NULL; //ݹ + else{ + T=new BiTNode; + T->data=ch; //ɸ + CreateBiTree(T->lchild); //ݹ鴴 + CreateBiTree(T->rchild); //ݹ鴴 + } //else +} //CreateBiTree + +void InitStack(LinkStack &S) +{ + //һջSջָÿ + S=NULL; +} + +bool StackEmpty(LinkStack S) +{ + if(!S) + return true; + return false; +} + +void Push(LinkStack &S,BiTree e) +{ + //ջԪ*e + StackNode *p=new StackNode; + p->data=*e; + p->next=S; + S=p; +} + +void Pop(LinkStack &S,BiTree e) +{ + if(S!=NULL)//ԭдif(S==NULL)return ERROR; + { + *e=S->data; + StackNode *p=S; + S=S->next; + delete p; + } +} + +void InOrderTraverse1(BiTree T) +{ + // Tķǵݹ㷨 + LinkStack S; BiTree p; + BiTree q=new BiTNode; + InitStack(S); p=T; + while(p||!StackEmpty(S)) + { + if(p) + { + Push(S,p); //pǿոָջ + p=p->lchild; + } + else + { + Pop(S,q); //pΪոָջʸ㣬 + cout<data; + p=q->rchild; + } + } // while +} // InOrderTraverse + +void main() +{ + BiTree tree; + cout<<"뽨У\n"; + CreateBiTree(tree); + cout<<"ĽΪ\n"; + InOrderTraverse1(tree); + cout< +using namespace std; + +//Ķ洢ʾ +typedef struct BiNode +{ + char data; // + struct BiNode *lchild,*rchild; //Һָ +}BiTNode,*BiTree; + +void CreateBiTree(BiTree &T) +{ + //нֵһַʾĶT + char ch; + cin >> ch; + if(ch=='#') T=NULL; //ݹ + else{ + T=new BiTNode; + T->data=ch; //ɸ + CreateBiTree(T->lchild); //ݹ鴴 + CreateBiTree(T->rchild); //ݹ鴴 + } //else +} //CreateBiTree + +//㷨5.1 ĵݹ㷨 +void InOrderTraverse(BiTree T) +{ + //Tĵݹ㷨 + if(T){ + InOrderTraverse(T->lchild); + cout << T->data; + InOrderTraverse(T->rchild); + } +} +void main() +{ + BiTree tree; + cout<<"뽨У\n"; + CreateBiTree(tree); + cout<<"ĶУ\n"; + InOrderTraverse(tree); + cout< +using namespace std; + +//Ķ洢ʾ +typedef struct BiNode +{ + char data; // + struct BiNode *lchild,*rchild; //Һָ +}BiTNode,*BiTree; + +//㷨5.3 +void CreateBiTree(BiTree &T) +{ + //нֵһַʾĶT + char ch; + cin >> ch; + if(ch=='#') T=NULL; //ݹ + else{ + T=new BiTNode; + T->data=ch; //ɸ + CreateBiTree(T->lchild); //ݹ鴴 + CreateBiTree(T->rchild); //ݹ鴴 + } //else +} //CreateBiTree + +void Copy(BiTree T, BiTree &NewT) +{ + if(T==NULL ) + { //ǿݹ + NewT=NULL; + return; + } + else + { + NewT=new BiTNode; + NewT->data= T->data; //Ƹ + Copy(T->lchild, NewT->lchild); //ݹ鸴 + Copy(T->rchild, NewT->rchild); //ݹ鸴 + } //else +} //CopyBiTree + +//㷨5.1 ĵݹ㷨 +void InOrderTraverse(BiTree T) +{ + //Tĵݹ㷨 + if(T){ + InOrderTraverse(T->lchild); + cout << T->data; + InOrderTraverse(T->rchild); + } +} +void main() +{ + BiTree tree,new_tree; + cout<<"뽨У\n"; + CreateBiTree(tree); + Copy(tree,new_tree); + cout<<"ƵõУ\n"; + InOrderTraverse(new_tree); + cout< +using namespace std; + +//Ķ洢ʾ +typedef struct BiNode +{ + char data; // + struct BiNode *lchild,*rchild; //Һָ +}BiTNode,*BiTree; + +//㷨5.3 +void CreateBiTree(BiTree &T) +{ + //нֵһַʾĶT + char ch; + cin >> ch; + if(ch=='#') T=NULL; //ݹ + else{ + T=new BiTNode; + T->data=ch; //ɸ + CreateBiTree(T->lchild); //ݹ鴴 + CreateBiTree(T->rchild); //ݹ鴴 + } //else +} //CreateBiTree + +int Depth(BiTree T) +{ + int m,n; + if(T == NULL ) return 0; //ǿΪ0ݹ + else + { + m=Depth(T->lchild); //ݹȼΪm + n=Depth(T->rchild); //ݹȼΪn + if(m>n) return(m+1); //Ϊm nĽϴ߼1 + else return (n+1); + } +} + +void main() +{ + BiTree tree; + cout<<"뽨У\n"; + CreateBiTree(tree); + cout<<"Ϊ"< +using namespace std; + +//Ķ洢ʾ +typedef struct BiNode +{ + char data; // + struct BiNode *lchild,*rchild; //Һָ +}BiTNode,*BiTree; + +//㷨5.3 +void CreateBiTree(BiTree &T) +{ + //нֵһַʾĶT + char ch; + cin >> ch; + if(ch=='#') T=NULL; //ݹ + else{ + T=new BiTNode; + T->data=ch; //ɸ + CreateBiTree(T->lchild); //ݹ鴴 + CreateBiTree(T->rchild); //ݹ鴴 + } //else +} //CreateBiTree + +int NodeCount(BiTree T) +{ + if(T==NULL) return 0; // ǿΪ0ݹ + else return NodeCount(T->lchild)+ NodeCount(T->rchild) +1; + //ΪĽ+Ľ+1 +} + +void main() +{ + BiTree tree; + cout<<"뽨У\n"; + CreateBiTree(tree); + cout<<"Ϊ"< +using namespace std; + +//Ķʹ洢ʾ +typedef struct BiThrNode +{ + char data; // + struct BiThrNode *lchild,*rchild; //Һָ + int LTag,RTag; +}BiThrNode,*BiThrTree; + +//ȫֱpre +BiThrNode *pre=new BiThrNode; + +//㷨5.3 +void CreateBiTree(BiThrTree &T) +{ + //нֵһַʾĶT + char ch; + cin >> ch; + if(ch=='#') T=NULL; //ݹ + else + { + T=new BiThrNode; + T->data=ch; //ɸ + CreateBiTree(T->lchild); //ݹ鴴 + CreateBiTree(T->rchild); //ݹ鴴 + } //else +} //CreateBiTree + +void InThreading(BiThrTree p) +{ + //preȫֱʼʱҺָΪգ㿪ʼ + if(p) + { + InThreading(p->lchild); //ݹ + if(!p->lchild) + { //pΪ + p->LTag=1; //p + p->lchild=pre; //pָָpreǰ + } + else + p->LTag=0; + if(!pre->rchild) + { //preҺΪ + pre->RTag=1; //pre + pre->rchild=p; //preҺָָp̣ + } + else + pre->RTag=0; + pre=p; //preָpǰ + InThreading(p->rchild); //ݹ + } +}//InThreading + +void main() +{ + pre->RTag=1; + pre->rchild=NULL; + BiThrTree tree; + cout<<"뽨У\n"; + CreateBiTree(tree); + InThreading(tree); + cout<<"ϣ\n"; +} diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.8.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.8.cpp new file mode 100644 index 0000000..ceaade5 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.8.cpp @@ -0,0 +1,85 @@ +//㷨5.8 ͷ +#include +using namespace std; + +//Ķʹ洢ʾ +typedef struct BiThrNode +{ + char data; // + struct BiThrNode *lchild,*rchild; //Һָ + int LTag,RTag; +}BiThrNode,*BiThrTree; + +//ȫֱpre +BiThrNode *pre=new BiThrNode; + +//㷨5.3 +void CreateBiTree(BiThrTree &T) +{ + //нֵһַʾĶT + char ch; + cin >> ch; + if(ch=='#') T=NULL; //ݹ + else + { + T=new BiThrNode; + T->data=ch; //ɸ + CreateBiTree(T->lchild); //ݹ鴴 + CreateBiTree(T->rchild); //ݹ鴴 + } //else +} //CreateBiTree + +//㷨5.7 ԽPΪ +void InThreading(BiThrTree p) +{ + //preȫֱʼʱҺָΪգ㿪ʼ + if(p) + { + InThreading(p->lchild); //ݹ + if(!p->lchild) + { //pΪ + p->LTag=1; //p + p->lchild=pre; //pָָpreǰ + } + else + p->LTag=0; + if(!pre->rchild) + { //preҺΪ + pre->RTag=1; //pre + pre->rchild=p; //preҺָָp̣ + } + else + pre->RTag=0; + pre=p; //preָpǰ + InThreading(p->rchild); //ݹ + } +}//InThreading + +void InOrderThreading (BiThrTree &Thrt,BiThrTree T) +{ + //TThrtָͷ + Thrt=new BiThrNode; //ͷ + Thrt->LTag=0; //ͷӣǿգΪ + Thrt->RTag=1; //ͷҺָΪ + Thrt->rchild=Thrt; //ʼʱָָԼ + if(!T) Thrt->lchild=Thrt; //ΪգָҲָԼ + else + { + Thrt->lchild=T; pre=Thrt; //ͷָpreֵָͷ + InThreading(T); //㷨5.7TΪĶ + pre->rchild=Thrt; //㷨5.7preΪҽ㣬preָͷ + pre->RTag=1; + Thrt->rchild=pre; //ͷָpre + } +} //InOrderThreading + +void main() +{ + pre->RTag=1; + pre->rchild=NULL; + BiThrTree tree,Thrt; + cout<<"뽨У\n"; + CreateBiTree(tree); + InOrderThreading(Thrt,tree); + cout<<"!\n"; +} diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.9.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.9.cpp new file mode 100644 index 0000000..9453d81 --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第5章/5.9.cpp @@ -0,0 +1,108 @@ +//㷨5.9 +#include +using namespace std; + +//Ķʹ洢ʾ +typedef struct BiThrNode +{ + char data; // + struct BiThrNode *lchild,*rchild; //Һָ + int LTag,RTag; +}BiThrNode,*BiThrTree; + +//ȫֱpre +BiThrNode *pre=new BiThrNode; + +//㷨5.3 +void CreateBiTree(BiThrTree &T) +{ + //нֵһַʾĶT + char ch; + cin >> ch; + if(ch=='#') T=NULL; //ݹ + else + { + T=new BiThrNode; + T->data=ch; //ɸ + CreateBiTree(T->lchild); //ݹ鴴 + CreateBiTree(T->rchild); //ݹ鴴 + } //else +} //CreateBiTree + +//㷨5.7ԽPΪ +void InThreading(BiThrTree p) +{ + //preȫֱʼʱҺָΪգ㿪ʼ + if(p) + { + InThreading(p->lchild); //ݹ + if(!p->lchild) + { //pΪ + p->LTag=1; //p + p->lchild=pre; //pָָpreǰ + } + else + p->LTag=0; + if(!pre->rchild) + { //preҺΪ + pre->RTag=1; //pre + pre->rchild=p; //preҺָָp̣ + } + else + pre->RTag=0; + pre=p; //preָpǰ + InThreading(p->rchild); //ݹ + } +}//InThreading + +//㷨5.8ͷ +void InOrderThreading (BiThrTree &Thrt,BiThrTree T) +{ + //TThrtָͷ + Thrt=new BiThrNode; //ͷ + Thrt->LTag=0; //ͷӣǿգΪ + Thrt->RTag=1; //ͷҺָΪ + Thrt->rchild=Thrt; //ʼʱָָԼ + if(!T) Thrt->lchild=Thrt; //ΪգָҲָԼ + else + { + Thrt->lchild=T; pre=Thrt; //ͷָpreֵָͷ + InThreading(T); //㷨5.7TΪĶ + pre->rchild=Thrt; //㷨5.7preΪҽ㣬preָͷ + pre->RTag=1; + Thrt->rchild=pre; //ͷָpre + } +} //InOrderThreading + +void InOrderTraverse_Thr(BiThrTree T) +{ + //Tָͷ㣬ͷlchildָ㣬ɲμ㷨5.8 + //Tķǵݹ㷨ÿԪֱ + BiThrTree p; + p=T->lchild; //pָ + while(p!=T) //ʱp==T + { + while(p->LTag==0) // + p=p->lchild; //ΪյĽ + cout<data; + while(p->RTag==1&&p->rchild!=T) + { + p=p->rchild; //ʺ̽ + cout<data; + } + p=p->rchild; + } +} //InOrderTraverse_Thr + +void main() +{ + pre->RTag=1; + pre->rchild=NULL; + BiThrTree tree,Thrt; + cout<<"뽨У\n"; + CreateBiTree(tree); + InOrderThreading(Thrt,tree); + cout<<"ĽΪ\n"; + InOrderTraverse_Thr(Thrt); + cout< +using namespace std; + +#define MaxInt 32767 //ʾֵ +#define MVNum 100 //󶥵 +#define OK 1 + +typedef char VerTexType; //趥Ϊַ +typedef int ArcType; //ߵȨֵΪ + +//- - - - -ͼڽӾ洢ʾ- - - - - +typedef struct{ + VerTexType vexs[MVNum]; // + ArcType arcs[MVNum][MVNum]; //ڽӾ + int vexnum,arcnum; //ͼĵǰͱ +}AMGraph; + +int LocateVex(AMGraph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vexs[i] == v) + return i; + return -1; +}//LocateVex + +int CreateUDN(AMGraph &G){ + //ڽӾʾG + int i , j , k; + cout <<"ܱܶԿո"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣa" << endl; + + for(i = 0; i < G.vexnum; ++i){ + cout << "" << (i+1) << ":"; + cin >> G.vexs[i]; //Ϣ + } + cout << endl; + for(i = 0; i < G.vexnum; ++i) //ʼڽӾ󣬱ߵȨֵΪֵMaxInt + for(j = 0; j < G.vexnum; ++j) + G.arcs[i][j] = MaxInt; + cout << "Ķ㼰Ȩֵ a b 5" << endl; + for(k = 0; k < G.arcnum;++k){ //ڽӾ + VerTexType v1 , v2; + ArcType w; + cout << "" << (k + 1) << "Ķ㼰Ȩֵ:"; + cin >> v1 >> v2 >> w; //һĶ㼰Ȩֵ + i = LocateVex(G, v1); j = LocateVex(G, v2); //ȷv1v2Gеλã± + G.arcs[i][j] = w; //ȨֵΪw + G.arcs[j][i] = G.arcs[i][j]; //ĶԳƱȨֵΪw + }//for + return OK; +}//CreateUDN + +int main(){ + cout << "************㷨6.1ڽӾʾ**************" << endl << endl; + AMGraph G; int i , j; + CreateUDN(G); + + cout < +using namespace std; + +#define MaxInt 32767 //ʾֵ +#define MVNum 100 //󶥵 +typedef char VerTexType; //趥Ϊַ +typedef int ArcType; //ߵȨֵΪ + +int *D=new int[MVNum]; //ڼ¼·ij +bool *S=new bool[MVNum]; //ǶǷS +int *Path=new int[MVNum]; //ڼ¼·ǰ + +//------------ͼڽӾ----------------- +typedef struct{ + VerTexType vexs[MVNum]; // + ArcType arcs[MVNum][MVNum]; //ڽӾ + int vexnum,arcnum; //ͼĵǰͱ +}AMGraph; + +int LocateVex(AMGraph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vexs[i] == v) + return i; + return -1; +}//LocateVex + +void CreateUDN(AMGraph &G){ + //ڽӾʾG + int i , j , k; + cout <<"ܱܶԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << ":a" << endl; + + for(i = 0; i < G.vexnum; ++i){ + cout << "" << (i+1) << ":"; + cin >> G.vexs[i]; //Ϣ + } + cout << endl; + for(i = 0; i < G.vexnum; ++i) //ʼڽӾ󣬱ߵȨֵΪֵMaxInt + for(j = 0; j < G.vexnum; ++j) + G.arcs[i][j] = MaxInt; + cout << "Ķ㼰Ȩֵa b 7" << endl; + for(k = 0; k < G.arcnum;++k){ //ڽӾ + VerTexType v1 , v2; + ArcType w; + cout << "" << (k + 1) << "Ķ㼰Ȩֵ:"; + cin >> v1 >> v2 >> w; //һĶ㼰Ȩֵ + i = LocateVex(G, v1); j = LocateVex(G, v2); //ȷv1v2Gеλã± + G.arcs[i][j] = w; //ȨֵΪw + G.arcs[j][i] = G.arcs[i][j]; //ĶԳƱȨֵΪw + }//for +}//CreateUDN + +void ShortestPath_DIJ(AMGraph G, int v0){ + //Dijkstra㷨Gv0㵽ඥ· + int v , i , w , min; + int n = G.vexnum; //nΪGжĸ + + for(v = 0; v < n; ++v){ //nγʼ + S[v] = false; //SʼΪռ + D[v] = G.arcs[v0][v]; //v0յ·ȳʼΪϵȨֵ + if(D[v] < MaxInt) Path [v] = v0; //v0v֮лvǰΪv0 + else Path [v] = -1; //v0v֮޻vǰΪ-1 + }//for + + S[v0]=true; //v0S + D[v0]=0; //Դ㵽ԴľΪ0 + + /*Dʼʼѭÿv0ijv·vӵSD*/ + for(i = 1;i < n; ++i){ //n-1㣬νм + min= MaxInt; + for(w = 0; w < n; ++w) + if(!S[w] && D[w] < min){ //ѡһǰ·յΪv + v = w; + min = D[w]; + }//if + S[v]=true; //vS + for(w = 0;w < n; ++w) //´v0V?Sж· + if(!S[w] && (D[v] + G.arcs[v][w] < D[w])){ + D[w] = D[v] + G.arcs[v][w]; //D[w] + Path [w] = v; //wǰΪv + }//if + }//for +}//ShortestPath_DIJ + +void DisplayPath(AMGraph G , int begin ,int temp ){ + //ʾ· + if(Path[temp] != -1){ + DisplayPath(G , begin ,Path[temp]); + cout << G.vexs[Path[temp]] << "-->"; + } +}//DisplayPath + +void main() +{ + cout << "************㷨6.10Ͻ˹㷨**************" << endl << endl; + AMGraph G; + int i , j ,num_start , num_destination; + VerTexType start , destination; + CreateUDN(G); + cout <> start >> destination; + num_start = LocateVex(G , start); + num_destination = LocateVex(G , destination); + ShortestPath_DIJ(G , num_start); + cout << endl <<"·Ϊ"; + DisplayPath(G , num_start , num_destination); + cout << G.vexs[num_destination]< +using namespace std; + +#define MaxInt 32767 //ʾֵ +#define MVNum 100 //󶥵 + +typedef char VerTexType; //趥Ϊַ +typedef int ArcType; //ߵȨֵΪ + +int Path[MVNum][MVNum]; //·϶vjǰһ +int D[MVNum][MVNum]; //¼vivj֮· + +//------------ͼڽӾ--------------- +typedef struct{ + VerTexType vexs[MVNum]; // + ArcType arcs[MVNum][MVNum]; //ڽӾ + int vexnum,arcnum; //ͼĵǰͱ +}AMGraph; + +int LocateVex(AMGraph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vexs[i] == v) + return i; + return -1; +}//LocateVex + +void CreateUDN(AMGraph &G){ + //ڽӾʾG + int i , j , k; + cout <<"ܱܶԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣa" << endl; + + for(i = 0; i < G.vexnum; ++i){ + cout << "" << (i+1) << ":"; + cin >> G.vexs[i]; //Ϣ + } + cout << endl; + for(i = 0; i < G.vexnum; ++i){ //ʼڽӾ󣬱ߵȨֵΪֵMaxInt + for(j = 0; j < G.vexnum; ++j){ + if(j != i) + G.arcs[i][j] = MaxInt; + else + G.arcs[i][j] = 0; + }//for + }//for + + cout << "Ķ㼰Ȩֵa b 3" << endl; + for(k = 0; k < G.arcnum;++k){ //ڽӾ + VerTexType v1 , v2; + ArcType w; + cout << "" << (k + 1) << "Ķ㼰Ȩֵ:"; + cin >> v1 >> v2 >> w; //һĶ㼰Ȩֵ + i = LocateVex(G, v1); j = LocateVex(G, v2); //ȷv1v2Gеλã± + G.arcs[i][j] = w; //ȨֵΪw + }//for +}//CreateUDN + +void ShortestPath_Floyed(AMGraph G){ + //Floyd㷨GиԶij֮· + int i , j , k ; + for (i = 0; i < G.vexnum; ++i) //Խ֮ʼ֪· + for(j = 0; j < G.vexnum; ++j){ + D[i][j] = G.arcs[i][j]; + if(D[i][j] < MaxInt && i != j) Path[i][j]=i; //ij֮лjǰΪi + else Path [i][j] = -1; //ij֮޻jǰΪ-1 + }//for + for(k = 0; k < G.vexnum; ++k) + for(i = 0; i < G.vexnum; ++i) + for(j = 0; j < G.vexnum; ++j) + if(D[i][k] + D[k][j] < D[i][j]){ //ikjһ· + D[i][j] = D[i][k]+D[k][j]; //D[i][j] + Path[i][j] = Path[k][j]; //jǰΪk + }//if +}//ShortestPath_Floyed + +void DisplayPath(AMGraph G , int begin ,int temp ){ + //ʾ· + if(Path[begin][temp] != -1){ + DisplayPath(G , begin ,Path[begin][temp]); + cout << G.vexs[Path[begin][temp]] << "-->"; + } +}//DisplayPath + +void main(){ + cout << "************㷨6.11㷨**************" << endl << endl; + AMGraph G; + char start , destination; + int num_start , num_destination; + + CreateUDN(G); + + cout <> start >> destination; + num_start = LocateVex(G , start); + num_destination = LocateVex(G , destination); + + DisplayPath(G , num_start , num_destination); + cout << G.vexs[num_destination] << endl; + cout << "·ijΪ" << D[num_start][num_destination] << endl; + cout < +using namespace std; + +#define MVNum 100 //󶥵 +#define OK 1 +#define ERROR 0 + +typedef char VerTexType; + +//- - - - -ͼڽӱ洢ʾ- - - - - +typedef struct ArcNode{ //߽ + int adjvex; //ñָĶλ + struct ArcNode *nextarc; //ָһߵָ +}ArcNode; + +typedef struct VNode{ + VerTexType data; //Ϣ + ArcNode *firstarc; //ָһöıߵָ +}VNode, AdjList[MVNum]; //AdjListʾڽӱ + +typedef struct{ + AdjList vertices; //ڽӱ + AdjList converse_vertices; //ڽӱ + int vexnum, arcnum; //ͼĵǰͱ +}ALGraph; +//- - - - - - - - - - - - - - - - + +//- - - - -˳ջĶ- - - - - +typedef struct{ + int *base; + int *top; + int stacksize; +}spStack; +//- - - - - - - - - - - - - - - - + +int indegree[MVNum]; //indegreeŸ +spStack S; + +//------------ջز---------------------- +void InitStack(spStack &S){ + //ʼջ + S.base = new int[MVNum]; + if(!S.base) + exit(1); + S.top = S.base; + S.stacksize = MVNum; +}//InitStack + +void Push(spStack &S , int i){ + //ջ + if(S.top - S.base == S.stacksize) + return; + *S.top++ = i; +}//Push + +void Pop(spStack &S , int &i){ + //ջ + if(S.top == S.base) + return; + i = *--S.top; +}//Pop + +bool StackEmpty(spStack S){ + //жջǷΪ + if(S.top == S.base) + return true; + return false; +}//StackEmpty +//------------------------------------------------- + +int LocateVex(ALGraph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vertices[i].data == v) + return i; + return -1; +}//LocateVex + +int CreateUDG(ALGraph &G){ + //ͼGڽӱڽӱ + int i , k; + + cout <<"ܱܶԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣa" << endl; + + for(i = 0; i < G.vexnum; ++i){ //㣬ͷ + cout << "" << (i+1) << ":"; + cin >> G.vertices[i].data; //붥ֵ + G.converse_vertices[i].data = G.vertices[i].data; + //ʼͷָΪNULL + G.vertices[i].firstarc=NULL; + G.converse_vertices[i].firstarc=NULL; + }//for + cout << endl; + cout << "Ķ㣬a b" << endl; + for(k = 0; k < G.arcnum;++k){ //ߣڽӱ + VerTexType v1 , v2; + int i , j; + cout << "" << (k + 1) << "Ķ:"; + cin >> v1 >> v2; //һ + i = LocateVex(G, v1); j = LocateVex(G, v2); + //ȷv1v2GλãG.verticesе + + ArcNode *p1=new ArcNode; //һµı߽*p1 + p1->adjvex=j; //ڽӵΪj + p1->nextarc = G.vertices[i].firstarc; G.vertices[i].firstarc=p1; + //½*p1붥viı߱ͷ + + ArcNode *p2=new ArcNode; //һµı߽*p1 + p2->adjvex=i; //ڽӵΪi + p2->nextarc = G.converse_vertices[j].firstarc; G.converse_vertices[j].firstarc=p2; + //½*p1붥viı߱ͷ + }//for + return OK; +}//CreateUDG + +void FindInDegree(ALGraph G){ + //ȴindegree + int i , count; + + for(i = 0 ; i < G.vexnum ; i++){ + count = 0; + ArcNode *p = G.converse_vertices[i].firstarc; + if(p){ + while(p){ + p = p->nextarc; + count++; + } + } + indegree[i] = count; + } +}//FindInDegree + +int TopologicalSort(ALGraph G , int topo[]){ + //ͼGڽӱ洢ṹ + //G޻·Gһtopo[]OKERROR + int i , m; + FindInDegree(G); //ȴindegree + InitStack(S); //ջSʼΪ + for(i = 0; i < G.vexnum; ++i) + if(!indegree[i]) Push(S, i); //Ϊ0߽ջ + m = 0; //ʼΪ0 + while(!StackEmpty(S)){ //ջSǿ + Pop(S, i); //ջviջ + topo[m]=i; //vitopo + ++m; // + ArcNode *p = G.vertices[i].firstarc; //pָviĵһڽӵ + while(p){ + int k = p->adjvex; //vkΪviڽӵ + --indegree[k]; //viÿڽӵȼ1 + if(indegree[k] ==0) Push(S, k); //ȼΪ0ջ + p = p->nextarc; //pָ򶥵viһڽӽ + }//while + }//while + + if(m < G.vexnum) return ERROR; //ͼл· + else return OK; +}//TopologicalSort + +int main(){ + cout << "************㷨6.12**************" << endl << endl; + ALGraph G; + CreateUDG(G); + int *topo = new int [G.vexnum]; + + cout << endl; + cout << "ͼڽӱڽӱ!" << endl << endl; + + if(TopologicalSort(G , topo)){ + cout << "ͼΪ"; + for(int j = 0 ; j < G.vexnum; j++){ + if(j != G.vexnum - 1) + cout << G.vertices[topo[j]].data << " , "; + else + cout << G.vertices[topo[j]].data << endl << endl; + }//for + } + else + cout << "дڻ޷" < +using namespace std; + +#define MVNum 100 //󶥵 +#define BDNum MVNum * (MVNum - 1) // +#define OK 1 +#define ERROR 0 + +typedef char VerTexType; + +//- - - - -ͼڽӱ洢ʾ- - - - - +typedef struct ArcNode{ //߽ + int adjvex; //ñָĶλ + int weight; //Ȩֵ + struct ArcNode *nextarc; //ָһߵָ +}ArcNode; + +typedef struct VNode{ + VerTexType data; //Ϣ + ArcNode *firstarc; //ָһöıߵָ +}VNode, AdjList[MVNum]; //AdjListʾڽӱ + +typedef struct{ + AdjList vertices; //ڽӱ + AdjList converse_vertices; //ڽӱ + int vexnum, arcnum; //ͼĵǰͱ +}ALGraph; +//- - - - - - - - - - - - - - - - + +//- - - - -˳ջĶ- - - - - +typedef struct{ + int *base; + int *top; + int stacksize; +}spStack; +//- - - - - - - - - - - - - - - - + +int indegree[MVNum]; //indegreeŸ +int ve[BDNum]; //¼vi緢ʱ +int vl[BDNum]; //¼viٷʱ +int topo[MVNum]; //¼еĶ +spStack S; + +//----------------ջIJ-------------------- +void InitStack(spStack &S){ + //ջijʼ + S.base = new int[MVNum]; + if(!S.base) + exit(1); + S.top = S.base; + S.stacksize = MVNum; +}//InitStack + +void Push(spStack &S , int i){ + //ջ + if(S.top - S.base == S.stacksize) + return; + *S.top++ = i; +}//Push + +void Pop(spStack &S , int &i){ + //ջ + if(S.top == S.base) + return; + i = *--S.top; +}//Pop + +bool StackEmpty(spStack S){ + //жջǷΪ + if(S.top == S.base) + return true; + return false; +}//StackEmpty +//--------------------------------------- + +int LocateVex(ALGraph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vertices[i].data == v) + return i; + return -1; +}//LocateVex + +int CreateUDG(ALGraph &G){ + //ͼGڽӱڽӱ + int i , k; + + cout <<"ܱܶԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣa" << endl; + + for(i = 0; i < G.vexnum; ++i){ //㣬ͷ + cout << "" << (i+1) << ":"; + cin >> G.vertices[i].data; //붥ֵ + G.converse_vertices[i].data = G.vertices[i].data; + //ʼͷָΪNULL + G.vertices[i].firstarc=NULL; + G.converse_vertices[i].firstarc=NULL; + }//for + cout << endl; + + cout << "Ķ㼰Ȩֵa b 3" << endl; + + for(k = 0; k < G.arcnum;++k){ //ߣڽӱ + VerTexType v1 , v2; + int i , j , w; + cout << "" << (k + 1) << "Ķ㼰Ȩֵ:"; + cin >> v1 >> v2 >> w; //һ + i = LocateVex(G, v1); j = LocateVex(G, v2); + //ȷv1v2GλãG.verticesе + + ArcNode *p1=new ArcNode; //һµı߽*p1 + p1->adjvex=j; //ڽӵΪj + p1->nextarc = G.vertices[i].firstarc; G.vertices[i].firstarc=p1; + p1->weight = w; + //½*p1붥viı߱ͷ + + ArcNode *p2=new ArcNode; //һµı߽*p1 + p2->adjvex=i; //ڽӵΪi + p2->nextarc = G.converse_vertices[j].firstarc; G.converse_vertices[j].firstarc=p2; + p2->weight = w; + //½*p1붥viı߱ͷ + }//for + return OK; +}//CreateUDG + +void FindInDegree(ALGraph G){ + //ȴindegree + int i , count; + + for(i = 0 ; i < G.vexnum ; i++){ + count = 0; + ArcNode *p = G.converse_vertices[i].firstarc; + if(p){ + while(p){ + p = p->nextarc; + count++; + } + }//if + indegree[i] = count; + }//for +}//FindInDegree + +int TopologicalOrder(ALGraph G , int topo[]){ + //ͼGڽӱ洢ṹ + //G޻·Gһtopo[]OKERROR + int i , m; + FindInDegree(G); //ȴindegree + InitStack(S); //ջSʼΪ + for(i = 0; i < G.vexnum; ++i) + if(!indegree[i]) Push(S, i); //Ϊ0߽ջ + m = 0; //ʼΪ0 + while(!StackEmpty(S)){ //ջSǿ + Pop(S, i); //ջviջ + topo[m]=i; //vitopo + ++m; // + ArcNode *p = G.vertices[i].firstarc; //pָviĵһڽӵ + while(p){ + int k = p->adjvex; //vkΪviڽӵ + --indegree[k]; //viÿڽӵȼ1 + if(indegree[k] ==0) Push(S, k); //ȼΪ0ջ + p = p->nextarc; //pָ򶥵viһڽӽ + }//while + }//while + + if(m < G.vexnum) return ERROR; //ͼл· + else return OK; +}//TopologicalOrder + +int CriticalPath(ALGraph G){ + //GΪڽӱ洢Gĸؼ + int n , i , k , j , e , l; + if (!TopologicalOrder(G, topo)) return ERROR; + //㷨ʹбtopoУʧܣ򻷣ERROR + n = G.vexnum; //nΪ + for(i = 0; i < n; i++) //ÿ¼緢ʱóֵ0 + ve[i] = 0; + + + /*DDDDDDDDDD˴ÿ¼緢ʱ䣭DDDDDDDDD*/ + for(i = 0;i < n; i++){ + k = topo[i]; //ȡеĶk + ArcNode *p = G.vertices[k].firstarc; //pָkĵһڽӶ + while(p != NULL){ //θkڽӶ緢ʱ + j = p->adjvex; //jΪڽӶ + if(ve[j] < ve[k] + p->weight) //¶j緢ʱve[j] + ve[j] = ve[k] + p->weight; + p = p->nextarc; //pָkһڽӶ + } //while + } //for + + for(i=0;i= 0; i--){ + k = topo[i]; //ȡеĶk + ArcNode *p = G.vertices[k].firstarc; //pָkĵһڽӶ + while(p != NULL){ //kڽӵ㣬kٷʱ + j = p->adjvex; //jΪڽӶ + if(vl[k] > vl[j] - p->weight) //¶kٷʱvl[k] + vl[k] = vl[j] - p->weight; + p = p->nextarc; //pָkһڽӶ + }//while + }//for + + /*DDDDDDDDDDDDжÿһǷΪؼDDDDDDDDDDD*/ + cout << endl; + cout << "ؼ·Ϊ:"; + for(i = 0;i < n; i++){ //ÿѭviΪʼл + ArcNode *p = G.vertices[i].firstarc; //pָiĵһڽӶ + while(p != NULL) { + j = p->adjvex; //jΪiڽӶ + e = ve[i]; //翪ʼʱ + l = vl[j] - p->weight; //ٿʼʱ + if(e == l) //Ϊؼ + cout << G.vertices[i].data << "-->" << G.vertices[j].data << " "; + p = p->nextarc; //pָiһڽӶ + } //while + } //for + return OK; +}//CriticalPath + +int main(){ + cout << "************㷨6.13ؼ·㷨**************" << endl << endl; + ALGraph G; + CreateUDG(G); + int *topo = new int [G.vexnum]; + + cout << endl; + cout << "ͼ!" << endl << endl; + + if(!CriticalPath(G)) + cout << "дڻ޷" < +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +//#define ONLINE_JUDGE +#define eps 1e-8 +#define INF 0x7fffffff +#define FOR(i,a) for((i)=0;i<(a);(i)++) +#define MEM(a) (memset((a),0,sizeof(a))) +#define sfs(a) scanf("%s",a) +#define sf(a) scanf("%d",&a) +#define sfI(a) scanf("%I64d",&a) +#define pf(a) printf("%d\n",a) +#define pfI(a) printf("%I64d\n",a) +#define pfs(a) printf("%s\n",a) +#define sfd(a,b) scanf("%d%d",&a,&b) +#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c) +#define for1(i,a,b) for(int i=(a);i=a;i--) +#define MEM1(a) memset(a,0,sizeof(a)) +#define MEM2(a) memset(a,-1,sizeof(a)) +const double PI=acos(-1.0); +template T gcd(T a,T b){return b?gcd(b,a%b):a;} +template T lcm(T a,T b){return a/gcd(a,b)*b;} +template inline T Min(T a,T b){return a inline T Max(T a,T b){return a>b?a:b;} +using namespace std; +#define ll __int64 +int n,m; +#define Mod 10 +#define N 10010 +#define M 1000010 +struct Edge{ //洢ߵĽṹ + int to; + int next; +}; +struct Node{ //洢Ľṹ + int id; + int step; +}; +struct sqQueue{ //еĽṹ + Node *base; + int front; + int rear; +}; +Edge edge[N]; // +int head[N]; +int vis[N]; +int cnt; +sqQueue Q; +void Init(){ + memset(head,-1,sizeof head); + cnt=0; +} +void addEdge(int u,int v){ //ӱ + edge[cnt].to = v; + edge[cnt].next = head[u]; + head[u] = cnt++; +} +void InitQueue(sqQueue &Q){ //ʼ + Q.base = new Node[M]; + if(!Q.base) + exit(OVERFLOW); + Q.front = Q.rear = 0; + return; +} +int QueueLength(sqQueue Q){ //еij + return(Q.rear-Q.front+M)%M; +} +int EnQueue(sqQueue &Q,Node e){ // + if((Q.rear+1)%M == Q.front) + return 0; + Q.base[Q.rear] = e; + Q.rear = (Q.rear+1)%M; + return 1; +} +int DeQueue(sqQueue &Q){ // + if(Q.front == Q.rear) + return 0; + Q.front = (Q.front+1)%M; + return 1; +} +Node getHead(sqQueue Q){ //õͷԪ + return Q.base[Q.front]; +} +void bfs(){ //bfsʼ벻7ĵĸռİٷֱ + memset(vis,0,sizeof vis); + InitQueue(Q); + Node cur,next; + cur.id = 0; + cur.step = 0; + EnQueue(Q,cur); + vis[0] = 1; + int num = 0; + while(QueueLength(Q)){ + cur = getHead(Q); + DeQueue(Q); + if(cur.step>7){ + break; + } + num++; + int s = cur.id; + for(int p = head[s];p!=-1;p=edge[p].next){ + int v = edge[p].to; + if(!vis[v]){ + next.id = v; + next.step = cur.step + 1; + vis[v] = 1; + EnQueue(Q,next); + } + } + } + printf("%.4f\n",num*1.0/n); +} +int main(){ +#ifndef ONLINE_JUDGE + freopen("in.txt","r",stdin); +// freopen("out.txt","w",stdout); +#endif + while(sfd(n,m)!=EOF){ //nΪmΪߵ,ıŴ0-n-1 + Init(); //ʼ + int u,v; + for(int i=0;i +using namespace std; + +#define MVNum 100 //󶥵 +#define OK 1 + +typedef char VerTexType; //Ϣ +typedef int OtherInfo; //ͱصϢ + +//- - - - -ͼڽӱ洢ʾ- - - - - +typedef struct ArcNode{ //߽ + int adjvex; //ñָĶλ + struct ArcNode *nextarc; //ָһߵָ + OtherInfo info; //ͱصϢ +}ArcNode; + +typedef struct VNode{ + VerTexType data; //Ϣ + ArcNode *firstarc; //ָһöıߵָ +}VNode, AdjList[MVNum]; //AdjListʾڽӱ + +typedef struct{ + AdjList vertices; //ڽӱ + int vexnum, arcnum; //ͼĵǰͱ +}ALGraph; + + +int LocateVex(ALGraph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vertices[i].data == v) + return i; + return -1; +}//LocateVex + +int CreateUDG(ALGraph &G){ + //ڽӱʾͼG + int i , k; + + cout <<"ܱܶмԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣ a " <> G.vertices[i].data; //붥ֵ + G.vertices[i].firstarc=NULL; //ʼͷָΪNULL + }//for + cout << endl; + + cout << "һĶ, a b" << endl; + for(k = 0; k < G.arcnum;++k){ //ߣڽӱ + VerTexType v1 , v2; + int i , j; + cout << "" << (k + 1) << "Ķ:"; + cin >> v1 >> v2; //һ + i = LocateVex(G, v1); j = LocateVex(G, v2); + //ȷv1v2GλãG.verticesе + + ArcNode *p1=new ArcNode; //һµı߽*p1 + p1->adjvex=j; //ڽӵΪj + p1->nextarc= G.vertices[i].firstarc; G.vertices[i].firstarc=p1; + //½*p1붥viı߱ͷ + + ArcNode *p2=new ArcNode; //һԳƵµı߽*p2 + p2->adjvex=i; //ڽӵΪi + p2->nextarc= G.vertices[j].firstarc; G.vertices[j].firstarc=p2; + //½*p2붥vjı߱ͷ + }//for + return OK; +}//CreateUDG + +int main(){ + cout << "************㷨6.2ڽӱʾͼ**************" << endl << endl; + ALGraph G; + CreateUDG(G); + int i; + + cout << endl; + cout << "*****ڽӱʾͼ*****" << endl; + + for(i = 0 ; i < G.vexnum ; ++i){ + VNode temp = G.vertices[i]; + ArcNode *p = temp.firstarc; + if(p == NULL){ + cout << G.vertices[i].data; + cout << endl; + } + else{ + cout << temp.data; + while(p){ + cout << "->"; + cout << p->adjvex; + p = p->nextarc; + } + } + cout << endl; + } + return 0; +}//main diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第6章/6.3.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第6章/6.3.cpp new file mode 100644 index 0000000..65cda6f --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第6章/6.3.cpp @@ -0,0 +1,114 @@ +//㷨6.3ͨͼĵݹ㷨 + +#include +using namespace std; + +#define MVNum 100 //󶥵 +typedef char VerTexType; //趥Ϊַ +typedef int ArcType; //ߵȨֵΪ + +typedef struct{ + VerTexType vexs[MVNum]; // + ArcType arcs[MVNum][MVNum]; //ڽӾ + int vexnum,arcnum; //ͼĵǰͱ +}Graph; + +bool visited[MVNum]; //ʱ־飬ֵΪ"false" +int FirstAdjVex(Graph G , int v); //vĵһڽӵ +int NextAdjVex(Graph G , int v , int w); //vwһڽӵ + +int LocateVex(Graph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vexs[i] == v) + return i; + return -1; +}//LocateVex + +void CreateUDN(Graph &G){ + //ڽӾʾG + int i , j , k; + cout <<"ܱܶ , Կո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣ a" << endl; + + for(i = 0; i < G.vexnum; ++i){ + cout << "" << (i+1) << ":"; + cin >> G.vexs[i]; //Ϣ + } + cout << endl; + + for(i = 0; i < G.vexnum; ++i) //ʼڽӾ󣬱ߵȨֵΪֵMaxInt + for(j = 0; j < G.vexnum; ++j) + G.arcs[i][j] = 0; + cout << "Ķ㣬磺a b" << endl; + for(k = 0; k < G.arcnum;++k){ //ڽӾ + VerTexType v1 , v2; + cout << "" << (k + 1) << "Ķ:"; + cin >> v1 >> v2; //һĶ㼰Ȩֵ + i = LocateVex(G, v1); j = LocateVex(G, v2); //ȷv1v2Gеλã± + G.arcs[j][i] = G.arcs[i][j] = 1; //ĶԳƱȨֵΪw + }//for +}//CreateUDN + +void DFS(Graph G, int v){ //ӵvݹȱͼG + cout << G.vexs[v] << " "; visited[v] = true; //ʵv㣬÷ʱ־ӦֵΪtrue + int w; + for(w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w)) + //μvڽӵw FirstAdjVex(G, v)ʾvĵһڽӵ + //NextAdjVex(G, v, w)ʾvwһڽӵ㣬w0ʾڽӵ + if(!visited[w]) DFS(G, w); //vδʵڽӶwݹDFS +}//DFS + +int FirstAdjVex(Graph G , int v){ + int i; + for(i = 0 ; i < G.vexnum ; ++i){ + if(G.arcs[v][i] == 1 && visited[i] == false) + return i; + } + return -1; +}//FirstAdjVex + +int NextAdjVex(Graph G , int v , int w){ + int i; + for(i = w ; i < G.vexnum ; ++i){ + if(G.arcs[v][i] == 1 && visited[i] == false) + return i; + } + return -1; +}//NextAdjVex + +int main(){ + cout << "************㷨6.3ͨͼĵݹ㷨**************" << endl << endl; + Graph G; + CreateUDN(G); + cout << endl; + cout << "ͨͼGɣ" << endl << endl; + + cout << "ͨͼʼ㣺"; + VerTexType c; + cin >> c; + + int i; + for(i = 0 ; i < G.vexnum ; ++i){ + if(c == G.vexs[i]) + break; + } + cout << endl; + while(i >= G.vexnum){ + cout << "õ㲻ڣ룡" << endl; + cout << "ͨͼʼ㣺"; + cin >> c; + for(i = 0 ; i < G.vexnum ; ++i){ + if(c == G.vexs[i]) + break; + } + } + cout << "ͨͼ" << endl; + DFS(G , i); + + cout < +using namespace std; + +#define MVNum 100 //󶥵 +typedef char VerTexType; //趥Ϊַ +typedef int ArcType; //ߵȨֵΪ + +//-------------ͼڽӾ----------------- +typedef struct{ + VerTexType vexs[MVNum]; // + ArcType arcs[MVNum][MVNum]; //ڽӾ + int vexnum,arcnum; //ͼĵǰͱ +}Graph; + +bool visited[MVNum]; //ʱ־飬ֵΪ"false" +int FirstAdjVex(Graph G , int v); //vĵһڽӵ +int NextAdjVex(Graph G , int v , int w); //vwһڽӵ + +int LocateVex(Graph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vexs[i] == v) + return i; + return -1; +}//LocateVex + +void CreateUDN(Graph &G){ + //ڽӾʾG + int i , j , k; + cout <<"ܱܶԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣa" << endl; + for(i = 0; i < G.vexnum; ++i){ + cout << "" << (i+1) << ":"; + cin >> G.vexs[i]; //Ϣ + } + cout << endl; + for(i = 0; i < G.vexnum; ++i) //ʼڽӾ󣬱ߵȨֵΪֵMaxInt + for(j = 0; j < G.vexnum; ++j) + G.arcs[i][j] = 0; + cout << "Ķ㣬a b" << endl; + for(k = 0; k < G.arcnum;++k){ //ڽӾ + VerTexType v1 , v2; + cout << "" << (k + 1) << "Ķ:"; + cin >> v1 >> v2; //һĶ㼰Ȩֵ + i = LocateVex(G, v1); j = LocateVex(G, v2); //ȷv1v2Gеλã± + G.arcs[j][i] = G.arcs[i][j] = 1; //ĶԳƱȨֵΪw + }//for +}//CreateUDN + +void DFS(Graph G, int v){ + //ӵvݹȱͼG + cout << G.vexs[v] << " "; visited[v] = true; //ʵv㣬÷ʱ־ӦֵΪtrue + int w; + for(w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w)) + //μvڽӵw FirstAdjVex(G, v)ʾvĵһڽӵ + //NextAdjVex(G, v, w)ʾvwһڽӵ㣬w0ʾڽӵ + if(!visited[w]) DFS(G, w); //vδʵڽӶwݹDFS +}//DFS + +void DFSTraverse(Graph G){ + //ԷͨͼGȱ + int v; + for(v = 0; v < G.vexnum; ++v) visited[v] = false; //ʱ־ʼ + for(v = 0; v < G.vexnum; ++v) //ѭ㷨6.3 + if(!visited[v]) DFS(G, v); //δʵĶDFS +}//DFSTraverse + +int FirstAdjVex(Graph G , int v){ + //vĵһڽӵ + int i; + for(i = 0 ; i < G.vexnum ; ++i){ + if(G.arcs[v][i] == 1 && visited[i] == false) + return i; + } + return -1; +}//FirstAdjVex + +int NextAdjVex(Graph G , int v , int w){ + //vwһڽӵ + int i; + for(i = w ; i < G.vexnum ; ++i){ + if(G.arcs[v][i] == 1 && visited[i] == false) + return i; + } + return -1; +}//NextAdjVex + +int main(){ + cout << "************㷨6.4ͨͼ**************" << endl << endl; + Graph G; + CreateUDN(G); + cout << endl; + cout << "ͼGɣ" << endl << endl; + + cout << "ͨͼ" << endl; + DFSTraverse(G); + + cout < +using namespace std; + +#define MVNum 100 //󶥵 +typedef char VerTexType; //趥Ϊַ +typedef int ArcType; //ߵȨֵΪ + +//------------ͼڽӾ------------------ +typedef struct{ + VerTexType vexs[MVNum]; // + ArcType arcs[MVNum][MVNum]; //ڽӾ + int vexnum,arcnum; //ͼĵǰͱ +}Graph; + +bool visited[MVNum]; //ʱ־飬ֵΪ"false" +int FirstAdjVex(Graph G , int v); //vĵһڽӵ +int NextAdjVex(Graph G , int v , int w); //vwһڽӵ + +int LocateVex(Graph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vexs[i] == v) + return i; + return -1; +}//LocateVex + +void CreateUDN(Graph &G){ + //ڽӾʾG + int i , j , k; + cout <<"ܱܶԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣa" <> G.vexs[i]; //Ϣ + } + cout << endl; + + for(i = 0; i < G.vexnum; ++i) //ʼڽӾ󣬱ߵȨֵΪֵMaxInt + for(j = 0; j < G.vexnum; ++j) + G.arcs[i][j] = 0; + cout << "Ķ㣬a b" << endl; + for(k = 0; k < G.arcnum;++k){ //ڽӾ + VerTexType v1 , v2; + cout << "" << (k + 1) << "Ķ:"; + cin >> v1 >> v2; //һĶ㼰Ȩֵ + i = LocateVex(G, v1); j = LocateVex(G, v2); //ȷv1v2Gеλã± + G.arcs[j][i] = G.arcs[i][j] = 1; //ĶԳƱȨֵΪw + }//for +}//CreateUDN + +void DFS(Graph G, int v){ + //ͼGΪڽӾ + int w; + cout << G.vexs[v] << " "; visited[v] = true; //ʵv㣬÷ʱ־ӦֵΪtrue + for(w = 0; w < G.vexnum; w++) //μڽӾvڵ + if((G.arcs[v][w] != 0)&& (!visited[w])) DFS(G, w); //G.arcs[v][w]!=0ʾwvڽӵ㣬wδʣݹDFS +}//DFS + +int FirstAdjVex(Graph G , int v){ + //vĵһڽӵ + int i; + for(i = 0 ; i < G.vexnum ; ++i){ + if(G.arcs[v][i] == 1 && visited[i] == false) + return i; + } + return -1; +}//FirstAdjVex + +int NextAdjVex(Graph G , int v , int w){ + //vwһڽӵ + int i; + for(i = w ; i < G.vexnum ; ++i){ + if(G.arcs[v][i] == 1 && visited[i] == false) + return i; + } + return -1; +}//NextAdjVex + +int main(){ + cout << "************㷨6.5ڽӾʾͼ**************" << endl << endl; + Graph G; + CreateUDN(G); + cout << endl; + cout << "ͼGɣ" << endl << endl; + + cout << "ͼGʼ㣺"; + VerTexType c; + cin >> c; + + int i; + for(i = 0 ; i < G.vexnum ; ++i){ + if(c == G.vexs[i]) + break; + } + cout << endl; + while(i >= G.vexnum){ + cout << "õ㲻ڣ룡" << endl; + cout << "ͨͼʼ㣺"; + cin >> c; + for(i = 0 ; i < G.vexnum ; ++i){ + if(c == G.vexs[i]) + break; + } + } + cout << "ͼG" << endl; + DFS(G , i); + + cout < +using namespace std; + +#define MVNum 100 //󶥵 +typedef char VerTexType; //趥Ϊַ + +//-------------ͼڽӱ--------------------- +typedef struct ArcNode{ //߽ + int adjvex; //ñָĶλ + struct ArcNode *nextarc; //ָһߵָ +}ArcNode; + +typedef struct VNode{ + VerTexType data; //Ϣ + ArcNode *firstarc; //ָһöıߵָ +}VNode, AdjList[MVNum]; //AdjListʾڽӱ + +typedef struct{ + AdjList vertices; //ڽӱ + int vexnum, arcnum; //ͼĵǰͱ +}ALGraph; + +bool visited[MVNum]; //ʱ־飬ֵΪ"false" + +int LocateVex(ALGraph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vertices[i].data == v) + return i; + return -1; +}//LocateVex + +void CreateUDG(ALGraph &G){ + //ڽӱʾͼG + int i , k; + + cout <<"ܱܶԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣa" << endl; + + for(i = 0; i < G.vexnum; ++i){ //㣬ͷ + cout << "" << (i+1) << ":"; + cin >> G.vertices[i].data; //붥ֵ + G.vertices[i].firstarc=NULL; //ʼͷָΪNULL + }//for + cout << endl; + + cout << "Ķ㣬a b" << endl; + + for(k = 0; k < G.arcnum;++k){ //ߣڽӱ + VerTexType v1 , v2; + int i , j; + cout << "" << (k + 1) << "Ķ:"; + cin >> v1 >> v2; //һ + i = LocateVex(G, v1); j = LocateVex(G, v2); + //ȷv1v2GλãG.verticesе + + ArcNode *p1=new ArcNode; //һµı߽*p1 + p1->adjvex=j; //ڽӵΪj + p1->nextarc= G.vertices[i].firstarc; G.vertices[i].firstarc=p1; + //½*p1붥viı߱ͷ + + ArcNode *p2=new ArcNode; //һԳƵµı߽*p2 + p2->adjvex=i; //ڽӵΪi + p2->nextarc= G.vertices[j].firstarc; G.vertices[j].firstarc=p2; + //½*p2붥vjı߱ͷ + }//for +}//CreateUDG + +void DFS(ALGraph G, int v){ //ͼGΪڽӱ + cout << G.vertices[v].data << " "; + visited[v] = true; //ʵv㣬÷ʱ־ӦֵΪtrue + ArcNode *p = G.vertices[v].firstarc; //pָvıĵһ߽ + while(p != NULL){ //߽ǿ + int w = p->adjvex; //ʾwvڽӵ + if(!visited[w]) DFS(G, w); //wδʣݹDFS + p = p->nextarc; //pָһ߽ + } +}//DFS + +int main(){ + cout << "************㷨6.6ڽӱʾͼ**************" << endl << endl; + ALGraph G; + CreateUDG(G); + cout << endl; + cout << "ͨͼGɣ" << endl << endl; + + cout << "ͨͼʼ㣺"; + VerTexType c; + cin >> c; + + int i; + for(i = 0 ; i < G.vexnum ; ++i){ + if(c == G.vertices[i].data) + break; + } + cout << endl; + while(i >= G.vexnum){ + cout << "õ㲻ڣ룡" << endl; + cout << "ͨͼʼ㣺"; + cin >> c; + for(i = 0 ; i < G.vexnum ; ++i){ + if(c == G.vertices[i].data) + break; + } + } + + cout << "ͼ" << endl; + DFS(G , i); + + cout < +using namespace std; + +#define MVNum 100 //󶥵 +#define MAXQSIZE 100 //г + +typedef char VerTexType; //趥Ϊַ +typedef int ArcType; //ߵȨֵΪ +bool visited[MVNum]; //ʱ־飬ֵΪ"false" + +//-----ͼڽӾ洢ʾ----- +typedef struct{ + VerTexType vexs[MVNum]; // + ArcType arcs[MVNum][MVNum]; //ڽӾ + int vexnum,arcnum; //ͼĵǰͱ +}Graph; + +//----еĶ弰-------- +typedef struct{ + ArcType *base; //ʼĶ̬洢ռ + int front; //ͷָ룬вգָͷԪ + int rear; //βָ룬вգָβԪصһλ +}sqQueue; + +void InitQueue(sqQueue &Q){ + //һնQ + Q.base = new ArcType[MAXQSIZE]; + if(!Q.base) exit(1); //洢ʧ + Q.front = Q.rear = 0; +}//InitQueue + +void EnQueue(sqQueue &Q, ArcType e){ + //ԪeΪQµĶβԪ + if((Q.rear + 1) % MAXQSIZE == Q.front) + return; + Q.base[Q.rear] = e; + Q.rear = (Q.rear + 1) % MAXQSIZE; +}//EnQueue + +bool QueueEmpty(sqQueue Q){ + //жǷΪն + if(Q.rear == Q.front) + return true; + return false; +}//QueueEmpty + +void DeQueue(sqQueue &Q, ArcType &u){ + //ͷԪسӲΪu + u = Q.base[Q.front]; + Q.front = (Q.front + 1) % MAXQSIZE; +}//DeQueue +//-------------------------------------------------- + +int LocateVex(Graph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vexs[i] == v) + return i; + return -1; +}//LocateVex + +void CreateUDN(Graph &G){ + //ڽӾʾG + int i , j , k; + cout <<"ܱܶԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + cout << "ƣa" << endl; + for(i = 0; i < G.vexnum; ++i){ + cout << "" << (i+1) << ":"; + cin >> G.vexs[i]; //Ϣ + } + cout << endl; + for(i = 0; i < G.vexnum; ++i) //ʼڽӾ󣬱ߵȨֵΪֵMaxInt + for(j = 0; j < G.vexnum; ++j) + G.arcs[i][j] = 0; + cout << "Ķ㣬a b" << endl; + for(k = 0; k < G.arcnum;++k){ //ڽӾ + VerTexType v1 , v2; + cout << "" << (k + 1) << "Ķ:"; + cin >> v1 >> v2; //һĶ + i = LocateVex(G, v1); j = LocateVex(G, v2); //ȷv1v2Gеλã± + G.arcs[i][j] = 1; //ȨֵΪw + G.arcs[j][i] = G.arcs[i][j]; //ĶԳƱȨֵΪw + }//for +}//CreateUDN + +int FirstAdjVex(Graph G , int v){ + //vĵһڽӵ + int i; + for(i = 0 ; i < G.vexnum ; ++i){ + if(G.arcs[v][i] == 1 && visited[i] == false) + return i; + } + return -1; +}//FirstAdjVex + +int NextAdjVex(Graph G , int u , int w){ + //vwһڽӵ + int i; + for(i = w ; i < G.vexnum ; ++i){ + if(G.arcs[u][i] == 1 && visited[i] == false) + return i; + } + return -1; +}//NextAdjVex + +void BFS (Graph G, int v){ + //ȷǵݹͨͼG + sqQueue Q; + ArcType u; + ArcType w; + + cout << G.vexs[v] << " "; visited[v] = true; //ʵv㣬÷ʱ־ӦֵΪtrue + InitQueue(Q); //Qʼÿ + EnQueue(Q, v); //v + while(!QueueEmpty(Q)){ //зǿ + DeQueue(Q, u); //ͷԪسӲΪu + for(w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G, u, w)){ + //μuڽӵw FirstAdjVex(G, u)ʾuĵһڽӵ + //NextAdjVex(G, u, w)ʾuwһڽӵ㣬w0ʾڽӵ + if(!visited[w]){ //wΪuδʵڽӶ + cout << G.vexs[w] << " "; visited[w] = true; //w÷ʱ־ӦֵΪtrue + EnQueue(Q, w); //w + }//if + }//for + }//while +}//BFS + +int main(){ + cout << "************㷨6.7ͨͼ**************" << endl << endl; + Graph G; + CreateUDN(G); + cout << endl; + cout << "ͨͼGɣ" << endl << endl; + + cout << "ͨͼʼ㣺"; + VerTexType c; + cin >> c; + + int i; + for(i = 0 ; i < G.vexnum ; ++i){ + if(c == G.vexs[i]) + break; + } + cout << endl; + while(i >= G.vexnum){ + cout << "õ㲻ڣ룡" << endl; + cout << "ͨͼʼ㣺"; + cin >> c; + for(i = 0 ; i < G.vexnum ; ++i){ + if(c == G.vexs[i]) + break; + } + } + cout << "ͨͼ" << endl; + BFS(G , i); + + cout < +using namespace std; + +typedef char VerTexType; +typedef int ArcType; +#define MVNum 100 +#define MaxInt 32767 //ʾֵ + +//Ķ壬¼Ӷ㼯UV-UȨֵСı +struct{ + VerTexType adjvex; //СUеǸ + ArcType lowcost; //СϵȨֵ +}closedge[MVNum]; + +//- - - - -ͼڽӱ洢ʾ- - - - - +typedef char VerTexType; //趥Ϊַ +typedef int ArcType; //ߵȨֵΪ +typedef struct{ + VerTexType vexs[MVNum]; // + ArcType arcs[MVNum][MVNum]; //ڽӾ + int vexnum,arcnum; //ͼĵǰͱ +}AMGraph; + +int LocateVex(AMGraph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vexs[i] == v) + return i; + return -1; +}//LocateVex + +void CreateUDN(AMGraph &G){ + //ڽӾʾG + int i , j , k; + cout <<"ܱܶԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣa" << endl; + + for(i = 0; i < G.vexnum; ++i){ + cout << "" << (i+1) << ":"; + cin >> G.vexs[i]; //Ϣ + } + cout << endl; + for(i = 0; i < G.vexnum; ++i) //ʼڽӾ󣬱ߵȨֵΪֵMaxInt + for(j = 0; j < G.vexnum; ++j) + G.arcs[i][j] = MaxInt; + cout << "Ķ㼰Ȩֵa b 5" << endl; + for(k = 0; k < G.arcnum;++k){ //ڽӾ + VerTexType v1 , v2; + ArcType w; + cout << "" << (k + 1) << "Ķ㼰Ȩֵ:"; + cin >> v1 >> v2 >> w; //һĶ㼰Ȩֵ + i = LocateVex(G, v1); j = LocateVex(G, v2); //ȷv1v2Gеλã± + G.arcs[i][j] = w; //ȨֵΪw + G.arcs[j][i] = G.arcs[i][j]; //ĶԳƱȨֵΪw + }//for +}//CreateUDN + +int Min(AMGraph G){ + //ȨֵСĵ + int i; + int index = -1; + int min = MaxInt; + for(i = 0 ; i < G.vexnum ; ++i){ + if(min > closedge[i].lowcost && closedge[i].lowcost != 0){ + min = closedge[i].lowcost; + index = i; + } + }//for + return index; +}//Min + +void MiniSpanTree_Prim(AMGraph G, VerTexType u){ + //GڽӾʽ洢ӶuGСTTĸ + int k , j , i; + VerTexType u0 , v0; + k =LocateVex(G, u); //kΪu± + for(j = 0; j < G.vexnum; ++j){ //V-Uÿһviʼclosedge[i] + if(j != k){ + closedge[j].adjvex = u; + closedge[j].lowcost = G.arcs[k][j]; //{adjvex, lowcost} + }//if + }//for + closedge[k].lowcost = 0; //ʼU = {u} + for(i = 1; i < G.vexnum; ++i){ //ѡn-1㣬n-1(n= G.vexnum) + k = Min(G); + //Tһ㣺k㣬closedge[k]деǰС + u0 = closedge[k].adjvex; //u0ΪСߵһ㣬u0U + v0 = G.vexs[k]; //v0ΪСߵһ㣬v0V-U + cout << " " <" << v0 << endl; //ǰС(u0, v0) + closedge[k].lowcost = 0; //k㲢U + for(j = 0; j < G.vexnum; ++j) + if(G.arcs[k][j] < closedge[j].lowcost){ //¶㲢UѡС + closedge[j].adjvex = G.vexs[k]; + closedge[j].lowcost = G.arcs[k][j]; + }//if + }//for +}//MiniSpanTree_Prim + +int main(){ + cout << "************㷨6.8ķ㷨**************" << endl << endl; + AMGraph G; + CreateUDN(G); + cout << endl; + cout << "ͼGɣ" << endl; + cout < +using namespace std; + +typedef char VerTexType; //趥Ϊַ +typedef int ArcType; +#define MVNum 100 //󶥵 +#define MaxInt 32767 //ʾֵ + +//----------------ͼڽӾ--------------------- +typedef struct{ + VerTexType vexs[MVNum]; // + ArcType arcs[MVNum][MVNum]; //ڽӾ + int vexnum,arcnum; //ͼĵǰͱ +}AMGraph; + +//EdgesĶ +struct{ + VerTexType Head; //ߵʼ + VerTexType Tail; //ߵյ + ArcType lowcost; //ϵȨֵ +}Edge[(MVNum * (MVNum - 1)) / 2]; + +int Vexset[MVNum]; //VexsetĶ + +int LocateVex(AMGraph G , VerTexType v){ + //ȷvGеλ + for(int i = 0; i < G.vexnum; ++i) + if(G.vexs[i] == v) + return i; + return -1; +}//LocateVex + +void CreateUDN(AMGraph &G){ + //ڽӾʾG + int i , j , k; + cout <<"ܱܶԿո:"; + cin >> G.vexnum >> G.arcnum; //ܱܶ + cout << endl; + + cout << "ƣa" << endl; + + for(i = 0; i < G.vexnum; ++i){ + cout << "" << (i+1) << ":"; + cin >> G.vexs[i]; //Ϣ + } + cout << endl; + for(i = 0; i < G.vexnum; ++i) //ʼڽӾ󣬱ߵȨֵΪֵMaxInt + for(j = 0; j < G.vexnum; ++j) + G.arcs[i][j] = MaxInt; + cout << "Ķ㼰Ȩֵa b 6" << endl; + for(k = 0; k < G.arcnum;++k){ //ڽӾ + VerTexType v1 , v2; + ArcType w; + cout << "" << (k + 1) << "Ķ㼰Ȩֵ:"; + cin >> v1 >> v2 >> w; //һĶ㼰Ȩֵ + i = LocateVex(G, v1); j = LocateVex(G, v2); //ȷv1v2Gеλã± + G.arcs[i][j] = w; //ȨֵΪw + G.arcs[j][i] = G.arcs[i][j]; //ĶԳƱȨֵΪw + Edge[k].lowcost = w; + Edge[k].Head = v1; + Edge[k].Tail = v2; + }//for +}//CreateUDN + +//----------ð------------------- +void Sort(AMGraph G){ + int m = G.arcnum - 2; + int flag = 1; + while((m > 0) && flag == 1){ + flag = 0; + for(int j = 0 ; j <= m ; j++){ + if(Edge[j].lowcost > Edge[j+ 1].lowcost){ + flag = 1; + + VerTexType temp_Head = Edge[j].Head; + Edge[j].Head = Edge[j+ 1].Head; + Edge[j + 1].Head = temp_Head; + + + VerTexType temp_Tail = Edge[j].Tail; + Edge[j].Tail = Edge[j+ 1].Tail; + Edge[j + 1].Tail = temp_Tail; + + ArcType temp_lowcost = Edge[j].lowcost; + Edge[j].lowcost = Edge[j+ 1].lowcost; + Edge[j + 1].lowcost = temp_lowcost; + }//if + }//for + --m; + }//while +}//Sort + +void MiniSpanTree_Kruskal(AMGraph G){ + //GڽӾʽ洢GСTTĸ + int i , j , v1 , v2 , vs1 , vs2; + Sort(G); //EdgeеԪذȨֵС + for(i = 0; i < G.vexnum; ++i) //飬ʾԳһͨ + Vexset[i] = i; + for(i = 0; i < G.arcnum; ++i){ + //β鿴źEdgeеıǷͬһͨ + v1 =LocateVex(G, Edge[i].Head); //v1ΪߵʼHead± + v2 =LocateVex(G, Edge[i].Tail); //v2ΪߵյTail± + vs1 = Vexset[v1]; //ȡEdge[i]ʼڵͨvs1 + vs2 = Vexset[v2]; //ȡEdge[i]յڵͨvs2 + if(vs1 != vs2){ //ߵͬͨ + cout << Edge[i].Head << "-->" << Edge[i].Tail << endl; //˱ + for(j = 0; j < G.vexnum; ++j) //ϲvs1vs2ͳһ + if(Vexset[j] == vs2) Vexset[j] = vs1; //ϱΪvs2ĶΪvs1 + }//if + }//for +}//MiniSpanTree_Kruskal + +void main(){ + cout << "************㷨6.9³˹㷨**************" << endl << endl; + AMGraph G; + CreateUDN(G); + + cout < +using namespace std; +#define MAXSIZE 100 +#define OK 1; + +typedef struct{ + int key;//ؼ +}ElemType; + +typedef struct{ + ElemType *R; + int length; +}SSTable; + +int InitList_SSTable(SSTable &L) +{ + L.R=new ElemType[MAXSIZE]; + if (!L.R) + { + cout<<"ʼ"; + return 0; + } + L.length=0; + return OK; +} + +int Insert_SSTable(SSTable &L) +{ + int j=0; + for(int i=0;i=1; --i) + if (ST.R[i].key==key) return i; //Ӻǰ + return 0; + }// Search_Seq + +void Show_End(int result,int testkey) +{ + if(result==0) + cout<<"δҵ"< +using namespace std; + +//㷨7.10ϣIJ +//- - - - -ŵַϣĴ洢ʾ- - - - - +#define m 16 //ϣı +#define NULLKEY 0 //ԪΪյı + +struct HashTable{ + int key; //ؼ +// InfoType otherinfo; // +}; + +// 㷨7.10Ϊϣҵ㷨̽ⷨͻ +// 㷨ʵ֡ + +int H(int key) +{ + int result; + result=key%13; + return result; +} + +int SearchHash(HashTable HT[],int key){ + //ڹϣHTвҹؼΪkeyԪأҳɹعϣĵԪţ򷵻-1 + int H0=H(key); //ݹϣHkeyϣַ + int Hi; + if (HT[H0].key==NULLKEY) return -1; //ԪH0ΪգԪز + else if (HT[H0].key==key) return H0; //ԪH0ԪصĹؼΪkeyҳɹ + else{ + for(int i=1;i +using namespace std; +#define MAXSIZE 100 +#define OK 1; + +typedef struct{ + int key;//ؼ +}ElemType; + +typedef struct{ + ElemType *R; + int length; +}SSTable; + +int InitList_SSTable(SSTable &L) +{ + L.R=new ElemType[MAXSIZE]; + if (!L.R) + { + cout<<"ʼ"; + return 0; + } + L.length=0; + return OK; +} + +int Insert_SSTable(SSTable &L) +{ + int j=1;//ճST.R[0]λ + for(int i=1;i +using namespace std; +#define MAXSIZE 100 +#define OK 1; + +typedef struct{ + int key;//ؼ +}ElemType; + +typedef struct{ + ElemType *R; + int length; +}SSTable; + +int InitList_SSTable(SSTable &L) +{ + L.R=new ElemType[MAXSIZE]; + if (!L.R) + { + cout<<"ʼ"; + return 0; + } + L.length=0; + return OK; +} + +int Insert_SSTable(SSTable &L) +{ + int j=1; + for(int i=1;i +using namespace std; +#define ENDFLAG '#' +//char a[10]={'5','6','7','2','1','9','8','10','3','4','#'};//ȫֱ +typedef struct ElemType{ + char key; +}ElemType; + +typedef struct BSTNode{ + ElemType data; // + BSTNode *lchild,*rchild; //Һָ +}BSTNode,*BSTree; + + +//㷨7.4ĵݹ +BSTree SearchBST(BSTree T,char key) { + //ڸָTָеݹزijؼֵkeyԪ + //ҳɹ򷵻ָԪؽָ룬򷵻ؿָ + if((!T)|| key==T->data.key) return T; //ҽ + else if (keydata.key) return SearchBST(T->lchild,key); //м + else return SearchBST(T->rchild,key); //м +} // SearchBST + + + +//㷨7.5IJ +void InsertBST(BSTree &T,ElemType e ) { + //Tвڹؼֵe.keyԪʱԪ + if(!T) { //ҵλãݹ + BSTree S = new BSTNode; //½*S + S->data = e; //½*SΪe + S->lchild = S->rchild = NULL; //½*SΪҶӽ + T =S; //½*SӵҵIJλ + } + else if (e.key< T->data.key) + InsertBST(T->lchild, e ); //*S + else if (e.key> T->data.key) + InsertBST(T->rchild, e); //*S +}// InsertBST + + + +//㷨7.6Ĵ +void CreateBST(BSTree &T ) { + //ζһؼΪkeyĽ㣬˽T + T=NULL; + ElemType e; + cin>>e.key; //??? + while(e.key!=ENDFLAG){ //ENDFLAGΪԶ峣Ϊ־ + InsertBST(T, e); //˽T + cin>>e.key; //??? + }//while +}//CreatBST + +void DeleteBST(BSTree &T,char key) { + //ӶTɾؼֵkeyĽ + BSTree p=T;BSTree f=NULL; //ʼ + BSTree q; + BSTree s; + /*------------whileѭӸʼҹؼֵkeyĽ*p-------------*/ + while(p){ + if (p->data.key == key) break; //ҵؼֵkeyĽ*pѭ + f=p; //*fΪ*p˫׽ + if (p->data.key> key) p=p->lchild; //*pм + else p=p->rchild; //*pм + }//while +if(!p) return; //Ҳɾ򷵻 +/*DʵpָڲĴ*pաD*/ +if ((p->lchild)&& (p->rchild)) { //ɾ*p + q = p; + s = p->lchild; + while (s->rchild) //*pмǰ㣬½ + {q = s; s = s->rchild;} //ҵͷ + p->data = s->data; //sָɾġǰ + if(q!=p){ + q->rchild = s->lchild; //ؽ*q + } + else q->lchild = s->lchild; //ؽ*q + delete s; + }//if +else{ + if(!p->rchild) { //ɾ*pֻؽ + q = p; p = p->lchild; + }//else if + else if(!p->lchild) { //ɾ*pֻؽ + q = p; p = p->rchild; + }//else if + /*DDDDDDDDDDpָҽӵ˫׽*fӦλèDDDDDDDD*/ + if(!f) T=p; //ɾΪ + else if (q==f->lchild) f->lchild = p; //ҽӵ*fλ + else f->rchild = p; //ҽӵ*fλ + delete q; + } +}//DeleteBST + +//㷨 7.7ɾ + +// +void InOrderTraverse(BSTree &T) +{ + if(T) + { + InOrderTraverse(T->lchild); + cout<data.key; + InOrderTraverse(T->rchild); + } +} + +void main() +{ + BSTree T; + cout<<"ַûس֣#"<>key; + BSTree result=SearchBST(T,key); + if(result) + {cout<<"ҵַ"<>key; + DeleteBST(T,key); + cout<<"ǰΪ"< +using namespace std; +#define FALSE 0 +#define TRUE 1 +#define OK 1 +#define m 3 //B-ĽףΪ3 +typedef struct BTNode{ + int keynum; //йؼֵĸĴС + BTNode *parent; //ָ˫׽ + int key[m+1]; //ؼʸ0ŵԪδ + BTNode *ptr[m+1]; //ָʸ +}BTNode,*BTree; + +//- - - - - B-IJҽͶ- - - - - +struct Result{ + BTNode *pt; //ָҵĽ + int i; //1..mڽеĹؼ + int tag; //1ҳɹ0ʧ +}; + + +int Search(BTree T,int key) +{ + BTree p=T; + int endnum; + if(p) //Ϊʱ + { + endnum=p->keynum; //׽ڵļ¼ + } + else + { + return 0; //ûҵ + } + int i=0; + if(endnum==0) + { + return i; //ڣһΪոڵ + } + else if(key>=p->key[endnum])//ڵ㲻Ϊգǰֵkey + { + i=endnum; + return i; + } + else if(key<=p->key[1]) //ڵ㲻ΪգǰֵСkeyС + { + return i;} + else + { + for(i=1;ikey[i]<=key && keykey[i+1]) + return i; + } + } +} + +void Insert(BTree &q,int i,int x,BTree &ap) +{//xqi+1λ + int j; + for(j=m-1;j>i;j--) + { + //λ֮keyȫһλ + q->key[j+1]=q->key[j]; + } + for(j=m;j>i;j--) + { + //ӦҲƶptrλ + q->ptr[j]=q->ptr[j-1]; + } + q->key[i+1]=x;//xλ + q->ptr[i+1]=ap; + q->keynum++; +} + +void split(BTree &q,int s,BTree &ap) +{ //q->key[s+1,..,m], q->ptr[s+1,..,m]½*apΪҽ + //ԭΪµ + //мֵap[0]->keyУȴҵתInsertBTreeѰҵʵIJλò + int i; + ap=new BTNode; + for(i=s+1;i<=m;i++) + { //q->key[s+1,..,m]浽ap->key[0,..,m-s+1] + //q->ptr[s+1,..,m]浽ap->ptr[0,..,m-s+1] + ap->key[i-s-1]=q->key[i]; + ap->ptr[i-s-1]=q->ptr[i]; + } + if(ap->ptr[0]) + { + //apʱ + for(i=0;i<=1;i++) + { + //apĸ׸ΪapԼ + ap->ptr[i]->parent=ap; + } + } + ap->keynum=(m-s)-1; + ap->parent=q->parent;//apĸ׸Ϊqĸ + + q->keynum=q->keynum-(m-s);//޸qļ¼ +} + +void NewRoot(BTree &T,BTree q,int x,BTree &ap)//ɺϢT, x, apµĸ*TԭTapΪָ +{ + BTree newT=new BTNode;//½һΪµĸ + + newT->key[1]=x;//д¸key[1] + newT->ptr[0]=T;//ԭΪ¸ + newT->ptr[1]=ap;//apΪ¸ + newT->keynum=1; + newT->parent=NULL;//¸ĸΪ + + ap->parent=newT;//apĸΪ¸ + T->parent=newT;//TĸΪ¸ + + T=newT;//ij¸ +} + +//㷨7.9B-IJ +int InsertBTree(BTree &T,int K,BTree q,int i){ + int x=K; + BTree ap=NULL; + int finished=FALSE;//xʾ²Ĺؼ֣apΪһָ + while(q&&!finished){ + Insert(q,i,x,ap); //xapֱ뵽q->key[i+1]q->ptr[i+1] + if (q->keynumkey[0];// x=q->key[s]; + //q->key[s+1..m], q->ptr[s..m]q->recptr[s+1..m] ½*ap + q=q->parent; + if(q) + { + i=Search(q,x); + } //˫׽*qвxIJλ + } //else + } //while + if(!finished) //TǿqֵΪNULL߸ѷΪ*q*ap + NewRoot(T,q,x,ap); //ɺϢT, x, apµĸ*TԭTapΪָ + return OK; +} //InsertBTree //InsertBTree + +//㷨7.8B-IJ +Result SearchBTree(BTree &T, int key){ + /*mB-Tϲҹؼkeyؽ(pt,i,tag)ҳɹֵtag=1ָptָеiؼֵkeyֵtag=0keyĹؼӦָptָеi͵i+1ؼ֮*/ + BTree p=T; + BTree q=NULL; + int found=FALSE; + int i=0; //ʼpָ㣬qָp˫ +while(p&&!found){ + i=Search(p,key); + //p-key[1..keynum]вiʹãp-key[i]=keyp-key[i+1] + if(i>0&&p->key[i]==key) + found=TRUE; //ҵؼ + else + { + q=p; + p=p->ptr[i]; + } + } + Result result; +if(found) +{ + result.pt=p; + result.i=i; + result.tag=1; + return result; +} //ҳɹ +else +{ + result.pt=q; + result.i=i; + result.tag=0; + return result; +} //ҲɹKIJλϢ +}//SearchBTree + +void InitialBTree(BTree &T) +{ + //ʼһյĸ + T->keynum=0; + T->parent=NULL; + for(int i=0;iptr[i]=NULL; + } +} + + + +void main() +{ + BTree T=new BTNode; + InitialBTree(T); + //SearchBTree()ҵҪλãõһResultṹ + //InsertBTree() + Result result; + int a[11]={45,24,53,90,3,12,50,61,70,100}; + for(int i=0;i<10;i++) + { + result=SearchBTree(T,a[i]); + if(result.tag==0) + { + InsertBTree(T,a[i],result.pt,result.i); + } + } + cout<<"OK"; +} + diff --git a/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第8章/8.1.cpp b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第8章/8.1.cpp new file mode 100644 index 0000000..e344e5f --- /dev/null +++ b/数据结构/严版教材/数据结构第2版-书中算法（C语言版）/第8章/8.1.cpp @@ -0,0 +1,65 @@ +//㷨8.1 ֱӲ +#include +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}ElemType; +//˳Ĵ洢ṹ +typedef struct +{ + ElemType *r; //洢ռĻַ + int length; //˳ +}SqList; //˳ + +void InsertSort(SqList &L) +{ + //˳LֱӲ + int i,j; + for(i=2;i<=L.length;++i) + if(L.r[i].key>n; // + cout<<":\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=1;i<=n;i++) + { + cin>>L.r[i].key; + L.length++; + } +} +void show(SqList L) +{ + int i; + for(i=1;i<=L.length;i++) + cout< +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}RedType; + +void Create_Sq(RedType *R) +{ + int i,n; + cout<<"ݸ"<>n; // + cout<<"ϲ:\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=0;i>R[i].key; +} + +void Merge(RedType R[],RedType T[],int low,int mid,int high) +{ + //R[low..mid]R[mid+1..high]鲢ΪT[low..high] + int i,j,k; + i=low; j=mid+1;k=low; + while(i<=mid&&j<=high) + { + //Rм¼СزT + if(R[i].key<=R[j].key) T[k++]=R[i++]; + else T[k++]=R[j++]; + } + while(i<=mid) //ʣR[low..mid]ƵT + T[k++]=R[i++]; + while(j<=high) //ʣR[j.high]ƵT + T[k++]=R[j++]; +}//Merge +void show(RedType *T,int low,int high) +{ + int i; + for(i=low;i<=high;i++) + cout<>low>>mid>>high; + Merge(R,T,low,mid,high); + cout<<"ϲĽΪ"< +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}RedType; + +typedef struct +{ + RedType *r; + int length; +}SqList; + +void Create_Sq(SqList &L) +{ + int i,n; + cout<<"ݸ"<>n; // + cout<<":\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=1;i<=n;i++) + { + cin>>L.r[i].key; + L.length++; + } +} + +//㷨8.10 еĹ鲢 +void Merge(RedType R[],RedType T[],int low,int mid,int high) +{ + //R[low..mid]R[mid+1..high]鲢ΪT[low..high] + int i,j,k; + i=low; j=mid+1;k=low; + while(i<=mid&&j<=high) + { + //Rм¼СزT + if(R[i].key<=R[j].key) T[k++]=R[i++]; + else T[k++]=R[j++]; + } + while(i<=mid) //ʣR[low..mid]ƵT + T[k++]=R[i++]; + while(j<=high) //ʣR[j.high]ƵT + T[k++]=R[j++]; +}//Merge + +void MSort(RedType R[],RedType T[],int low,int high) +{ + //R[low..high]鲢T[low..high] + int mid; + RedType *S=new RedType[MAXSIZE]; + if(low==high) T[low]=R[low]; + else + { + mid=(low+high)/2; //ǰһΪѵmid + MSort(R,S,low,mid); //R[low..mid] ݹ鲢򣬽S[low..mid] + MSort(R,S,mid+1,high); //R[mid+1..high] ݹ鲢򣬽S[mid+1..high] + Merge(S,T,low,mid,high); //S[low..mid]S [mid+1..high]鲢T[low..high] + }//else +}// MSort + +void MergeSort(SqList &L) +{ + //˳L鲢 + MSort(L.r,L.r,1,L.length); +}//MergeSort +void show(SqList L) +{ + int i; + for(i=1;i<=L.length;i++) + cout< +#include +#include +#include +#define MAXNUM_KEY 8 //ؼֵ +#define RADIX 10 //ؼֻʱʮĻ +#define MAX_SPACE 10000 +typedef char KeysType; //ؼΪַ +typedef int InfoType; // +typedef struct +{ + KeysType keys[MAXNUM_KEY]; //ؼ + InfoType otheritems; // + int next; +}SLCell; //̬Ľ +typedef struct +{ + SLCell r[MAX_SPACE]; //̬Ŀÿռ䣬r[0]Ϊͷ + int keynum; //¼ĵǰؼָ + int recnum; //̬ĵǰ +}SLList; //̬ +typedef int ArrType[RADIX]; //ָ + +void InitList(SLList *L) +{ + //ʼ̬LDеݴLУ + char c[MAXNUM_KEY],c1[MAXNUM_KEY]; + int i,j,n,max; //maxΪؼֵֵ + max=-10000; + cout<<"ݸ"<>n; + while(n>MAX_SPACE) + { + cout<<"ĸޣ룬"<>n; + } + int *D=new int[n]; + cout<<""<>D[i]; + if(max=0;j--) + cout< +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}ElemType; +//˳Ĵ洢ṹ +typedef struct +{ + ElemType *r; //洢ռĻַ + int length; //˳ +}SqList; //˳ + +void BInsertSort(SqList &L){ + //˳L۰ + int i,j,low,high,m; + for(i=2;i<=L.length;++i) + { + L.r[0]=L.r[i]; //ļ¼ݴ浽 + low=1; high=i-1; //òֵ + while(low<=high) + { //r[low..high]۰Ҳλ + m=(low+high)/2; //۰ + if(L.r[0].key=high+1;--j) L.r[j+1]=L.r[j]; //¼ + L.r[high+1]=L.r[0]; //r[0]ԭr[i]뵽ȷλ + } //for +} //BInsertSort + +void Create_Sq(SqList &L) +{ + int i,n; + cout<<"ݸ"<>n; // + cout<<"ݣ\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=1;i<=n;i++) + { + cin>>L.r[i].key; + L.length++; + } +} + +void show(SqList L) +{ + int i; + for(i=1;i<=L.length;i++) + cout< +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}ElemType; +//˳Ĵ洢ṹ +typedef struct +{ + ElemType *r; //洢ռĻַ + int length; //˳ +}SqList; //˳ + +void ShellInsert(SqList &L,int dk) +{ + //˳Lһdkϣ + int i,j; + for(i=dk+1;i<=L.length;++i) + if(L.r[i].key0&& L.r[0].key>n; // + cout<<"ݣ\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=1;i<=n;i++) + { + cin>>L.r[i].key; + L.length++; + } +} + +void show(SqList L) +{ + int i; + for(i=1;i<=L.length;i++) + cout<>t; + for(i=0;i>dt[i]; + } + ShellSort(L,dt,t); + cout<<"ĽΪ"< +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}ElemType; +//˳Ĵ洢ṹ +typedef struct +{ + ElemType *r; //洢ռĻַ + int length; //˳ +}SqList; //˳ + +void BubbleSort(SqList &L) +{ + //˳Lð + int m,j,flag; + ElemType t; + m=L.length-1; flag=1; //flagijһǷ + while((m>0)&&(flag==1)) + { + flag=0; //flagΪ0ûз򲻻ִһ + for(j=1;j<=m;j++) + if(L.r[j].key>L.r[j+1].key) + { + flag=1; //flagΪ1ʾ˽ + t=L.r[j];L.r[j]=L.r[j+1];L.r[j+1]=t; //ǰ¼ + } //if + --m; + } //while +} //BubbleSort + +void Create_Sq(SqList &L) +{ + int i,n; + cout<<"ݸ"<>n; // + cout<<":\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=1;i<=n;i++) + { + cin>>L.r[i].key; + L.length++; + } +} + +void show(SqList L) +{ + int i; + for(i=1;i<=L.length;i++) + cout< +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}ElemType; +//˳Ĵ洢ṹ +typedef struct +{ + ElemType *r; //洢ռĻַ + int length; //˳ +}SqList; //˳ + + +int Partition(SqList &L,int low,int high) +{ + //˳Lеӱr[low..high]һ򣬷λ + int pivotkey; + L.r[0]=L.r[low]; //ӱĵһ¼¼ + pivotkey=L.r[low].key; //¼ؼֱpivotkey + while(low=pivotkey) --high; + L.r[low]=L.r[high]; //¼Сļ¼ƵͶ + while(low>n; // + cout<<":\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=1;i<=n;i++) + { + cin>>L.r[i].key; + L.length++; + } +} + + +void show(SqList L) +{ + int i; + for(i=1;i<=L.length;i++) + cout< +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}ElemType; +//˳Ĵ洢ṹ +typedef struct +{ + ElemType *r; //洢ռĻַ + int length; //˳ +}SqList; //˳ + +void SelectSort(SqList &L) +{ + //˳Lѡ + int i,j,k; + ElemType t; + for(i=1;i>n; // + cout<<":\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=1;i<=n;i++) + { + cin>>L.r[i].key; + L.length++; + } +} + +void show(SqList L) +{ + int i; + for(i=1;i<=L.length;i++) + cout< +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}ElemType; +//˳Ĵ洢ṹ +typedef struct +{ + ElemType *r; //洢ռĻַ + int length; //˳ +}SqList; //˳ + +void HeapAdjust(SqList &L,int s,int m) +{ + //r[s+1..m]ѾǶѣr[s..m]Ϊr[s]ΪĴ + ElemType rc; + int j; + rc=L.r[s]; + for(j=2*s;j<=m;j*=2) + { //keyϴĺӽɸѡ + if(j=L.r[j].key) break; //rcӦλs + L.r[s]=L.r[j]; s=j; + } + L.r[s]=rc; // +} //HeapAdjust + +void Create_Sq(SqList &L) +{ + int i,n; + cout<<"ݸ"<>n; // + cout<<":\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=1;i<=n;i++) + { + cin>>L.r[i].key; + L.length++; + } +} +void show(SqList L) +{ + int i; + for(i=1;i<=L.length;i++) + cout< +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}ElemType; +//˳Ĵ洢ṹ +typedef struct +{ + ElemType *r; //洢ռĻַ + int length; //˳ +}SqList; //˳ + +//㷨8.7 ɸѡ +void HeapAdjust(SqList &L,int s,int m) +{ + //r[s+1..m]ѾǶѣr[s..m]Ϊr[s]ΪĴ + ElemType rc; + int j; + rc=L.r[s]; + for(j=2*s;j<=m;j*=2) + { //keyϴĺӽɸѡ + if(j=L.r[j].key) break; //rcӦλs + L.r[s]=L.r[j]; s=j; + } + L.r[s]=rc; // +} //HeapAdjust + +void Create_Sq(SqList &L) +{ + int i,n; + cout<<"ݸ"<>n; // + cout<<":\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=1;i<=n;i++) + { + cin>>L.r[i].key; + L.length++; + } +} + +void CreatHeap(SqList &L) +{ + //L.r[1..n]ɴ + int i,n; + n=L.length; + for(i=n/2;i>0;--i) //HeapAdjust + HeapAdjust(L,i,n); +} //CreatHeap +void show(SqList L) +{ + int i; + for(i=1;i<=L.length;i++) + cout< +using namespace std; +#define MAXSIZE 20 //˳󳤶 +typedef struct +{ + int key; + char *otherinfo; +}ElemType; +//˳Ĵ洢ṹ +typedef struct +{ + ElemType *r; //洢ռĻַ + int length; //˳ +}SqList; //˳ + +//㷨8.7 ɸѡ +void HeapAdjust(SqList &L,int s,int m) +{ + //r[s+1..m]ѾǶѣr[s..m]Ϊr[s]ΪĴ + ElemType rc; + int j; + rc=L.r[s]; + for(j=2*s;j<=m;j*=2) + { //keyϴĺӽɸѡ + if(j=L.r[j].key) break; //rcӦλs + L.r[s]=L.r[j]; s=j; + } + L.r[s]=rc; // +} + //HeapAdjust +void Create_Sq(SqList &L) +{ + int i,n; + cout<<"ݸ"<>n; // + cout<<":\n"; + while(n>MAXSIZE) + { + cout<<"ޣܳ"<>n; + } + for(i=1;i<=n;i++) + { + cin>>L.r[i].key; + L.length++; + } +} + +//㷨8.8 +void CreatHeap(SqList &L) +{ + //L.r[1..n]ɴ + int i,n; + n=L.length; + for(i=n/2;i>0;--i) //HeapAdjust + HeapAdjust(L,i,n); +} //CreatHeap + +void HeapSort(SqList &L) +{ + //˳Lж + int i; + ElemType x; + CreatHeap(L); //L.r[1..L.length]ɴ + for(i=L.length;i>1;--i) + { + x=L.r[1]; //Ѷ¼͵ǰδL.r[1..i]һ¼ + L.r[1]=L.r[i]; + L.r[i]=x; + HeapAdjust(L,1,i-1); //L.r[1..i-1]µΪ + }//for +}//HeapSort +void show(SqList L) +{ + int i; + for(i=1;i<=L.length;i++) + cout<