1、使用C++ 基于STL库进行箱排序
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
void BucketSort(float arr[], int n) {
vector<float>* bucket = new vector<float>[n];
for (int i = 0; i < n; i++) {
int key = arr[i] * n;
bucket[key].push_back(arr[i]);
}
for (int i = 0; i < n; i++) {
sort((bucket[i].begin()), (bucket[i].end()));
}
int index = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < bucket[i].size(); j++) {
arr[index++] = bucket[i][j];
}
}
};
int main() {
float arr[10] = {
0.33,0.9,0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1 };
BucketSort(arr, 10);
for (int i = 0; i < 10; i++) {
cout << arr[i] << "\t";
}
return 0;
}
2、C++泛型编程实现广义表
#include <iostream>
#include <string>
using namespace std;
typedef enum {
atom, list }NodeTag;
template <typename DataType>
class GLIST {
private:
typedef struct GLNode{
NodeTag tag;
union {
DataType data;
GLNode* slink;
};
GLNode* link;
}*Glist;
public:
Glist _GL;
Glist p;
public:
Glist CreateGList(Glist GL) {
char ch;
ch = getchar();
if (ch != ' ') {
GL = (GLNode *)malloc(sizeof(GLNode));
if (ch == '(') {
GL->tag = list;
GL->slink = CreateGList(GL->slink);
}
else {
GL->tag = atom;
GL->data = ch;
}
}
else GL = NULL;
ch = getchar();
if (GL != NULL) {
if (ch == ',')
GL->link = CreateGList(GL->link);
else
GL->link = NULL;
return GL;
}
}
void PrintGlist(Glist GL = this.GL) {
if (GL != NULL) {
if (GL->tag == list) {
cout << "(";
if (GL -> slink == NULL)cout << " ";
else PrintGlist(GL->slink);
}
else {
cout << GL->data;
}
if (GL->tag == list)cout << ")";
if (GL->link != NULL) {
cout << ",";
PrintGlist(GL->link);
}
}
}
void FindGlistX(GList GL,DataType x,int * mark) {
if (GL != NULL) {
if (GL->tag == 0 && GL->data == x) {
p = GL;
*mark = 1;
}
else {
if (GL->tag == 1)FindGlistX(GL->slink, x, mark);
FindGlistX(gl->link, x, mark);
}
}
}
Glist tail() {
Glist p;
if (GL != NULL && GL->tag != 0) {
p = GL->slink;
p->link = NULL;
return p;
}
else return NULL;
}
void depth(Glist GL, int * maxdh) {
int h;
if (GL->tag == 0)*maxdh = 0;
else {
if (GL->tag == 1 && GL->slink == NULL) {
*maxdh = 1;
}
else {
GL = GL->slink;
*maxdh = 0;
do {
depth(GL, &h);
if (h > *maxdh) {
maxdh = h;
}
} while (GL != NULL);
(*maxdh)++;
}
}
}
};
int main()
{
GLIST<char>* gl = new GLIST<char>();
gl->CreateGList(gl->_GL);
gl->PrintGlist(gl->_GL);
return 0;
}
3、使用C++实现散列函数算法
#include <iostream>
#include <cmath>
using namespace std;
class Hex_Function
{
private:
long a;
long b;
public:
Hex_Function(int value1, int value2) {
a = value1;
b = value2;
}
long Create_Hyperbola_function(long value)
{
return sqrt(((pow(b, 2)*pow(value, 2)) / pow(a, 2)) - pow(b, 2));
}
long Get_Ticking_function(long value)
{
return (value*a) + (b / value);
}
};
int main()
{
Hex_Function* one = new Hex_Function(1,65535);
cout <<"散列值："<< one->Get_Ticking_function(one->Create_Hyperbola_function(43));
return 0;
}
3、使用C++实现二叉排序树
#include <iostream>
using namespace std;
int arr[10] = {
11,20,39,48,9,7,5,49,1,44 };
struct BinTree {
int key;
BinTree* leftNode;
BinTree* rightNode;
};
BinTree* BSTree = NULL;
BinTree* InsertBST(BinTree* T,BinTree* S) {
BinTree* f = NULL, *p = T;
while (p) {
f = p;
if (S->key < p->key)p = p->leftNode;
else p = p->rightNode;
}
if (T == NULL)T = S;
else if (S->key < f->key)
f->leftNode = S;
else f->rightNode = S;
return T;
}
void CreateBST() {
for (int i = 0; i < 10; i++) {
BinTree* S = (BinTree*)malloc(sizeof(BinTree));
S->key = arr[i];
S->leftNode = S->rightNode = NULL;
BSTree = InsertBST(BSTree, S);
}
}
BinTree* SearchBST(BinTree* T,int data) {
if (T == NULL || T->key == data) {
return T; }
else if (data < T->key) {
SearchBST(T->leftNode, data); }
else SearchBST(T->rightNode, data);
}
void Mid_Print(BinTree* Head) {
if (Head->leftNode != NULL)Mid_Print(Head->leftNode);
if (Head!=NULL)printf("%d\t", Head->key);
if (Head->rightNode != NULL)Mid_Print(Head->rightNode);
}
int main()
{
BinTree** one = &BSTree;
CreateBST();
Mid_Print(*one);
BinTree* two = SearchBST(*one, 1);
printf("%d", two->key);
return 0;
}