数据结构与算法分析--代码
参考书籍：[1]Clifford A.Shaffer.数据结构与算法分析[M].北京：电子工业出版社，2020.
Chapter 4 Lists, Stacks and Queues
4.1 Lists 线性表
4.1.1 Array-based Lists 顺序表
arraylist.h
#pragma once
#include<iostream>
using namespace std;
template <typename E>
class List //arraylist
{
private:
int maxSize;
int listSize;
int curr;
E* listArray;
public:
List(int size)
{
maxSize = size;
listSize = curr = 0;
listArray = new E[maxSize];
}
~List()
{
delete[] listArray;
}
void clear()
{
delete[] listArray;
listSize = curr = 0;
listArray = new E[maxSize];
}
void insert(const E& item)//在curr处加一个元素并把其它元素后移
{
if (listSize >= maxSize)
{
cout << "List capacity exceeded" << endl;
return;
}
for (int i = listSize; i > curr; i--)
{
listArray[i] = listArray[i - 1];
}
listArray[curr] = item;
listSize++;
}
void append(const E& item)//在元素最后加一个元素，不超过列表总长
{
if (listSize >= maxSize)
{
cout << "List capacity exceeded" << endl;
return;
}
listArray[listSize++] = item;
}
void remove()//除去curr处的元素并把其它元素前移
{
if (curr < 0 || curr >= listSize)
{
cout << "No element" << endl;
return;
}
//E it = listArray[curr];可以返回删除的值
for (int i = curr; i < listSize - 1; i++)
listArray[i] = listArray[i + 1];
listSize--;
return;
}
void printlist()//打印列表元素
{
int i = 0;
while (i != listSize)
{
cout << listArray[i] << ' ';
i++;
}
}
void moveToStart()//curr移到头部
{
curr = 0;
}
void moveToEnd()//curr移到尾部
{
curr = listSize;
}
void prev()//curr前移
{
if (curr != 0) curr--;
}
void next()//curr后移
{
if (curr < listSize) curr++;
}
int length() const//返回列表长度
{
return listSize;
}
int currPos() const//返回curr位置
{
return curr;
}
void moveToPos(int pos)//curr移到pos位置
{
if (pos < 0 || pos >= listSize)
{
cout << "No current element" << endl;
return;
}
curr = pos;
}
const E& getValue() const//返回curr的值
{
if (curr < 0 || curr >= listSize)
{
cout << "No current element" << endl;
return 0;
}
return listArray[curr];
}
};
模板一般整个放到头文件中
模板会在被使用的时候实例化，在这之前并不会生成二进制的机器码，所以必须在用到的地方被引入，如果把实现放到cpp里的话，引用到这个模板的地方虽然包含了相应的头文件知道有符号（比如函数）的存在，却不知道这个符号到底要做什么（函数没有实现），就会出错。–引用老师的解释
arraylist.cpp
#include"list.h"
#include<iostream>
int main()
{
List<int> a(10);
a.append(1);
a.append(2);
a.append(3);
a.moveToPos(2);
a.insert(4);
a.moveToStart();
a.remove();
a.printlist();
return 0;//结果输出2 4 3
}
4.1.2 Singly Linked List 单链表
用单链表实现排序功能
#include<iostream>
using namespace std;
template<class T>
class node
{
public:
T data;
node* next;
node()
{
data = 0;
next = NULL;
}
node(T d, node* next = NULL)
{
data = d;
next = next;
}
};
template<class T>
class List:public node<T>
{
private:
node<T>* head;
node<T>* tail;
node<T>* curr;
int size;
public:
List(T a[],int size)
{
size = size;
curr = tail = head = new node<T>();
for (int i = 0; i < size; i++)
{
curr->next = new node<T>(a[i], NULL);
tail = curr->next;
curr = curr->next;
}
}
void Print(List list,int size)
{
curr = head;
for (int i = 0; i < size; i++)
{
cout << curr->next->data << " ";
curr = curr->next;
}
cout << endl;
}
bool Compare(T a, T b)
{
if (a < b)
return true;
return false;
}
void SelectSort(List list,int size)//From smallest to largest
{
node<T>* currTem;
T temp;
for (int i = 0; i < size-1; i++)
{
curr = head->next;
currTem = curr;
for (int j = 0; j < size-i-1; j++)
{
currTem = currTem->next;
if (Compare(curr->data, currTem->data))
{
curr = currTem;//curr save the largest place
}
}
temp = curr->data;
curr->data = currTem->data;
currTem->data = temp;
}
}
};
int main()
{
cout << "Example 1" << endl;
int a[5] = { 10,8,34,26,5 };
List<int> list1(a,5);
cout<<"The original order:"<<endl;
list1.Print(list1, 5);
list1.SelectSort(list1,5);
cout << "The sorted order:" << endl;
list1.Print(list1, 5);
cout << endl;
}
Chapter 5 Binary Tree
5.3 Binary Tree Node Implementations 二叉树实现
BinNode.h
template<typename E>
class BinNode
{
private:
E it;
BinNode* lc;
BinNode* rc;
public:
BinNode()
{
lc = rc = NULL;
}
BinNode(E e, BinNode* l, BinNode* r)
{
it = e;
lc = l;
rc = r;
}
E& element()
{
return it;
}
void setElement(const E& e)
{
it = e;
}
BinNode* left() const
{
return lc;
}
void setLeft(BinNode* b)
{
lc = b;
}
BinNode* right() const
{
return rc;
}
void setRight(BinNode* b)
{
rc = b;
}
bool isLeaf()
{
return (lc == NULL) && (rc == NULL);
}
};
BinTree.h
#include<queue>
#include"BinNode.h"
template<typename E>
class BinTree
{
private:
BinNode<E>* root;//根结点
public:
//构造函数
BinTree()
{
root = NULL;
}
//析构函数
~BinTree()
{
clear(root);
}
//前序遍历输入一棵二叉树
BinNode<E>* createBinTree()
{
E ele;
cin >> ele;
BinNode<E>* rt;
if (ele == '#') rt = NULL;
else
{
rt = new BinNode<E>;
rt->setElement(ele);
rt->setLeft(createBinTree());
rt->setRight(createBinTree());
}
return rt;//返回根结点
}
//销毁二叉树
void clear(BinNode<E>* r)
{
if (r == NULL) return;//空树，直接返回
//只有一个结点
if (r->left() == NULL && r->right() == NULL)
{
delete r;
r = NULL;
return;
}
//大于一个结点，递归销毁左子树与右子树
clear(r->left());
clear(r->right());
delete r;
r = NULL;
}
//返回根节点
BinNode<E>* Root()
{
return root;
}
//设置根节点
void setRoot(BinNode<E>* r)
{
root = r;
}
//判断二叉树是否为空
bool isEmpty(BinNode<E>* r)
{
return root == NULL;
}
//层次遍历
void levelorder(BinNode<E>* r)
{
queue<BinNode<E>*> q;
//将根结点入队
if (r) q.push(r);
BinNode<E>* temp;
while (!q.empty())
{
//temp赋为队首的根结点
temp = q.front();
//将队首的根结点出队
q.pop();
cout << temp->element() << ' ';
//如果该结点的左右结点存在，分别入队
if (temp->left()) q.push(temp->left());
if (temp->right()) q.push(temp->right());
}
}
//二叉树高度
int BinTreeHeight(BinNode<E>* r)
{
if (r == NULL) return 0;
else return max(BinTreeHeight(r->left()), BinTreeHeight(r->right())) + 1;
}
//二叉树结点数
int count(BinNode<E>* r)
{
if (r == NULL) return 0;
else return 1 + count(r->right()) + count(r->left());
}
};
BinTree.cpp
#include <iostream>
using namespace std;
#include"BinTree.h"
int main()
{
BinTree<char> tree;
BinNode<char>* rt;
cout << "请以前序遍历的顺序输入一棵树(结点元素类型为字符型)，空节点以#代替。" << endl;
cout << "例如：AB##C##（必须是满二叉树，且叶子都为#）" << endl;
rt = tree.createBinTree();
tree.setRoot(rt);
if (tree.isEmpty(rt)) cout << "这棵树是空树，结束操作\n";
else
{
cout << "这棵二叉树层次遍历的结果为：\n";
tree.levelorder(rt); cout << endl;
cout << "这棵二叉树的高度是：\n";
cout << tree.BinTreeHeight(rt) << endl;
//都把二叉树生成了也算一下结点数，用的是与算高度差不多的递归函数
cout << "这棵二叉树的结点个数是：\n";
cout << tree.count(rt) << endl;
}
return 0;
}
5.4 Binary Search Tree 二叉查找树(BST)
利用二叉查找树查找从小值到大值中间的数
BSTNode.h
#include<iostream>
using namespace std;
template<typename E>
class BSTNode
{
private:
E it;
BSTNode* lc;
BSTNode* rc;
public:
BSTNode()
{
lc = rc = NULL;
}
BSTNode(E e, BSTNode* l = NULL, BSTNode* r = NULL)
{
it = e; lc = l; rc = r;
}
//基础结点函数
E& element()
{
return it;
}
inline BSTNode* left() const
{
return lc;
}
void setLeft(BSTNode<E>* b)
{
lc = b;
}
inline BSTNode* right() const
{
return rc;
}
void setRight(BSTNode<E>* b)
{
rc = b;
}
};
BST.h
#include"BSTNode.h"
template<typename E>
class BST
{
private:
BSTNode<E>* root;//树根
int m = 0;//记录结点数
public:
//构造函数
BST()
{
root = NULL;
}
void setRoot(BSTNode<E>* b)
{
root = b;
}
BSTNode<E>* insert(BSTNode<E>* b, int val)
{
if (b == NULL)
{
BSTNode<E>* temp = new BSTNode<E>(val);
return temp;
}
else
{
if (val < b->element())
b->setLeft(insert(b->left(), val));//小于往左边插入元素
else b->setRight(insert(b->right(), val));//大于等于往右边插入元素
return b;
}
}
void printRange(BSTNode<E>* b, E low, E high)
{
if (b == NULL) return;
if (b->element() < low)//元素太小，向右查找
{
printRange(b->right(), low, high);
return;
}
if (b->element() > high)//元素太大，向左查找
{
printRange(b->left(), low, high);
return;
}
//元素适中，打印并向左右两边继续查找
printRange(b->left(), low, high);
cout << b->element() << ' ';
printRange(b->right(), low, high);
m++;
}
void getNode() {
cout << "\n经过" << m << "个结点" << endl;//检查经过结点数
}
};
BST.cpp
#include"BST.h"
int main()
{
BST<int> Tree;
BSTNode<int>* rt = NULL;
Tree.setRoot(rt);
cout << "请输入BST中的结点个数：\n";
int n, m;
cin >> n;
cout << "请依次输入" << n << "个结点的值(int)：\n";
for (int i = 1; i <= n; i++)
{
cin >> m;
if (i == 1) rt = Tree.insert(rt, m);
else Tree.insert(rt, m);
}
cout << "输入小值low value和大值high value" << endl;
int l, h;
cin >> l;
cin >> h;
Tree.printRange(rt, l, h); //在中序排序下进行修改
Tree.getNode();
return 0;
}
5.5 max-heap 大顶堆
Heap.h
#include<iostream>
using namespace std;
template<typename E>
class Comp
{
public:
//比较优先级
static bool prior(E a, E b)
{
return a >= b;
}
};
template<typename E, typename Comp>
class heap {
private:
E* Heap;
int maxsize;
int n;
//堆的下沉调整
void siftdown(int pos) {
while (!isLeaf(pos)) {
int lc = leftchild(pos);
int rc = rightchild(pos);
if ((rc < n) && Comp::prior(Heap[rc], Heap[lc]))
lc = rc;
if (Comp::prior(Heap[pos], Heap[lc]))
return;
swap(Heap[pos], Heap[lc]);
pos = lc;
}
}
public:
void buildHeap()
{
for (int i = n / 2; i >= 0; i--)
siftdown(i);
}
heap(E* h, int num, int max) //构造函数
{
Heap = h;
n = num;
maxsize = max;
buildHeap();
}
bool isLeaf(int pos) const
{
return (pos >= n / 2) && (pos < n);
}
bool isEmpty()
{
return n == 0;
}
int leftchild(int pos) const
{
return 2 * pos + 1;
}
int rightchild(int pos) const
{
return 2 * pos + 2;
}
//删除堆的根结点
E removefirst() {
if (n <= 0)
{
cout << "Heap is empty" << endl;
return NULL;
}
swap(Heap[0], Heap[--n]);
if (n != 0)
siftdown(0);
return Heap[n];
}
};
Heap.cpp
#include"Heap.h"
using namespace std;
int main()
{
int n = 10;
int a[100] = {10,5,12,3,2,1,8,7,9,4};
heap< int, Comp<int> > hp(a, n, 100);
while (!hp.isEmpty())
cout << hp.removefirst() << endl;
cout << endl;
}
5.6 Huffman Coding Trees 哈夫曼编码树
有参考csnd（ChanJose：C++哈夫曼编码）
HuffTree.h
#ifndef HuffTree_h
#define HuffTree_h
#include <iostream>
using namespace std;
struct HuffmanNode {
int weight; // 权重
char ch; // 存储符号
string code; // 存储该符号对应的编码
int leftChild, rightChild, parent; // 左、右孩子，父结点
};
class HuffmanCode {
public:
HuffmanCode(int* arr,char* letter,int leafSize); // 构造函数
~HuffmanCode(); // 析构函数
void getMin(int& first, int& second, int parent); // 选取两个较小的元素
void Merge(int first, int second, int parent); // 合并
void Encode(int count); // 编码:利用哈夫曼编码原理对数据进行加密
private:
HuffmanNode* HuffmanTree; // 数组
};
// 构造函数
HuffmanCode::HuffmanCode(int* arr,char* letter,int len) {
HuffmanTree = new HuffmanNode[100]; // 分配空间
// 1.初始化HuffmanTree数组
for (int i = 0; i < (2 * len - 1); i++) { // 叶子结点为len,则树最多有2*len-1个结点
HuffmanTree[i].leftChild = HuffmanTree[i].rightChild = HuffmanTree[i].parent = -1;
HuffmanTree[i].code = "";
}
// 2.将权重和字符存入HuffmanTree数组
for (int i = 0; i < len; i++) {
HuffmanTree[i].ch = letter[i]; // 将数字转成对应的字符
HuffmanTree[i].weight = arr[i]; // 权重
}
// 3.选取两个较小值合并
int first, second; // 两个较小的结点
for (int i = len; i < (2*len-1) ; i++) { // 做leafSize-1趟
getMin(first, second, i); // 选取两个较小的元素
Merge(first, second, i); // 合并
}
}
// 析构函数
HuffmanCode::~HuffmanCode() {
delete[]HuffmanTree;
}
// 选取权值两个较小的元素
void HuffmanCode::getMin(int& first, int& second, int parent) {
int weight = 0;
int i;
// 找权重最小元素
for (i = 0; i < parent; i++) {
if (HuffmanTree[i].parent != -1) // 已选过，直接跳过
continue;
if (weight == 0) { // 第一次找到没选过的结点
weight = HuffmanTree[i].weight;
first = i;
}
else if (HuffmanTree[i].weight < weight) { // 权值更小
weight = HuffmanTree[i].weight;
first = i;
}
}
// 找权重次小元素
weight = 0;
for (i = 0; i < parent; i++) {
if (HuffmanTree[i].parent != -1 || i == first) // 已选过，直接跳过
continue;
if (weight == 0) { // 第一次找到没选过的结点
weight = HuffmanTree[i].weight;
second = i;
}
else if (HuffmanTree[i].weight < weight) { // 权值更小
weight = HuffmanTree[i].weight;
second = i;
}
}
}
// 合并
void HuffmanCode::Merge(int first, int second, int parent) {
HuffmanTree[first].parent = HuffmanTree[second].parent = parent; // 父结点
HuffmanTree[parent].leftChild = first; // 左孩子
HuffmanTree[parent].rightChild = second; // 右孩子
HuffmanTree[parent].weight = HuffmanTree[first].weight + HuffmanTree[second].weight; // 权值
}
// 编码:利用哈夫曼编码原理对数据进行加密
void HuffmanCode::Encode(int count) {
string code; // 存储符号的不定长二进制编码
int i, j, k, parent;
for (i = 0; i < count; i++) { // 从叶子结点出发
j = i;
code = ""; // 初始化为空
while (HuffmanTree[j].parent != -1) { // 往上找到根结点
parent = HuffmanTree[j].parent; // 父结点
if (j == HuffmanTree[parent].leftChild) // 如果是左孩子，则记为0
code += "0";
else // 右孩子，记为1
code += "1";
j = parent; // 上移到父结点
}
// 编码要倒过来：因为是从叶子往上走到根，而编码是要从根走到叶子结点
for (k = (int)code.size() - 1; k >= 0; k--)
HuffmanTree[i].code += code[k]; // 保存编码
cout << HuffmanTree[i].ch << "的编码为：" << HuffmanTree[i].code << " "<<endl;
}
}
#endif
HuffTree.cpp
#include "HuffTree.h"
int main() {
int count = 12;//字符数
int a[12] = { 2,3,5,7,11,13,17,19,23,31,37,41 };
char c[12] = { 'A','B','C','D','E','F','G','H','I','J','K','L' };
HuffmanCode st(a,c,count); // 对象
cout << "对字符串编码情况如下：" << endl;
st.Encode(count); // 编码
cout << endl;
cout << "n个字符编码的期望长度为[log(n)]+1" << endl;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
