HNU数据结构与算法szh

已于 2023-04-06 22:05:33 修改
阅读量152 收藏 1
点赞数 1
文章标签： c++ 开发语言
于 2023-03-09 22:45:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67635510/article/details/129433054
版权

C语言数据结构

实验

实验二

#include<iostream>
#include"string"
#include<queue>

using  namespace  std;

template<typename  E>
class  BinNode//结点类
{
private:
    BinNode* lc;//左孩子
    BinNode* rc;//右孩子
    E  elem;
public:
    BinNode()//默认构造函数，设置左右孩子为空
    {

        lc = rc = NULL;

    }
    BinNode(E  tmp, BinNode* l = NULL, BinNode* r = NULL)//带参构造函数
    {

        elem = tmp;
        lc = l;
        rc = r;

    }
    BinNode* left()//返回左孩子
    {

        return lc;

    }
    BinNode* right()//返回右孩子
    {

        return rc;

    }
    void  setLeft(BinNode* l)//设置左孩子
    {

        lc = l;

    }
    void  setRight(BinNode* r)//设置右孩子
    {

        rc = r;

    }
    void  setValue(E  tmp)//设置当前结点的值
    {

        elem = tmp;

    }
    E  getValue()//获得当前结点的值
    {

        return elem;

    }
    bool  isLeaf()//判断当前结点是否为叶子结点
    {

        return (lc == NULL) && (rc == NULL);

    }
};

template<typename  E>
class  BinTree//二叉树类
{
private:
    BinNode<E>* root;//根结点
    void  clear(BinNode<E>* r)//清空二叉树
    {

        if (r == NULL) return;
        clear(r->left());
        clear(r->right());
        delete r;

    }
    void  preOrder(BinNode<E>* tmp, void(*visit)(BinNode<E>* node))//先序遍历，void(*visit)(BinNode<E>*node)为一个函数指针参数，用visit代替传进来的函数，在遍历函数中使用传进来的函数功能
    {

        if (tmp != NULL) {
            visit(tmp);
            preOrder(tmp->left(), visit);
            preOrder(tmp->right(), visit);
        }

    }
    void  inOrder(BinNode<E>* tmp, void(*visit)(BinNode<E>* node))//中序遍历，void(*visit)(BinNode<E>*node)为一个函数指针参数，用visit代替传进来的函数，在遍历函数中使用传进来的函数功能
    {

        if (tmp != NULL) {
            inOrder(tmp->left(), visit);
            visit(tmp);
            inOrder(tmp->right(), visit);
        }

    }
    void  postOrder(BinNode<E>* tmp, void(*visit)(BinNode<E>* node))//后序遍历，void(*visit)(BinNode<E>*node)为一个函数指针参数，用visit代替传进来的函数，在遍历函数中使用传进来的函数功能
    {

        if (tmp != NULL) {
            postOrder(tmp->left(), visit);
            postOrder(tmp->right(), visit);
            visit(tmp);
        }

    }
    void  LevelOrderTranverse(BinNode<E>* tmp, void(*visit)(BinNode<E>* node))//层次遍历，void(*visit)(BinNode<E>*node)为一个函数指针参数，用visit代替传进来的函数，在遍历函数中使用传进来的函数功能
    {

        queue<BinNode<E>*> q;
        if (tmp != NULL) { q.push(tmp); }//压入队尾
        BinNode<E>* b;
        while (!q.empty()) {
            b = q.front();//b等于队头元素
            visit(b);
            q.pop();//弹出队头元素
            if (b->left()) {
                q.push(b->left());//压入b的左孩子
            }
            if (b->right()) {
                q.push(b->right());//压入b的右孩子
            }
        }

    }
    int  BinTreeDepth(BinNode<E>* tmp)//获得二叉树的深度
    {

        if (BinTreeHeight(tmp) > 0) return BinTreeHeight(tmp) - 1;
        else return 0;

    }
    int  BinTreeNodes(BinNode<E>* tmp)//获得二叉树的结点数
    {

        if (tmp != NULL)
        {
            return (BinTreeNodes(tmp->left()) + BinTreeNodes(tmp->right()) + 1);
        }
        else return 0;

    }
    int  BinTreeHeight(BinNode<E>* tmp)//获得二叉树的高度
    {

        if (tmp == NULL)
        {
            return 0;
        }
        if (tmp->isLeaf())
        {
            return 1;
        }
        int lh = BinTreeHeight(tmp->left());
        int rh = BinTreeHeight(tmp->right());
        return 1 + (lh > rh ? lh : rh);

    }
    int  BinTreeLeafs(BinNode<E>* tmp)//获得二叉树的叶子结点数
    {

        if (tmp == NULL) return 0;
        if (tmp->isLeaf()) return 1;
        return BinTreeLeafs(tmp->left()) + BinTreeLeafs(tmp->right());

    }
    bool  find(BinNode<E>* tmp, E  e)//查找二叉树中是否含有某个名为e的结点
    {

        if (tmp == NULL) return false;
        if (tmp->getValue() == e) return true;
        bool lresult = find(tmp->left(), e);
        bool rresult = find(tmp->right(), e);
        return lresult || rresult;

    }
public:
    BinTree()//默认构造函数
    {
        root = new  BinNode<E>;
    }
    ~BinTree()//析构函数
    {
        clear(root);
    }
    bool  BinTreeEmpty()//判断二叉树是否为空
    {
        if (root == NULL)
            return  true;
        else
            return  false;
    }
    BinNode<E>* getRoot()//获得根节点
    {
        return  root;
    }
    void  setRoot(BinNode<E>* r)//设置根节点
    {
        root = r;
    }
    //下面的函数是对外的函数，所以内部还会有一些同名的函数，但是参数列表不一样，实现数据的封装，外部的调用不会涉及到内部的数据对象
    void  clear()//清空二叉树
    {
        clear(root);
        root = NULL;
    }
    void  preOrder(void(*visit)(BinNode<E>* node))//先序遍历，传入相对应的访问函数即可对该当前结点实现不同功能的访问（本程序为输出）
    {
        preOrder(root, visit);
    }
    void  inOrder(void(*visit)(BinNode<E>* node))  //先序遍历，传入相对应的访问函数即可对该当前结点实现不同功能的访问（本程序为输出）
    {
        inOrder(root, visit);
    }
    void  postOrder(void(*visit)(BinNode<E>* node))//先序遍历，传入相对应的访问函数即可对该当前结点实现不同功能的访问（本程序为输出）
    {
        postOrder(root, visit);
    }
    void  LevelOrderTranverse(void(*visit)(BinNode<E>* node))//先序遍历，传入相对应的访问函数即可对该当前结点实现不同功能的访问（本程序为输出）
    {
        LevelOrderTranverse(root, visit);
    }
    int  BinTreeDepth()//获得二叉树深度
    {
        return  BinTreeDepth(root);
    }
    int  BinTreeNodes()//获得二叉树结点数
    {
        return  BinTreeNodes(root);
    }
    int  BinTreeHeight()//获得二叉树高度
    {
        return  BinTreeHeight(root);
    }
    int  BinTreeLeafs()//获得二叉树叶子结点数
    {
        return  BinTreeLeafs(root);
    }
    bool  find(E  e)//查找二叉树中是否存在名为e的结点
    {
        return  find(root, e);
    }
};



template<typename  E>
void  printNode(BinNode<E>* tmp)//打印结点的值的函数
{
    cout << tmp->getValue() << "  ";
}

template<typename  E>
BinNode<E>* creatBinaryTree(string  s[], int& x, int  n)//构建二叉树的主函数，根据先序遍历，采用递归思想构建
{
    if (s[x] == "/")
        return  NULL;
    else
    {
        BinNode<E>* node = new  BinNode<E>(s[x]);
        x = x + 1;
        if (x < n);
        node->setLeft(creatBinaryTree<E>(s, x, n));
        x = x + 1;
        if (x < n);
        node->setRight(creatBinaryTree<E>(s, x, n));
        return  node;
    }
}

void  creatBinaryTree(BinTree<string>* BT)//构建二叉树的函数，包含了上面的构建二叉树的主函数，仅仅起到了在主函数中简洁一些的作用
{
    //cout  <<  "现在进入构建二叉树程序......"  <<  endl;
    //cout  <<  "请输入二叉树有多少个结点(空结点也计算其中)"  <<  endl;
    int  n = 0;
    cin >> n;
    //cout  <<  "请按preorder顺序输入，遇到NULL请输入'/',用空格隔开或者回车隔开均可以"  <<  endl;
    string* s = new  string[n];
    for (int i = 0; i < n; i++)
    {
        cin >> s[i];
    }
    int  now = 0;
    BT->setRoot(creatBinaryTree<string>(s, now, n));
}

int  main()
{
    //本程序的二叉树是一个模板类，若想改变为别的类型，可以在相关的地方在“<>”中修改相关参数,本程序默认为最具有普遍性的string
    BinTree<string>* BT = new  BinTree<string>;
    creatBinaryTree(BT);
    string  strfind;
    cin >> strfind;
    //在这里，已经构建好了一棵二叉树
    //下面是二叉树的基本函数操作的展示

    cout << "0:判断是否为空树：";
    if (BT->BinTreeEmpty() == true)
        cout << "是" << endl;
    else
        cout << "否" << endl;
    cout << "1:前序遍历:";
    BT->preOrder(printNode);
    cout << endl;
    cout << "2:中序遍历:";
    BT->inOrder(printNode);
    cout << endl;
    cout << "3:后序遍历:";
    BT->postOrder(printNode);
    cout << endl;
    cout << "4:层次遍历:";
    BT->LevelOrderTranverse(printNode);
    cout << endl;
    cout << "5:记录树的深度:";
    cout << BT->BinTreeDepth() << endl;
    cout << "6:记录树的高度:";
    cout << BT->BinTreeHeight() << endl;
    cout << "7:统计结点:";
    cout << BT->BinTreeNodes() << endl;
    cout << "8:统计叶子结点:";
    cout << BT->BinTreeLeafs() << endl;
    cout << "9:查找" << strfind << ":";
    if (BT->find(strfind) == true)
        cout << "存在" << endl;
    else
        cout << "不存在" << endl;
    cout << "10:是否清空:";
    BT->clear();
    cout << "已清空" << endl;
    cout << "5:记录树的深度:";
    cout << BT->BinTreeDepth() << endl;
    cout << "6:记录树的高度:";
    cout << BT->BinTreeHeight() << endl;
    cout << "7:统计结点:";
    cout << BT->BinTreeNodes() << endl;
    cout << "8:统计叶子结点:";
    cout << BT->BinTreeLeafs() << endl;
    return  0;
}

前言

结构体的使用

malloc()动态分配内存

#include <stdio.h>
#include <malloc.h>
int main ()
{
    int a[5]={4,10,2,8,6};
    int len;
    scanf("%d",&len);
    int *pArr = (int *)malloc(sizeof(int)*len);
    for(int i=0; i<len; i++) scanf("%d",&pArr[i]);
    for(int i=0; i<len; i++) printf("%d\n",*(pArr+i));
    //*pArr = 4;//类似于a[0]=4;
    //pArr[1] = 10;//类似于a[1]=10;
    
    free(pArr);//把pArr所代表的动态分配的20个字节的内存释放
    return 0;
}

连续存储数组的算法演示

#include<bits/stdc++.h>
using namespace std;

struct Arr
{
	int* pBase;//存储的是数组第一个元素的地址 
	int len;//数组所能容纳的最大元素的个数 
	int cnt;//当前数组有效元素的个数 
};

void init_arr(struct Arr *pArr,int length);//初始化 
bool append_arr(struct Arr *pArr, int val);//尾加
bool insert_arr(struct Arr *pArr, int pos, int val); //插入值   pos的值从1开始 
bool delete_arr(struct Arr *pArr, int pos, int* pVal);
bool is_empty(struct Arr* pArr);
bool is_full(struct Arr* pArr);
void sort_arr(struct Arr* pArr);
void show_arr(struct Arr* pArr);//打印数组 
void inversion_arr(struct Arr* pArr);//倒置数组 

int main()
{
	struct Arr arr;
	int val;
	
	init_arr(&arr,6);
	
	append_arr(&arr,1);
	show_arr(&arr);
	delete_arr(&arr,1,&val);
	append_arr(&arr,2);
	append_arr(&arr,3);
	append_arr(&arr,4);
	append_arr(&arr,5);
	insert_arr(&arr,7,99);
	show_arr(&arr);
	inversion_arr(&arr);
	show_arr(&arr);
	sort_arr(&arr);
	show_arr(&arr);
	
	return 0;
} 

void init_arr(struct Arr *pArr,int length)
{
	pArr->pBase = (int*)malloc(sizeof(int)*length);
	if(NULL == pArr->pBase)//如果分配不成功 
	{
		cout<<"动态内存分配失败"<<endl;
		exit(-1);//终止整个程序 
	}
	else
	{
		pArr->len = length;
		pArr->cnt = 0;
	} 
	return;
}

bool append_arr(struct Arr *pArr, int val)
{
	if(is_full(pArr)) return 0;//如果已满则加不进去 返回false 
	else//未满则增加val到末尾 
	{
		pArr->pBase[(pArr->cnt)++] = val;
		return 1;
	}
}

bool insert_arr(struct Arr *pArr, int pos, int val)
{
	if(is_full(pArr)) return 0;
	if(pos<1 || pos>pArr->cnt+1) return 0;
	for(int i=pArr->cnt-1; i>=pos-1; --i) pArr->pBase[i+1] = pArr->pBase[i];
	pArr->pBase[pos-1] = val;
	(pArr->cnt)++;
	return 1;
}

bool delete_arr(struct Arr *pArr, int pos, int* pVal)
{
	if(is_empty(pArr)) return 0;
	if(pos<1 || pos>pArr->cnt) return 0;
	*pVal=pArr->pBase[pos-1];//把要删除的值赋给*pVal 
	for(int i=pos; i<pArr->cnt;++i) pArr->pBase[i-1] = pArr->pBase[i];
	pArr->cnt--;//有效个数减1
	return 1; 
}

bool is_empty(struct Arr* pArr)
{
	if(0 == pArr->cnt) return 1;
	else return 0;
}

bool is_full(struct Arr* pArr)
{
	if(pArr->cnt == pArr->len) return 1;
	else return 0;
}

void sort_arr(struct Arr* pArr)
{
	for(int i=0;i<pArr->cnt-1;i++)//冒泡排序 
	{
		for(int j=i+1;j<pArr->cnt;j++)
		{
			if(pArr->pBase[i]>pArr->pBase[j])
			{
				int temp = pArr->pBase[i];
				pArr->pBase[i] = pArr->pBase[j];
				pArr->pBase[j] = temp;
			}
		}
	}
}

void show_arr(struct Arr* pArr)
{
	if(is_empty(pArr)) cout<<"数组为空!"<<endl;
	else
	{
		for(int i=0;i<pArr->cnt;i++) printf("%d ",pArr->pBase[i]);//先等于 再自增 
		cout<<endl;
	}
}

void inversion_arr(struct Arr* pArr)
{
	int i=0;
	int j=pArr->cnt-1;
	while(i<j)//互换
	{
		int temp = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = temp;
		i++; j--;
	} 
	return;
}

链表

typedef的用法

#include <stdio.h>

typedef int INT;//为int再取一个名字INT
typedef struct student
{
    int sid;
    char name[100];
    char sex;
}* PST,ST;//ST为struct student， PST为struct student*

int main()
{
    struct student st; //等价于ST st;
    struct student* ps = &st;//等价于ST* ps = &st; 等价于PST ps = &st;
}

链表的定义

n个节点离散分配 彼此通过指针相连 首节点没有前驱节点 尾节点没有后续节点

5个专业术语

首节点：第一个有效节点

尾节点：最后一个有效节点

头节点：第一个有效节点之前的那个节点 头节点并不存放有效数据 加头结点的目的主要是为了方便堆链表操作 头节点数据类型和首节点一样

头指针：指向头结点的指针变量(存放头节点地址)

尾指针：指向尾结点的指针变量(存放尾节点地址)

**确定一个链表需要几个参数：**只需要一个参数：头指针

链表分类： 单链表

​ 双链表：每个节点有两个指针域

​ 循环链表：能通过任何一个节点找到其他所有节点

​ 非循环链表

链表的实现

#include<bits/stdc++.h>
using namespace std;

typedef struct Node 
{
	int data;//数据域 
	struct Node* pNext;//指针域 
}NODE,*PNODE;//NODE等价于struct Node    PNODE等价于struct Node*

PNODE create_list(); 
void traverse_list(PNODE pHead);//遍历输出 
void is_empty(PNODE pHead);
int length_list(PNODE);//求链表长度 
bool insert_list(PNODE pHead,int pos,int val);//插入 
bool delete_list(PNODE pHead ,int pos,int* val);//删除 
void sort_list(PNODE);//排序 


int main()
{
	PNODE pHead = NULL;//等价于struct Node* pHead = NULL;
	
	pHead = create_list(); //create_list()功能为创建一个非循环单链表，并将改链表头结点的地址赋给pHead 
	traverse_list(pHead);
	is_empty(pHead);
	cout<<"链表长度为："<<length_list(pHead)<<endl;
	void sort_list(PNODE pHead);
	insert_list(pHead,3,33);
	sort_list(pHead);
	traverse_list(pHead);
	return 0;
} 

PNODE create_list()
{
	int len;//用来存放有效节点的个数
	int val;//用来存放用户输入的结点的值 
	
	//分配了一个不存放有效数据的头节点
	PNODE pHead = (PNODE)malloc(sizeof(NODE)); 
	if(NULL==pHead)
	{
		cout<<"分配失败，程序终止！"<<endl;
		exit(-1); 
	}
	
	//初始化pTail 永远指向最后一个节点 
	PNODE pTail = pHead;
	pTail->pNext = NULL;
	
	cout<<"请输入您需要生成的链表节点的个数:len=";
	cin>>len;
	for(int i=0;i<len;i++)
	{
		cout<<"请输入第"<<i+1<<"个节点的值:"; 
		cin>>val; 
		
		PNODE pNew = (PNODE)malloc(sizeof(NODE));
		if(NULL==pNew)
		{
			cout<<"分配失败，程序终止！"<<endl;
			exit(-1); 
		}
		pNew->data = val;//数据域赋值
		
		//指针域赋值
		pTail->pNext = pNew;
		pNew->pNext = NULL;
		pTail = pNew; 
	} 
	return pHead; 
}

void traverse_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	while(NULL != p)
	{
		cout<<p->data<<" ";
		p = p->pNext;
	}
	cout<<endl;
	return;
}

void is_empty(PNODE pHead)
{
	if(pHead->pNext == NULL) 
	{
		cout<<"链表为空！"<<endl; 
	}
	else 
	{
		cout<<"链表不为空！"<<endl;
	}
	return;
} 


int length_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	int len = 0;
	while(NULL != p) 
	{
		++len;
		p = p->pNext;
	}
	return len;
}

//非常难  要多看
bool insert_list(PNODE pHead,int pos,int val)
{
	int i=0;
	PNODE p = pHead;
	while(NULL!=p && i<pos-1)
	{
		p = p->pNext;
		++i;
	}
	if(i>pos-1 || NULL==p) return 0;
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	if(NULL==pNew)
	{
		cout<<"动态内存分配失败！"<<endl;
		exit(-1);
	}
	pNew->data = val;
	PNODE q = p->pNext;
	p->pNext = pNew;
	pNew->pNext = q;
	return 1;
}

//非常难  要多看
bool delete_list(PNODE pHead ,int pos,int* val)
{
	int i=0;
	PNODE p = pHead;
	while(NULL!=p->pNext && i<pos-1)
	{
		p = p->pNext;
		++i;
	}
	if(i>pos-1 || NULL==p->pNext) return 0;
	PNODE q = p->pNext;
	*val = q->data;
	
	//删除p节点后面的节点 
	p->pNext = p->pNext->pNext;
	free(q);
	q = NULL;
	return 1;
}

void sort_list(PNODE pHead)
{
	PNODE p,q;
	for(p=pHead->pNext;p->pNext!=NULL;p=p->pNext)
	{
		for(q=p->pNext;q!=NULL;q=q->pNext)
		{
			if(p->data > q->data)
			{
				int t=p->data;
				p->data=q->data;
				q->data=t;
			}
		}
	}
	return;
}

栈

简要介绍

定义：一种可以实现”先进后出“的存储结构

分类：静态栈 动态栈

栈的实现

#include<bits/stdc++.h>
using namespace std;

typedef struct Node 
{
	int data;//数据域 
	struct Node* pNext;//指针域 
}NODE,*PNODE;//NODE等价于struct Node    PNODE等价于struct Node*

typedef struct Stack
{
	PNODE pTop;//不停变化 
	PNODE pBottom;//一般不变 
}STACK,*PSTACK;

void init(PSTACK);//栈初始化 
void push(PSTACK,int);//入栈 
void traverse(PSTACK);//遍历输出 
void pop(PSTACK,int*);//出栈 
void clear(PSTACK pS);//清空 

int main()
{
	int val;//保存出战元素的值 
	STACK S;//STACK等价于struct Stack 
	init(&S);
	push(&S,1);
	push(&S,2);
	push(&S,3);
	push(&S,4);
	push(&S,5);
	push(&S,6);
	traverse(&S);
	pop(&S,&val);
	traverse(&S);
	clear(&S);
	traverse(&S);
	return 0;
} 

void init(PSTACK pS)
{
	pS->pTop = (PNODE)malloc(sizeof(NODE));
	if(NULL==pS->pTop)
	{
		cout<<"动态内存分配失败！"<<endl;
		exit(-1);
	} 
	else
	{
		pS->pBottom = pS->pTop;
		pS->pTop->pNext = NULL;//头节点指针域置为空 
	}
}

void push(PSTACK pS,int val)
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	pNew->data = val;
	
	pNew->pNext = pS->pTop;//不能改成pS->pBottom
	pS->pTop = pNew;
	return;
}

void traverse(PSTACK pS)
{
	PNODE p = pS->pTop;
	while(p!=pS->pBottom)
	{
		cout<<p->data<<" ";
		p = p->pNext;
	}
	cout<<endl;
	return;
}

bool empty(PSTACK pS)
{
	if(pS->pBottom == pS->pTop) return 1;
	else return 0;
}

//把pS所指向的栈出栈一次  并把出栈元素存入val形参所指向的变量中  如果出栈失败则返回false 否则返回true 
void pop(PSTACK pS,int* pval)
{
	if(empty(pS))
	{
		cout<<"出栈失败！"<<endl;
	} 
	else
	{
		PNODE r = pS->pTop;
		*pval = r->data;
		pS->pTop = pS->pTop->pNext;
		free(r);
		r=NULL;
		cout<<"出栈成功，出栈的元素是："<<*pval<<endl;
	}
	return;
}

void clear(PSTACK pS)//把有效数据全部删除 
{
	if(empty(pS)) return;
	else
	{
		PNODE p = pS->pTop;
		PNODE q = NULL;
		while(p != pS->pBottom)
		{
			q=p->pNext;
			free(p);//free(p)释放的是p所指的对象 不是p 
			p = q;
		}
		pS->pTop = pS->pBottom;
		return; 
	}
}

队列

简要介绍

定义：一种可以实现“先进先出”的存储结构

分类：链式队列——用链表实现 静态队列——用数组实现(通常都是循环队列)

循环队列需要几个参数来确定： front rear

​ 1.队列初始化：front和rear的值都是0

​ 2.队列非空：front代表队列最后一个元素 rear代表队列最后一个有效元素的下一个元素

​ 3.队列空：front和rear的值相等 但不一定是零

伪算法演示

入队：将值存入r所代表的位置 r=(r+1)%数组的长度

出队：f=(f+1)%数组的长度

如何判断队列是否已满：

​ 1.多增加一个标识参数

​ 2.少用一个元素 如果r和f的值紧挨着 则队列已满

if ((r+1)%数组长度 == f) 已满;
else 不满;

队列的实现

//该程序可存放的最大整型数数目为5(6-1) 
#include<bits/stdc++.h>
using namespace std;

typedef struct Queue 
{
	int* pBase;
	int front;
	int rear;
}QUEUE;

void init(QUEUE*);//队列初始化 
bool en(QUEUE* ,int val);//入队
bool out(QUEUE* ,int*);//出队 
void traverse(QUEUE*);//遍历 
bool full(QUEUE*);//判断是否已满 
bool empty(QUEUE*);//判断是否为空 

int main()
{
	QUEUE Q;
	int val;
	
	init(&Q);
	en(&Q,1);
	en(&Q,2);
	en(&Q,3);
	en(&Q,4);
	en(&Q,5);
	en(&Q,6);
	en(&Q,7);
	en(&Q,8);
	traverse(&Q);
	if(out(&Q,&val))
	{
		cout<<"出队成功！队列出队的元素是："<<val<<endl;
	}
	else cout<<"出队失败！"<<endl;
	traverse(&Q);	
	
	return 0;
} 

void init(QUEUE* pQ)
{
	pQ->pBase = (int*)malloc(sizeof(int)*6);
	pQ->front = 0;
	pQ->rear = 0;
	return;
}

bool en(QUEUE* pQ,int val)
{
	if(full(pQ)) return 0;
	else
	{
		pQ->pBase[pQ->rear] = val;
		pQ->rear = (pQ->rear+1)%6;
		return 1;
	}
}

bool out(QUEUE* pQ,int* pVal)
{
	if(empty(pQ)) return 0;
	else
	{
		*pVal = pQ->pBase[pQ->front];
		pQ->front = (pQ->front+1)%6;
		return 1;
	}
}

void traverse(QUEUE* pQ)
{
	int i=pQ->front;
	while(i!=pQ->rear)
	{
		cout<<pQ->pBase[i]<<" ";
		i = (i+1)%6;
	}
	cout<<endl;
	return;
}

bool full(QUEUE* pQ)
{
	if((pQ->rear+1)%6 == pQ->front) return 1;
	else return 0;
}

bool empty(QUEUE* pQ)
{
	if(pQ->front == pQ->rear) return 1;
	else return 0;
}

递归

简要介绍

定义：一个函数自己直接或间接调用自己

举例

//1.求阶乘
#include<bits/stdc++.h>//for循环实现 
using namespace std;
int main()
{
	int val,res=1; cin>>val;
	for(int i=1;i<=val;i++) res*=i;
	cout<<res<<endl;
	return 0;
} 

#include<bits/stdc++.h>//递归实现
using namespace std;
int f(int n)
{
	if(n==1) return 1;
	else return f(n-1)*n;
}
 
int main()
{	
	int val;cin>>val;
	cout<<f(val)<<endl;
	return 0;
} 


//1+2+...+100 
#include<bits/stdc++.h>
using namespace std;
int sum(int n)
{
	if(1==n) return 1;
	else return n+sum(n-1);
}
int main()
{
	cout<<sum(100)<<endl;
	return 0;
} 


//汉诺塔 
#include<bits/stdc++.h>
using namespace std;
void hannuota(int n,char A,char B,char C)//有n个盘子  从A借助B移到C 
{
/*	如果是1个盘子
		直接将A柱子上的盘子借助C移到B
	否则
		先将A柱子上的n-1个盘子借助C移到B
		直接将A柱子上剩余的一个盘子从A移到C
		最后将B柱子上的n-1个盘子借助A移到C
*/ 
	if(n==1) printf("将编号为%d的盘子直接从%c柱子移到%c柱子\n",n,A,C);
	else
	{
		hannuota(n-1,A,C,B);
		printf("将编号为%d的盘子直接从%c柱子移到%c柱子\n",n,A,C);
		hannuota(n-1,B,A,C);
	}
} 
int main()
{
	int n; cin>>n;
	hannuota(n,'A','B','C');
	return 0;
}

树

简要介绍

深度：从根节点到最底层节点的层数 根节点是第一层

叶子节点：没有子节点的节点

非终端节点：即非叶子节点

度：子节点的个数

数分类

​ 一般数

​ 二叉树：任意一个节点的子节点个数最多两个，且子节点的位置不可更改

​ 一般二叉树

​ 满二叉树：在不增加树的层数的情况下，无法再多添加一个界定的二叉树称为满二叉树

​ 完全二叉树：如果只是删除了满二叉树最底层最右边的连续若干个节点 这样形成的二叉树就是完全二叉树

​ 森林：n个互不相交的数的集合

树的存储

​ 二叉树的存储

​ 连续存储[完全二叉树]

​ 优点：查找某个节点的父节点和字节点速度很快

​ 缺点：耗用内存空间过大

​ 链式存储

​ 一般树的存储

​ 双亲表示法：求父节点方便

​ 孩子表示法：求子节点方便

​ 双亲孩子表示法

​ 二叉树表示法：把一个普通树转化成二叉树来存储 (一定没有右子树)

​ 具体转换方法：设法保证任意一个节点的做指针指向它的第一个孩子 右指针指向它的下一个兄弟 只要满足此条件 就可以把一个普通树转化成二叉树来存储

​ 森林的存储：先把森林转化为二叉树，再存储二叉树

二叉树操作

遍历

先序遍历 [先访问根节点]：先访问根节点 再先序访问左子树 再先序访问右子树(递归)

中序遍历 [中间访问根节点]：中序遍历左子树 再访问根节点 再中序遍历右子树

后序遍历 [最后访问根节点]：后序遍历左子树 再后序遍历右子树 再访问根节点

已知两种遍历序列求原始二叉树

通过先序和中序 或者 中序和后序可以还原出原始二叉树 但是通过先序和后序是无法还原出原始二叉树的**(必须有中序)**

已知先序和中序求后序
已知中序和后序求先序

链式二叉树遍历具体程序演示

#include<bits/stdc++.h>
using namespace std;

struct BTNode
{
	char data;//数据域 
	struct BTNode* pLchild;//p是指针 L是左 child是孩子
	struct BTNode* pRchild;//p是指针 R是右 child是孩子
};

struct BTNode* CreateBTree(); 
void PreTraverseBTree(struct BTNode*); 
void InTraverseBTree(struct BTNode*); 
void PostTraverseBTree(struct BTNode*); 

int main()
{
	struct BTNode* pT = CreateBTree(); 
	
	PreTraverseBTree(pT);//先序遍历输出 
	InTraverseBTree(pT); //中序遍历输出
	PostTraverseBTree(pT);//后序遍历输出 
	
	return 0;
} 

struct BTNode* CreateBTree(void)//静态构造树 
{
	struct BTNode* pA = (struct BTNode*)malloc(sizeof(struct BTNode));
	struct BTNode* pB = (struct BTNode*)malloc(sizeof(struct BTNode));
	struct BTNode* pC = (struct BTNode*)malloc(sizeof(struct BTNode));
	struct BTNode* pD = (struct BTNode*)malloc(sizeof(struct BTNode));
	struct BTNode* pE = (struct BTNode*)malloc(sizeof(struct BTNode));
	
	pA->data = 'A';
	pB->data = 'B';
	pC->data = 'C';
	pD->data = 'D';
	pE->data = 'E';
	
	pA->pLchild = pB;
	pA->pRchild = pC;
	pB->pLchild = pB->pRchild = NULL;
	pC->pLchild = pD;
	pC->pRchild = NULL;
	pD->pLchild = NULL;
	pD->pRchild = pE;
	pE->pLchild = pE->pRchild = NULL;
	
	return pA;
}

void PreTraverseBTree(struct BTNode* pT)
{
	if(NULL != pT)
	{
		cout<<pT->data<<endl;
		if(NULL != pT->pLchild) PreTraverseBTree(pT->pLchild);
		if(NULL != pT->pRchild) PreTraverseBTree(pT->pRchild);
	}
}

void InTraverseBTree(struct BTNode* pT)
{
	if(NULL != pT)
	{
		if(NULL != pT->pLchild) InTraverseBTree(pT->pLchild);
		cout<<pT->data<<endl;
		if(NULL != pT->pRchild) InTraverseBTree(pT->pRchild);
	}
}

void PostTraverseBTree(struct BTNode* pT)
{
	if(NULL != pT)
	{
		if(NULL != pT->pLchild) PostTraverseBTree(pT->pLchild);
		if(NULL != pT->pRchild) PostTraverseBTree(pT->pRchild);
		cout<<pT->data<<endl;
	}
}

查找和排序

快速排序法

#include<bits/stdc++.h>
using namespace std;

void  QuickSort(int *a,int low,int high);
int FindPos(int *a,int low,int high);

int main()
{
	int a[6] = {2,1,0,5,4,3};
	QuickSort(a,0,5);//第二个参数表示第一个元素下标   第三个参数表示最后一个元素下标
	
	for(int i=0;i<6;i++) cout<<a[i]<<" ";//遍历输出 
	cout<<endl; 
	return 0;
} 

void  QuickSort(int *a,int low,int high)
{
	int pos;
	if(low < high)
	{
		pos=FindPos(a,low,high);
		QuickSort(a,low,pos-1);
		QuickSort(a,pos+1,high);
	}
}

int FindPos(int *a,int low,int high)
{
	int val=a[low];
	while(low<high)
	{
		while(low<high && a[high]>=val) --high;
		a[low]=a[high];
		while(low<high && a[low]<=val) ++low;
		a[high]=a[low];
	}//while循环终止后high和low一定是相等的 
	a[low]=val;

	return high; 
}
10Futari
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
《数据结构与算法分析》课程实验设计与分析
10-03
hnu《数据结构与算法分析》课程实验的设计、记录与分析，含九个小实验，包括链表（顺序表）、树、图、排序算法等，主要有抽象数据结构的设计与实现、二叉树构建与遍历、栈与队列（最小差值、约瑟夫问题游戏）、BST、...
湖南大学数据结构实验2-游戏.zip
03-08
C++是一种常用的编程语言，特别适合处理复杂的数据结构和算法，它的面向对象特性使得在实现游戏逻辑时更加直观和高效。 在数据结构游戏中，可能会涉及到以下知识点： 1. **数组**：数组是最基础的数据结构，它允许...
HNU数据结构与算法分析-作业1-算法分析
wolf的博客
05-20 1169
对于输入规模n，在某台计算机上实现并完成该算法的时间为t秒。现在另有一台计算机，运行速度为第一台的64倍，那么t秒内新机器上能完成的输入规模为多大？(g)假设数组A中含有n个元素，函数Random花的时间是常数值，sort需要执行nlogn步。注意：课后作业必须在作业本上完成，需要有完整的计算过程。在截止时间之前，在系统提交答案照片。若输入的a数组是一个严格单调递增的数列，分析此程序的时间复杂度。(h)假设数组A中元素为从0到n-1的任意一个排列。1.（教材3.4）（a）假设某一个算法的时间代价为。
HNU数据结构和算法复习1
solution50的博客
05-23 242
Happy birthday to java! 白驹过隙，期末将至。今天做往年题的时候有个mergesort写得不是很利索，（代码填空，看得出来老师已经很尽力送分了）主要是再明确一下mergesort的逻辑和写法。上代码： void mergesort(Elem A[],Elem temp[],int left,int right) {//此处right和left指的是下标 /************************************划分子串**************************
HNU数据结构与算法分析-实验一---基于链表的线性表实现
wolf的博客
05-17 1670
【问题描述】 根据课程学习内容，补齐线性表的相关代码实现。 【输入形式】 若干行测试指令 指令说明： 1 在指定位置插入数据 1 0 9 在0位置插入数字9 1 2 1 在2位置插入数字1 2 删除指定位置的数据 2 0 删除0位置的数据 2 2 删除2位置的数据 3 获取指定位置的值 3 0 获取0位置的数据 4 查找特定值的位置 4 2 查找2第一次出现的位置 0 结束程序
HNU数据结构与算法分析-作业6-排序
wolf的博客
05-21 691
对以下8种排序算法，给定以下数据元素：31 73 44 13 7 28 22 64 53，对其进行从小到大排序，给出每趟排序过程。注意：课后作业必须在作业本上完成，需要有完整的计算过程。在截止时间之前，在系统提交答案照片。4，shell排序（增量d=5，3，1）作业本统一交给课代表。
HNU数据结构八算法实验
solution50的博客
06-04 283
yue果然做完计网做算法，这两天算法都快给我做吐了。 但是呢，你看，程序设计要考，ccf要考，数据结构要考，算法分析也要考。捏着鼻子忍忍吧。 数据结构实验8 CG上题目： 【问题描述】 桌子上有一个m行n列的方格矩阵，将每个方格用坐标表示，行坐标从下到上依次递增，列坐标从左至右依次递增，左下角方格的坐标为(1,1)，则右上角方格的坐标为(m,n)且（0<m+n<=20）。 小明是个调皮的孩子，一天他捉来一只蚂蚁，不小心把蚂蚁的右脚弄伤了，于是蚂蚁只能向上或向右移动。小明把这只蚂蚁放在左下角的方格
HNU数据结构与算法分析-作业5-检索
wolf的博客
05-20 749
【应用题】9.14 假定有一个7个槽的散列表（槽从0到6编号）。如果使用散列函数h(k) = k mod 7 和线性探查，作用于一组数字3、12、9、2，给出每次插入数字后的散列表。在插入值为2的关键码后，列出每一个空槽作为下一个被填充槽的概率。注意：课后作业必须在作业本上完成，需要有完整的计算过程。在截止时间之前，在系统提交答案照片。【应用题】13.5 (a)在下图所示的AVL树中，插入值39后的结果（包括合适的旋转）作业本统一交给课代表。
HNU数据结构与算法分析-实验三---基于二叉链表的二叉树实现
wolf的博客
05-17 1266
根据课程学习内容，补齐线性表的相关代码实现。 11 AB//CD//E// C 上述输入将构造一棵包含11个节点的二叉树，并将查询“C”是否存在。 上述输入对应生成的二叉树如下图 【输入形式】 第一行：输入二叉树总节点数n，（空节点也计算在内） 第二行：以空格分隔的节点数据（string类型），其中 / 表示该节点为空，其他数据为该节点保存的信息 第三行：拟在二叉树中查询的值 【输出形式】 具体输出以提供的代码为准 【样例输入】 11 AB//CD
hnu 数据结构 实验八
zumhui的博客
07-05 329
实验8 查找算法实验比较 实验目的 基于教材内容，从顺序查找、二分查找、基于BST的查找和哈希中任选两种查找算法，实现并比较性能。 基本要求 （1）对实现的查找算法进行实验比较，在不同数据规模（N）下执行100次成功查找，以表格形式记录最小、最大和平均查找时间；在不同数据规模（N）下执行100次不成功查找，以表格形式记录最小、最大和平均查找时间。 （2）查找算法要基于教材，测试输入的整数数据文件（5个，文件中数据规模N分别是100，1K，10K，100K和1M），每次查找的比较次数和时间也要输出到文件中。
hnu 数据结构 实验五
zumhui的博客
07-05 800
实验5 图的物理实现 分别提交两个附件： 1：实验5的日志报告文件，提交规范，参看课程规范。 2：实验5的源码包。（文件名也要规范，可以参考报告文件的格式） 实验五-图-实验日志 【2020.12.2】 任务：复习图论，知道图的矩阵存储结构和链表存储结构是如何实现的，并根据题目要求，理解书本上给的图的ADT如何完成图的相邻矩阵实现和邻接表实现。 【2020.12. 3】 任务：在理解图的两种存储实现方式后，将书本上的ADT模板输入程序中，并补足书本给出的模板未完成的链表实现的ADT。 【2020.12.4】
HNU数据结构与算法分析-小班4
wolf的博客
04-24 399
HNU数据结构与算法分析-小班4。
数据结构与算法分析期末试卷（湖南大学）.pdf
01-07
"数据结构与算法分析期末试卷（湖南大学）" 本资源是一个数据结构与算法分析期末试卷，来自湖南大学。试卷共分为五部分，包括判断题、选择题、填空题、简答题和应用题。 数据结构是计算机科学中的一门基础学科，...
数据结构各类查找总结.pdf
12-16
数据结构查找资料总结，
数据结构_二叉树.cpp
04-25
简单的二叉树实现，采用C++语言编写，从而形成对二叉树理论转换为代码的理解。书本《数据结构》。。。紫色书皮的那本
c++ primer plus 第16章string 类和标准模板库,string 类输入
最新发布
zhyjhacker的博客
07-14 755
c++ primer plus 第16章string 类和标准模板库,string 类输入。
C++初探究（2）
Frenemy__的博客
07-09 1491
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C语言操作符详解
z317920的博客
07-11 615
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
【C++】类和对象--类，实例化，this指针
tidal_wave的博客
07-10 1010
前面的几篇文章我们介绍了命名空间，inline，nullptr等C++中常见的的基础概念。今天的文章我们来介绍一些C++中类与对象的内容。在现实世界中，经常有属于同一类的对象。例如，你的自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象：矩形、雇用记录、视频剪辑等。可以利用这些对象的相同特征为它们建立一个集合。而这个集合就称为类。类是定义同一类所有对象的变量和方法的蓝图或原型。
hnu数据结构词频统计
04-18
HNU数据结构词频统计是指对HNU（湖南大学）数据结构课程中的文本进行分析，统计每个词在文本中出现的频率。数据结构是计算机科学中的重要基础课程，它研究如何组织和存储数据以便有效地访问和操作。词频统计可以帮助我们了解在数据结构课程中常用的术语和概念，并对学习和理解课程内容有所帮助。 为了进行词频统计，可以使用编程语言（如Python）来读取文本文件，并使用合适的数据结构（如字典）来记录每个词出现的次数。具体步骤如下： 1. 打开文本文件并读取内容。 2. 将文本内容按照空格或其他分隔符进行分割，得到一个词的列表。 3. 遍历词列表，对每个词进行统计。 4. 使用字典来记录每个词出现的次数，如果词已经在字典中，则将其对应的值加1；如果词不在字典中，则将其添加到字典，并将其对应的值设为1。 5. 统计完成后，可以按照词频进行排序，从高到低输出结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

10Futari

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值