数据结构期末复习

已于 2023-12-14 10:40:25 修改
阅读量212 收藏 2
点赞数 2
文章标签： 数据结构 算法
于 2023-12-06 12:19:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XUE_DING_E/article/details/134828516
版权

数据结构

文章目录

第四章 串

4.1 统计频数
#include <cstdio>
#include <iostream>
#include<string.h>
using namespace std;
void Count( char s[],int b[])
{  //统计串中的数字字符和大写字母的频度,并将结果存入数组b 
	/**************begin************/
    for(int i = 0 ; i < strlen(s) ; i ++)
    {
    	if(s[i] >= '0' && s[i] <= '9') 
    		b[(int)s[i] -(int)'0' ] += 1;
    	else
			b[10 + (int)s[i]-(int)'A'] += 1;	
	}
   
	/**************end**************/
}
int main()
{   char s[255];        // 定义串s
    cin>>s;             //输入串s
    int b[36]={0};      //定义数组b，初始化为0 
    Count(s,b);			
	
	//输出统计结果（只输出存在的字符，格式为 字符:频度），字符排列顺序按照ASCII码从小到大的顺序。 
	/**************begin************/
    for(int i = 0 ; i < 36 ; i ++)
    {
    	if(b[i] != 0 )
		{
			if(i >= 0 && i <= 9) cout << i ;
			else printf("%c",'A' + i - 10); 
			cout << ":" << b[i] << endl;
		} 	
	}
    /**************end**************/
    return 0;
}
4.2 取子串
#include <cstdio>
#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int Status;

#define MAXLEN 255
typedef struct{
	char ch[MAXLEN+1];		//从1号下标开始存储串值 
	int length;				//串的长度 
}SString;        			//串的定长顺序存储结构     

void InputStr(SString &s)	//输入串 
{	
    char str[MAXLEN];
	int i;
	cin>>str;
	for (i=0;str[i]!='\0';i++)
			s.ch[i+1]=str[i];
	s.length=i;
}

void OutputStr(SString s)	//输出串
{ 
	for (int i=1;i<=s.length;i++) 
		cout<<s.ch[i];	
}

Status SubString(SString s,SString &sub,int  pos,int len){
	//在串s的第pos位置开始取出len个字符，存入串sub,若成功，返回OK,否则返回ERROR 
	/********************begin********************/
 	if(pos + len - 1> s.length || pos <= 0 || len <= 0 || pos > s.length || len > s.length) return ERROR;
	for(int i = pos, j = 1 ; i < pos + len ; i ++,j ++)
		sub.ch[j] = s.ch[i];
	sub.length = len;
	return OK;
  	/********************end ********************/
}


int main() 
{	
    SString s,sub;
    int pos,len; 
    InputStr(s);				//输入串s
	cin>>pos; 
	cin>>len;
	//调用取子串函数，并按要求输出。 
	/********************begin********************/
	if(SubString(s,sub,pos,len)) OutputStr(sub);
	else cout << "Error!";
	
	/********************end ********************/	
	return 0; 
}
4.3 kmp
#include <iostream>
using namespace std;

#define MAXLEN 255
typedef struct{
	char ch[MAXLEN+1];		//从1号下标开始存储串值 
	int length;				//串的长度 
}SString;        			//串的定长顺序存储结构     

void InputStr(SString &s)	//输入串 
{	
    char str[MAXLEN];
	int i;
	cin>>str;
	for (i=0;str[i]!='\0';i++)
			s.ch[i+1]=str[i];
	s.length=i;
}
int Index_BF(SString s,SString t)
{   //在串s中查找串t的首次出现位置，如不存在，则返回0 
	/***************begin*************/
	for(int i = 1 ; i <= s.length ; i ++)
    {
     	int flag = 1 ;
     	int x = i;
		for(int j = 1 ; j <= t.length ; j ++)
     	{
     		//cout << "j:" << j << endl;
     		if(s.ch[x++] != t.ch[j]) 
     		{
     			flag = 0 ;
     			break;
			}
		}
		if(flag) return i;
	}
	return 0;
	/***************end *************/
}

int main() 
{	
    SString s,t;
    InputStr(s);				//输入串s
	InputStr(t);
//	cout << s.length << endl;
//	cout << t.length << endl;				//输入串t
	cout<<Index_BF(s,t);		//输出查找结果	
	return 0; 
}
4.4 串的插入
#include <iostream>
using namespace std;
#define MAXLEN 255
typedef struct{
	char ch[MAXLEN+1];		//从1号下标开始存储串值 
	int length;				//串的长度 
}SString;        			//串的定长顺序存储结构     

void InputStr(SString &s)	//输入串 
{	
    char str[MAXLEN];
	int i;
	cin>>str;
	for (i=0;str[i]!='\0';i++)
			s.ch[i+1]=str[i];
	s.length=i;
}
void OutputStr(SString s)	//输出串
{ 
	for (int i=1;i<=s.length;i++) 
		cout<<s.ch[i];	
}

void InsertStr(SString &s,int pos, SString t)
{  //在串s的第pos位置插入串t，如pos不合法，则不插入
	/***************begin*************/ 
  	if(pos <= 0 || pos > s.length + 1 || s.length + t.length > MAXLEN || pos + t.length > MAXLEN) return;
	for(int i = s.length ,j = s.length + t.length ; i >= pos ; j--,i--)
	{
   		s.ch[j] = s.ch[i];
		//cout << "s" << j << " " << s.ch[j] <<" s" << i <<" "<< s.ch[i]<<endl;
	}
   	for(int i = pos,j = 1 ; i < pos + t.length ; j++,i++)
   	{	
	   	s.ch[i] = t.ch[j];
   		//cout << "s" << i << " " << s.ch[i] <<" t" << j <<" "<< t.ch[j]<<endl;
	}
   	s.length = s.length + t.length;
//   	cout << s.length;
//   	for (int i=1;i<=s.length;i++) 
//		cout<<i<<":"<<s.ch[i]<<endl;
	return;
	/***************end *************/
}

int main() 
{	
    SString s,t;
    int pos; 
    InputStr(s);				//输入串s
    cin>>pos;					//输入插入位置 
	InputStr(t);				//输入串t
	InsertStr(s,pos,t);         //调用插入函数 
	OutputStr(s);				//输出串s 
	return 0; 
}

第五章 二叉树

5.1 二叉树的建立和遍历
#include<iostream>
#include<string.h>
using namespace std;

typedef char ElemType;
typedef struct BiTNode
{
	ElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T)
{//先序建立二叉树
/**************begin************/
	char ch;
	cin >> ch;
	if(ch == '#') T = NULL;
	else {
		T = new BiTNode;//T是树的指针 new BiTNode 开辟一个BiTNode的指针
		T->data = ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
	return;
    /**************end************/
}
void PreOrderTraverse(BiTree T)
{//二叉树的先序遍历
/**************begin************/
	if(T){
		cout << T->data ;
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
    /**************end************/
}
void InOrderTraverse(BiTree T)
{//二叉树的中序遍历
/**************begin************/
	if(T){
		InOrderTraverse(T->lchild);
		cout << T->data ;
		InOrderTraverse(T->rchild);
	}
    /**************end************/
}
void PostOrderTraverse(BiTree T)
{//二叉树的后序遍历
/**************begin************/
	if(T){
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		cout << T->data ;
	}
    /**************end************/
}
int main()
{
  	BiTree T;
	CreateBiTree(T);
	PreOrderTraverse(T);
	cout<<endl;
    InOrderTraverse(T);
	cout<<endl;
	PostOrderTraverse(T);
	cout<<endl;
	return 0;
}
5.2 统计分支个数
#include<iostream>
#include<string.h>
using namespace std;

typedef char ElemType;
typedef struct BiTNode
{
	ElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T)
{//先序建立二叉树
	ElemType ch;
	cin>>ch;
	if(ch=='#')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
}
int Count_leaf(BiTree T){
//统计叶子结点的数目
/**************begin************/
	if(!T) return 0;
	else return Count_leaf(T->lchild) + Count_leaf(T->rchild) + (((!T->lchild)&&(!T->rchild))?1:0);

/**************end************/
}


int Count_Sigle(BiTree T) {
//统计单分支结点的数目
/**************begin************/
 	if(!T) return 0;
	return Count_Sigle(T->lchild) + Count_Sigle(T->rchild) + (((!T->lchild)&&(T->rchild))||((T->lchild)&&(!T->rchild))?1:0);

/**************end************/			
}


int Count_Double(BiTree T) {
//统计双分支结点的数目
/**************begin************/	  
	if(!T) return 0;
	return Count_Double(T->lchild) + Count_Double(T->rchild) + (((T->lchild)&&(T->rchild))?1:0);
/**************end************/		
}	
int main()
{
  	BiTree T;
    CreateBiTree(T);
	cout<<Count_leaf(T)<<" "<<Count_Sigle(T)<<" "<<Count_Double(T)<<endl;
	return 0;
}
5.3 高度计算

#include<iostream>
#include <string.h>
using namespace std;

typedef char ElemType;
typedef struct BiTNode
{
	ElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T)
{//先序建立二叉树
	ElemType ch;
	cin>>ch;
	if(ch=='#')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
}
int Depth(BiTree T)
{//二叉树高度的计算
/**************begin************/
	if(!T) return 0;
	else{
		int m = Depth(T->lchild);
		int n = Depth(T->rchild);
		return m > n ? (m+1) : (n+1);
	}
    /**************end************/
}
int main()
{
  	BiTree T;
    CreateBiTree(T);
	cout<<Depth(T)<<endl;
	return 0;
}
5.4 二叉树左右孩子交换

#include<iostream>
#include<cstring>
using namespace std;

typedef char ElemType;
typedef struct BiTNode
{
	ElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T)
{//先序建立二叉树
	ElemType ch;
	cin>>ch;
	if(ch=='#')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
}
void ChangeRL(BiTree &T)
{//二叉树左右孩子的交换
/**************begin************/
	BiTree t;
	if(!T) return;
	else{
		t = T->lchild;
		T->lchild = T->rchild;
		T->rchild = t;
		ChangeRL(T->lchild);
		ChangeRL(T->rchild);
	}

/**************end************/	
}
void PreOrderTraverse(BiTree T)
{//先序遍历
	if(T)
	{
    	cout<<T->data;
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}
int main()
{
    BiTree T;
	CreateBiTree(T);
	ChangeRL(T);
	PreOrderTraverse(T);
	cout<<endl;
	return 0;
}
5.5 两个二叉树的相等判断
#include<iostream>
using namespace std;

typedef char ElemType;
typedef struct BiTNode
{
	ElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T)
{//先序建立二叉树
   ElemType ch;
	cin>>ch;
	if(ch=='#')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}	
}
int Compare(BiTree T1,BiTree T2)
{//判断两棵二叉树是否相等，不相等返回0，相等返回1
/**************begin************/
	if(!T1 && !T2) return true;
	if(!T1 || !T2) return false;
	return T1->data == T2->data && Compare(T1->rchild,T2->rchild) && Compare(T1->lchild,T2->lchild);
/**************end************/		
}
int main()
{
  	BiTree T1,T2;
	CreateBiTree(T1);
	CreateBiTree(T2);
	if(!Compare(T1,T2))
		cout<<"NO"<<endl;
	else
		cout<<"YES"<<endl;
	return 0;
}
5.6 二叉树的层次遍历
#include<iostream>
#include<string.h>
using namespace std;
int flag;
#define OK 1
#define ERROR -1
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef char ElemType;
typedef struct BiTNode
{
	ElemType data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//链队列定义 
typedef BiTree QElemType;
typedef struct QNode {
	QElemType data;
	struct QNode *next;
}QNode,*QueuePtr;
typedef struct {
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;
//队列基本操作
Status InitQueue (LinkQueue &Q){
	//构造一个空队列
	Q.front=Q.rear=new QNode;
	if(!Q.front) return ERROR;
	Q.front->next=NULL;
	return OK;
}
Status QueueEmpty(LinkQueue Q){
//判断Q是否为空, 若为空，则输出TRUE，否则输出FALSE
	if(Q.front==Q.rear)
		return TRUE;
	return FALSE;
}
Status EnQueue(LinkQueue &Q,QElemType e){
	//将元素e入队列
	QueuePtr p;
	p=new QNode;
	if(!p) return ERROR;
	p->data=e;
	p->next=NULL;
	Q.rear->next=p;
	Q.rear=p;
	return OK;
}
Status DeQueue(LinkQueue &Q,QElemType &e){
	   //将元素e出队列
	QueuePtr p;
	if(Q.front==Q.rear)
		return ERROR;
	p=Q.front->next;
	e=p->data;
	Q.front->next=p->next;
	if(Q.rear==p)         
		Q.rear=Q.front;
	delete p;
	return OK;
} 
void CreateBiTree(BiTree &T)
{//先序建立二叉树
	ElemType ch;
	cin>>ch;
	if(ch=='#')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
}
Status LevelOrder(BiTree T)//层次遍历二叉树
{
/**************begin************/
    LinkQueue Q;
    QElemType t;
    InitQueue(Q);
    if(T){
    	EnQueue(Q,T);
    	while(!QueueEmpty(Q)){
    		DeQueue(Q,t);
    		cout << t->data;
    		if(t->lchild) EnQueue(Q,t->lchild);
    		if(t->rchild) EnQueue(Q,t->rchild);
    	}
    }
/**************end************/	
}
int main()
{
	BiTree T;
	CreateBiTree(T);
	LevelOrder(T);
	cout<<endl;
	return 0;
}
5.7 二叉树的WPL计算
#include<iostream>
using namespace std;
typedef struct BiTNode
{
	int weight;
	struct BiTNode *left,*right;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T)
{//先序建立二叉树
	int x;
	cin>>x;
	if(x == 0) T=NULL;
	else
    {
		T=new BiTNode;
		T->weight=x;
		CreateBiTree(T->left);
		CreateBiTree(T->right);
	}
}
int WPL(BiTree &T,int d)
{//求二叉树T的带权路径长度
/**************begin************/
	if(!T) return 0;
	return ((!T->left)&&(!T->right)?T->weight*d:0) + WPL(T->right,d+1) + WPL(T->left,d+1);
    /**************end************/
}
int main()
{
	while(1)
    {
		BiTree T;
		CreateBiTree(T);
		if(!T) break;
		int d=0;          //调用时T指向二叉树的根结点，d为0
		cout<<WPL(T,d)<<endl;
	}
	return 0;
}

第六章 图

6.1 邻接矩阵
6.1.1 建立无向网的邻接矩阵
#include <cstdio>
#include <iostream> 
using namespace std;

#define MaxInt 32767   			  	//最大值
#define MVNum 20    			  	//最大顶点数
typedef  struct { 
   int  vexnum,arcnum;		 	 	//顶点数和边的数目 
   char vexs[MVNum]; 			  	//顶点向量
   int  arcs[MVNum][MVNum];			//邻接矩阵    
}AMGraph;

int LovateVex(AMGraph G,char v){
   int i;  
   for ( i=0; i<G.vexnum; i++)
         if (G.vexs[i]==v) return i;
   return -1;
}
 
void CreateUDN(AMGraph &G)  		//创建无向网的邻接矩阵 
{/****************begin****************/
	cin >> G.vexnum >> G.arcnum;
	for(int i = 0 ; i < G.vexnum ; i++)
		cin >> G.vexs[i];
	for(int i = 0 ; i < G.vexnum ; i++)
		for(int j = 0 ; j < G.vexnum ; j++)
			G.arcs[i][j] = (i == j ? 0 : MaxInt);
	for(int k = 0; k < G.arcnum ; k++){
		char v1, v2;
		int w;
		cin >> v1 >> v2 >> w;
		int i = LovateVex(G,v1), j = LovateVex(G,v2);
		G.arcs[i][j] = w;
		G.arcs[j][i] = w;
	}

 /******************end****************/
}
void PrintGraph(AMGraph G)          //输出图的邻接矩阵	 
{    
	cout<<"图的邻接矩阵：";
  	for (int i=0;i<G.vexnum;i++)
	{	cout<<endl;
		for (int j=0;j<G.vexnum;j++){
			if (G.arcs[i][j]==MaxInt) 
		  		  printf("    ∞");
		  	else 	
		  		  printf("%5d",G.arcs[i][j]);
		}	 
	}
}
int main()
{
  	AMGraph G; 
  	CreateUDN(G);
  	PrintGraph(G); 
 	return 0;   
}
6.1.2 深度优先遍历
#include <iostream> 
using namespace std;

#define MaxInt 32767   			   //最大值
#define MVNum 20    			      //最大顶点数
typedef  struct {
   int  vexnum,arcnum;		 	   //顶点数和弧的数目 
   char vexs[MVNum]; 			   //顶点向量
   int  arcs[MVNum][MVNum];		//邻接矩阵    
}AMGraph;

int LocateVex(AMGraph G,char v){
   int i;  
   for ( i=0; i<G.vexnum; i++)
         if (G.vexs[i]==v) return i;
   return -1;
}
 
void CreateDG(AMGraph &G)
{//创建有向图的邻接矩阵
   /****************begin****************/
	cin >> G.vexnum >> G.arcnum;
	for(int i = 0 ; i < G.vexnum ; i++)
		cin >> G.vexs[i];
	for(int i = 0 ; i < G.vexnum ; i++)
		for(int j = 0 ; j < G.vexnum ; j++)
			G.arcs[i][j] = 0;
	for(int k = 0; k < G.arcnum ; k++){
		char v1, v2;
		cin >> v1 >> v2;
		int i = LocateVex(G,v1), j = LocateVex(G,v2);
		G.arcs[i][j] = 1;
	}
   /****************end*****************/
 }
void PrintGraph(AMGraph G)       //输出图的邻接矩阵	 
{    
	cout<<"有向图的邻接矩阵：";
    for (int i=0;i<G.vexnum;i++)
	{	cout<<endl;
		for (int j=0;j<G.vexnum;j++)
		{
			printf("%5d",G.arcs[i][j]);
		}
		  
	}
}
//深度优先搜索DFS 
bool visited[MVNum];
void DFS(AMGraph G,int v)
{//从顶点v开始对图进行深度优先遍历 
/****************begin****************/
	cout << " " << G.vexs[v] ;
	visited[v] = true;
	for(int i = 0 ; i < G.vexnum ; i ++)
	{
		if(!visited[i] && G.arcs[v][i] != 0) DFS(G,i);
	}
/****************begin****************/
}
void DFSTraverse(AMGraph G)
{//图的深度优先遍历 
/****************begin****************/
  	for(int v = 0 ; v < G.vexnum ; v++) visited[v] = false;
  	for(int v = 0 ; v < G.vexnum ; v ++)
  		if(!visited[v]) {
  			DFS(G,v);
  			cout << endl;
  		}
/****************end ****************/
}

int main()
{
  	AMGraph G; 
  	CreateDG(G);	//建立有向图的邻接矩阵 
  	PrintGraph(G);	//输出图的邻接矩阵 
  	cout<<"\n图的深度优先序列：\n"; 
	DFSTraverse(G);
 	return 0;   
}
6.1.3 prime求最小生成树
#include <cstdio>
#include <iostream> 
using namespace std;
#include "graph.h"		//图的定义、无向网的建立以及输出函数 

typedef struct{
   char adjvex;
   int 	lowcost;
}node;
node closedge[MVNum];	//定义待选边辅助数组 
 
int Min(AMGraph G)
{
    //从待选边辅助数组closeedge中选择最小边closedge[k],返回k
    int k = 0;
    while (closedge[k].lowcost == 0)
        k++;
    int min = closedge[k].lowcost;
    for (int i = k + 1; i < G.vexnum; i++)
    {
        if (closedge[i].lowcost != 0 && closedge[i].lowcost < min)
        {
            min = closedge[i].lowcost;
            k = i;
        }
    }
    return k;
}

int MiniSpanTree(AMGraph G, char u)
{
    //从顶点u出发构造最小生成树T，输出T的各条边，函数返回T的代价
    int uIndex = LocateVex(G, u);
    for (int i = 0; i < G.vexnum; i++)
    {
        if (i != uIndex)
        {
            closedge[i].adjvex = u;
            closedge[i].lowcost = G.arcs[uIndex][i];
        }
    }
    closedge[uIndex].lowcost = 0;
    cout << endl;
    int MSTcost = 0;
    for (int i = 1; i < G.vexnum; i++)
    {
        int k = Min(G);
        cout <<"(" <<closedge[k].adjvex <<"," << G.vexs[k] << ") " << closedge[k].lowcost << endl;
        MSTcost += closedge[k].lowcost;
        closedge[k].lowcost = 0;

        for (int j = 0; j < G.vexnum; j++)
        {
            if (G.arcs[k][j] < closedge[j].lowcost)
            {
                closedge[j].adjvex = G.vexs[k];
                closedge[j].lowcost = G.arcs[k][j];
            }
        }
    }
    return MSTcost;
}

int main()
{
  	AMGraph G;
	char u;
	int MSTcost;
  	CreateUDN(G);					//建立无向网的邻接矩阵
  	cin>>u;							//输入起始顶点
	PrintGraph(G);					//输出无向网 
	cout<<"\n\n最小生成树的边："; 	
  	MSTcost=MiniSpanTree(G,u);		// 从顶点u出发构造最小生成树T
	cout<<"\n最小生成树的代价：\n"<<MSTcost;    	
 	return 0;   
}
6.1.4 Dijkstra算法求解单源点最短路径
#include<bits/stdc++.h>
using namespace std;
#include "graph.h"		//图的定义、 有向网的建立以及输出函数   
	          
void ShortestPath_DIJ(AMGraph G, int v0) {
    vector<int> dist(G.vexnum, MaxInt);
    vector<bool> visited(G.vexnum, false);

    dist[v0] = 0;

    for (int i = 0; i < G.vexnum; ++i) {
        int u = -1;
        for (int j = 0; j < G.vexnum; ++j) {
            if (!visited[j] && (u == -1 || dist[j] < dist[u])) {
                u = j;
            }
        }

        visited[u] = true;

        for (int v = 0; v < G.vexnum; ++v) {
            if (!visited[v] && G.arcs[u][v] != MaxInt) {
                if (dist[u] + G.arcs[u][v] < dist[v]) {
                    dist[v] = dist[u] + G.arcs[u][v];
                }
            }
        }
    }
    vector<tuple<int, int, int>> paths;

    for (int i = 0; i < G.vexnum; ++i) {
        if (i != v0 && dist[i] != MaxInt) {
            paths.push_back(make_tuple(v0, i, dist[i]));
        }
    }

    sort(paths.begin(), paths.end(), [&](const tuple<int, int, int>& a, const tuple<int, int, int>& b) {
        return get<2>(a) < get<2>(b);
    });
    for (const auto& path : paths) {
        cout << G.vexs[get<0>(path)] << "-->" << G.vexs[get<1>(path)] << " " << get<2>(path) << endl;
    }
}


int main()
{
  	AMGraph G; 
  	char u;
  	CreateDN(G);				//建立有向网的邻接矩阵 
  	cin>>u;						//输入源点
  	PrintGraph(G);				//输出有向网的邻接矩阵 
  	int v0=LocateVex(G,u);
  	cout<<"\n从顶点"<<u<<"到图中其他顶点的最短路径：\n" ;
	ShortestPath_DIJ(G,v0); 	//从顶点v0开始，应用dijkstra算法求最短路径 
 	return 0;   
}

6.2 邻接表

6.2.1 图的建立
#include <cstdio>
#include <iostream>
using namespace std;
#define MVNum 20    			//最大顶点数
typedef  struct ArcNode{		//边结点 
    int 	adjvex;				//邻接点的位置 
    struct 	ArcNode *nextarc;	//指向下一条边的指针 
}ArcNode;

typedef struct VNode{			//表头结点（顶点信息） 
    char  data;					//顶点值 
    ArcNode  *firstarc;		//指向第一条依附该顶点的边的指针 
}VNode; 

typedef struct {
  	int vexnum;					//图的顶点数
	int arcnum;					//图的边数 
	VNode vertices[MVNum];   	//顶点向量表 
}ALGraph;						//邻接表 

int LocateVex(ALGraph G,char v)  
{//在顶点向量表中查找顶点v，如果找到，则返回顶点在图中的位置，否则返回-1
   for (int i=0;i<G.vexnum ;i++)
        if ( G.vertices[i].data==v ) return i;
   return -1;
}

void CreateUDG(ALGraph &G)
{//建立无向图的邻接表 , 对每一条边（i,j）,按照头插法，分别将表结点插入i表和j表  
	/******************begin*****************/
	int i,j,k;
	char v1,v2;
	ArcNode *p,*q;
	cin >> G.vexnum >> G.arcnum;
	for(i = 0 ; i < G.vexnum ; i ++)
	{
		cin >> G.vertices[i].data;
		G.vertices[i].firstarc = NULL;	
	}
	for(k = 0 ; k < G.arcnum ; k ++)
	{
		cin >> v1 >> v2;
		i = LocateVex(G,v1);
		j = LocateVex(G,v2);
		p = new ArcNode;
		p->adjvex = j;
		p->nextarc = G.vertices[i].firstarc;
		G.vertices[i].firstarc = p;
		q = new ArcNode;
		q->adjvex = i;
		q->nextarc = G.vertices[j].firstarc;
		G.vertices[j].firstarc = q;
	}
   /******************end ******************/
}
void PrintGraph(ALGraph G)				//输出图中每个点的邻接点 
{
    ArcNode *p;	    
	for (int i=0;i<G.vexnum;i++)
	{
		printf("\n%2c邻接到：",G.vertices[i].data);
		for (p=G.vertices[i].firstarc; p ;p=p->nextarc)
		{
			int j=p->adjvex;
			printf("%2c",G.vertices[j].data);
		}		
	}
}
int main()
{	ALGraph G;
  	CreateUDG(G);				//建立无向图的邻接表 
  	PrintGraph(G);				//输出图的邻接表	 
    return 0;   	
}
6.2.2 计算顶点的出度和入度
#include <cstdio>
#include <iostream>
using namespace std;
#define MVNum 20    			//最大顶点数
typedef  struct ArcNode{		//边结点 
    int 	adjvex;				//邻接点的位置 
    struct 	ArcNode *nextarc;	//指向下一条边的指针 
}ArcNode;

typedef struct VNode{			//表头结点（顶点信息） 
    char  data;					//顶点值 
    ArcNode     *firstarc;		//指向第一条依附该顶点的边的指针 
}VNode; 

typedef struct {
  	int vexnum;					//图的顶点数
	int arcnum;					//图的边数 
	VNode vertices[MVNum];   	//顶点向量表 
}ALGraph;						//邻接表 

int LocateVex(ALGraph G,char v)  
{//在顶点向量表中查找顶点v，如果找到，则返回顶点在图中的位置，否则返回-1
   for (int i=0;i<G.vexnum ;i++)
        if ( G.vertices[i].data==v ) return i;
   return -1;
}

void CreateDG(ALGraph &G)
{//建立有向图的邻接表 , 对每一条边<i,j>,按照头插法，分别将表结点插入i表  
	int i,j,k;
    char v1,v2;
	ArcNode *p;
	cin>>G.vexnum>>G.arcnum;			//输入图的顶点数和边数
    for (i=0;i<G.vexnum;i++) 			//初始化顶点向量表 
	{
		cin>>G.vertices[i].data;		//输入顶点信息 
		G.vertices[i].firstarc=NULL;	//初始化每个顶点的邻接表 
	}
    
    for (k=0;k<G.arcnum;k++) 			//依次输入图的每条边
	{			
        cin>>v1>>v2;
		i=LocateVex(G,v1);  
		j=LocateVex(G,v2); 
		p=new ArcNode;
		p->adjvex=j;
		p->nextarc=G.vertices[i].firstarc;
        G.vertices[i].firstarc=p;	        			
	}
}
void PrintGraph(ALGraph G)				//输出图中每个点的邻接点 
{
    ArcNode *p;	    
	for (int i=0;i<G.vexnum;i++)
	{
		printf("\n%2c邻接到：",G.vertices[i].data);
		for (p=G.vertices[i].firstarc; p ;p=p->nextarc)
		{
			int j=p->adjvex;
			printf("%2c",G.vertices[j].data);
		}		
	}
}
void FindOutdegree(ALGraph G,int outdegree[])
{ 	//计算每个顶点的出度，存入数组outdegree 
	/******************begin*****************/
   for(int i = 0 ; i < G.vexnum ; i++){
   	outdegree[i] = 0;
   	ArcNode *p = G.vertices[i].firstarc;
   	while(p){
   		outdegree[i]++;
   		p = p->nextarc;
   	}
   }
	/******************end *****************/   
}
void FindIndegree(ALGraph G,int indegree[])
{	//计算每个顶点的入度，存入数组indegree
   /******************begin*****************/
   for(int i = 0 ; i < G.vexnum ; i++){
   	indegree[i] = 0;
   	for(int j = 0 ; j < G.vexnum ; j++)
   	{
   		ArcNode *p = G.vertices[j].firstarc;
   		while(p){
   			if(p->adjvex == i){
   				indegree[i]++;
   				break;
   			}
   			p = p->nextarc;
   		}
   	}
   }
   /******************end *****************/
}

int main()
{	ALGraph G;
	int indegree[MVNum],outdegree[MVNum]; 
  	CreateDG(G);				//建立有向图的邻接表 
  	PrintGraph(G);				//输出图的邻接表
  	FindOutdegree(G,outdegree);	//计算每个顶点的出度 
  	cout<<"\n 顶点的出度：";
	for (int i=0;i<G.vexnum;i++) 
  		printf("%2d",outdegree[i]);
  	FindIndegree(G,indegree);	//计算每个顶点的入度 
	cout<<"\n 顶点的入度：";	
  	for (int i=0;i<G.vexnum;i++) 
  		printf("%2d",indegree[i]) ;		
	return 0;   	
}
6.2.3 图的广度优先遍历
#include <cstdio>
#include <iostream>
using namespace std;
#define  OK 1
#define  ERROR 0 
#define  OVERFLOW -1
typedef int Status;
typedef int QElemType;
#define MAX_QSIZE 5 // 最大队列长度+1
 //循环队列的定义以及基本算法（初始化、入队、出队、判队空）
struct SqQueue
{
   QElemType *base; // 初始化的动态分配存储空间
   int front; // 头指针，若队列不空，指向队列头元素
   int rear; // 尾指针，若队列不空，指向队列尾元素的下一个位置
};            
// 循环队列的基本操作(9个)
Status InitQueue(SqQueue &Q)
{ // 构造一个空队列Q
   /********** Begin **********/ 
	Q.base = new QElemType[MAX_QSIZE];
	if(!Q.base) return ERROR;
	Q.front = Q.rear = 0;
	return OK;
	/********** End **********/  
}
Status QueueEmpty(SqQueue Q)
{ // 若队列Q为空队列，则返回TRUE；否则返回FALSE
   /********** Begin **********/ 
 	return (Q.front == Q.rear);
	/********** End **********/  
}
Status EnQueue(SqQueue &Q,QElemType e)
{ // 插入元素e为Q的新的队尾元素
   /********** Begin **********/ 
 	if((Q.rear+1)%MAX_QSIZE == Q.front) return ERROR;
 	Q.base[Q.rear] = e;
 	Q.rear = (Q.rear + 1)%MAX_QSIZE;
 	//cout << endl << "Q.front=" << Q.front << " " <<"Q.rear="<<Q.rear<< endl;
 	return OK;
	/********** End **********/  
 }
Status DeQueue(SqQueue &Q,QElemType &e)
{ // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR
   /********** Begin **********/ 
	if(Q.front == Q.rear) return ERROR;
	e = Q.base[Q.front];
	Q.front = (Q.front+1)%MAX_QSIZE;
	
	/********** End **********/  
}
#define MVNum 20    			//最大顶点数
typedef  struct ArcNode{		//边结点 
    int 	adjvex;				//邻接点的位置 
    struct 	ArcNode *nextarc;	//指向下一条边的指针 
}ArcNode;

typedef struct VNode{			//表头结点（顶点信息） 
    char  data;					//顶点值 
    ArcNode     *firstarc;		//指向第一条依附该顶点的边的指针 
}VNode; 

typedef struct {
  	int vexnum;					//图的顶点数
	int arcnum;					//图的边数 
	VNode vertices[MVNum];   	//顶点向量表 
}ALGraph;						//邻接表 

int LocateVex(ALGraph G,char v)  
{//在顶点向量表中查找顶点v，如果找到，则返回顶点在图中的位置，否则返回-1
   for (int i=0;i<G.vexnum ;i++)
        if ( G.vertices[i].data==v ) return i;
   return -1;
}

void CreateUDG(ALGraph &G)
{//建立无向图的邻接表 , 对每一条边（i,j）,按照头插法，分别将表结点插入i表和j表  
	int i,j,k;
    char v1,v2;
	ArcNode *p,*q;
	cin>>G.vexnum>>G.arcnum;			//输入图的顶点数和边数
    for (i=0;i<G.vexnum;i++) 			//初始化顶点向量表 
	{
		cin>>G.vertices[i].data;		//输入顶点信息 
		G.vertices[i].firstarc=NULL;	//初始化每个顶点的邻接表 
	}
    
    for (k=0;k<G.arcnum;k++) 			//依次输入图的每条边
	{			
        cin>>v1>>v2;
		i=LocateVex(G,v1);  
		j=LocateVex(G,v2); 
		p=new ArcNode;
		p->adjvex=j;
		p->nextarc=G.vertices[i].firstarc;
        G.vertices[i].firstarc=p;
		q=new ArcNode;
		q->adjvex=i;
		q->nextarc=G.vertices[j].firstarc;
        G.vertices[j].firstarc=q;              			
	}
}
void PrintGraph(ALGraph G)				//输出图中每个点的邻接点 
{
    ArcNode *p;	    
	for (int i=0;i<G.vexnum;i++)
	{
		printf("\n%2c邻接到：",G.vertices[i].data);
		for (p=G.vertices[i].firstarc; p ;p=p->nextarc)
		{
			int j=p->adjvex;
			printf("%2c",G.vertices[j].data);
		}		
	}
}
bool visited[MVNum];			//定义访问标记数组 
void BFS(ALGraph G,int v)
{	//从顶点v出发，对图进行广度优先遍历
	SqQueue Q;					//定义队列Q
    InitQueue(Q);				//将队列Q初始化为空队列
 	/******************begin*****************/
	cout << ' ' << G.vertices[v].data;//访问节点
	EnQueue(Q,v);//节点入队
	visited[v] = true;//标记

	while(!QueueEmpty(Q)){
		DeQueue(Q,v);
		ArcNode *p = G.vertices[v].firstarc;
        //遍历v的所有出边
		while(p){
			int u = p->adjvex;
			if(!visited[u]){
                //如果没有遍历过 就输出 入队
				cout << ' ' << G.vertices[u].data;
				visited[u] = true;
				EnQueue(Q,u);
			}
			p = p->nextarc;
		}
	}
 	/******************end******************/
}//BFS

void BFSTraverse(ALGraph G){
   int v;
   for (v=0;v<G.vexnum;v++) 	//初始化每个顶点的访问标记为false
   		visited[v]=false;  
   for (v=0;v<G.vexnum;v++)
   {      
        if (!visited[v]) 		
		{ 
		   	cout<<endl;
        	BFS(G,v);			//对未访问的顶点v，调用BFS，进行广度优先搜索
		}
   }
	   
}//BFSTraverse

int main()
{	ALGraph G;	
  	CreateUDG(G);				//建立无向图的邻接表
	PrintGraph(G);				//输出图的邻接表
	cout<<"\n 图的广度优先序列：";	 
    BFSTraverse(G);				//广度优先遍历	
	return 0;   	
}
6.2.4 AOV网的拓扑排序
#include <cstdio>
#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int Status;
#include "stack.h"//顺序栈的定义和基本函数的定义 
#include "graph.h"//图的邻接表定义，以及图的建立
 
void FindIndegree(ALGraph G, int indegree[])
{ //计算每个顶点的入度，存入数组indegree
    for (int i = 0; i < G.vexnum; i++)
        indegree[i] = 0;

    for (int i = 0; i < G.vexnum; i++)
    {
        ArcNode *p = G.vertices[i].firstarc;
        while (p)
        {
            int j = p->adjvex;
            indegree[j]++;
            p = p->nextarc;
        }
    }
}

Status TopologicalSort(ALGraph G, int topo[])
{ 
    int indegree[MVNum];
    SqStack S;
    InitStack(S);

    FindIndegree(G, indegree);

    for (int i = 0; i < G.vexnum; i++)
    {
        if (indegree[i] == 0)
        {
            Push(S, i); 
        }
    }

    int count = 0;
    while (!StackEmpty(S))
    {
        Pop(S, topo[count++]); 
        ArcNode *p = G.vertices[topo[count - 1]].firstarc;
        while (p)
        {
       
            indegree[p->adjvex]--;
            if (indegree[p->adjvex] == 0)
            {
                Push(S, p->adjvex); 
            }
            p = p->nextarc;
        }
    }

    if (count != G.vexnum)
    {
        return ERROR;
    }

    return OK;
}
int main()
{	ALGraph G;
	int topo[MVNum];
	CreateDG(G);							//建立有向图的邻接表 
	PrintGraph(G);							//输出图的邻接表 
  	if (TopologicalSort(G,topo)==ERROR) 		//拓扑排序
		cout<<"\n 图中有环，拓扑排序失败！";
	else{
		cout<<"\n 拓扑序列：";
		for (int i=0;i<G.vexnum;i++)
		 	printf("%2c",G.vertices[topo[i]].data);
	} 
			
	return 0;   	
}

第七章 查找

7.1 顺序查找
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*************************************************************
    顺序查找  头文件   
**************************************************************/
#define MAXSIZE 100
typedef int KeyType; /*关键字类型*/
typedef struct
{
    KeyType  key;
    /*InfoType  otherinfo;*/
}RedType; /*记录类型*/
typedef struct
{
    RedType  r[MAXSIZE+1];  /*r[0]闲置或用作"监视哨"*/
    int  length;
}SSTable; /*静态查找表的类型定义*/

/*******函数声明*******/
void SSTableInput(SSTable &L); /*输入若干记录的关键字，存放到静态查找表L中*/
void SSTableOutput(SSTable L); /*输出静态查找表L中各记录的关键字*/
int Search_Seq(SSTable L, KeyType key);  /*顺序查找*/
/*************************************************************
    顺序查找  实现文件    
**************************************************************/
int Search_Seq(SSTable L, KeyType key) 
{
    for (int i = 1; i <= L.length; i++) {
        if (L.r[i].key == key) {
            return i;
        }
    }
    return 0;
}
void SSTableInput(SSTable &L) /*输入若干记录的关键字，存放到静态查找表L中*/
{
    int i=1; KeyType x;
    scanf("%d",&x);
    while(x!=-1)
    {
        L.r[i++].key=x; scanf("%d",&x);
    }
    L.length=i-1;
}
void SSTableOutput(SSTable L) /*输出静态查找表L中各记录的关键字*/
{
    int i;
    for(i=1;i<=L.length;i++)
        printf("%d ",L.r[i].key);
    printf("\n");
}



int main()
{
    SSTable L; KeyType x;int loc;
    SSTableInput(L);/*输入一组记录的关键字，存放到静态查找表L中*/
    scanf("%d",&x);  /*输入待查找的关键字*/
    SSTableOutput(L);/*输出静态查找表L中各记录的关键字*/
    loc=Search_Seq(L,x);/*采用顺序查找法，在表L中查找其关键字等于x的记录，并返回该记录在表中的位置*/
    if(loc==0) printf("not find!\n");
    else printf("%d\n",loc);/*输出关键字等于x的记录在表中的位置*/
    return 0;
}
7.2 折半查找
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*************************************************************
    折半查找  头文件
**************************************************************/
#define MAXSIZE 100
typedef int KeyType; /*关键字类型*/
typedef struct
{
    KeyType  key;
    /*InfoType  otherinfo;*/
}RedType; /*记录类型*/
typedef struct
{
    RedType  r[MAXSIZE+1];  /*r[0]闲置或用作"监视哨"*/
    int  length;
}SSTable; /*静态查找表的类型定义*/

/*******函数声明*******/
void SSTableInput(SSTable &L); /*输入若干记录的关键字，存放到静态查找表L中*/
void SSTableOutput(SSTable L); /*输出静态查找表L中各记录的关键字*/
int Search_Bin(SSTable L, KeyType key);  /*折半查找*/
/*************************************************************
    折半查找  实现文件  
**************************************************************/
int Search_Bin(SSTable L, KeyType key)/*在递增有序的顺序表L中折半查找其关键字等于key的记录*/
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int low = 1;
    int high = L.length;

    while (low <= high) {
        int mid = (low + high) / 2;
        if (L.r[mid].key == key) {
            return mid; 
        } else if (L.r[mid].key < key) {
            low = mid + 1; 
        } else {
            high = mid - 1; 
        }
    }
    return 0;   
    /********** End **********/
}
void SSTableInput(SSTable &L) /*输入若干记录的关键字，存放到静态查找表L中*/
{
    int i=1; KeyType x;
    scanf("%d",&x);
    while(x!=-1)
    {
        L.r[i++].key=x; scanf("%d",&x);
    }
    L.length=i-1;
}
void SSTableOutput(SSTable L) /*输出静态查找表L中各记录的关键字*/
{
    int i;
    for(i=1;i<=L.length;i++)
        printf("%d ",L.r[i].key);
    printf("\n");
}
int main()
{
    SSTable L; KeyType x;int loc;
    SSTableInput(L);/*按递增或递减的顺序输入一组记录的关键字，存放到静态查找表L中*/
    scanf("%d",&x);  /*输入待查找的关键字*/
    SSTableOutput(L);/*输出静态查找表L中各记录的关键字*/
    loc=Search_Bin(L,x);/*采用折半查找法，在表L中查找其关键字等于x的记录，并返回该记录在表中的位置*/
    if(loc==0) printf("not find!\n");
    else printf("%d\n",loc);/*输出关键字等于x的记录在表中的位置*/
    return 0;
}
7.3 二叉排序树的查找
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*************************************************************
    二叉排序树的查找  头文件
**************************************************************/
#define MAXSIZE 100
typedef int KeyType; /*关键字类型*/
typedef struct
{
    KeyType  key;
    /*InfoType  otherinfo;*/
}RedType; /*记录类型*/

typedef struct BiTNode
{
    RedType  data;
    struct BiTNode  *lchild,*rchild;
}BiTNode, *BiTree; /*动态查找表的二叉链表存储表示*/

/*******函数声明*******/
BiTree Search_BST(BiTree T, KeyType key, BiTree &parent); /*二叉排序树的查找*/
void Insert_BST(BiTree &T, RedType r); /*二叉排序树的插入*/
void Create_BST(BiTree &T); /*二叉排序树的构造*/
void PreOrder(BiTree bt); /*先序遍历*/
void InOrder(BiTree bt); /*中序遍历*/
/*************************************************************
    二叉排序树的查找  实现文件
**************************************************************/
BiTree Search_BST(BiTree T, KeyType key, BiTree &parent)
{
    BiTree p = T;
    parent = NULL;

    while (p != NULL && p->data.key != key)
    {
        parent = p;
        if (key < p->data.key)
            p = p->lchild;
        else
            p = p->rchild;
    }

    return p;
}
void Insert_BST(BiTree &T, RedType r)/*若二叉排序树T中没有关键字为r.key的记录，则插入*/
{
    BiTree p,q,parent;
    parent=NULL;
    p=Search_BST(T,r.key,parent); /*查找*/
    if(p) printf("BST中有结点r，无需插入\n");
    else
    {
        p=parent;
        q=(BiTNode *)malloc(sizeof(BiTNode)); q->data=r; q->lchild=q->rchild=NULL;
        if(T==NULL) T=q; /*若T为空，则q为新的根*/
        else if(r.key<p->data.key) p->lchild=q;
        else p->rchild=q;
    }
}
void Create_BST(BiTree &T ) /*二叉排序树的构造*/
{/*输入若干记录的关键字（以-1标志结束），生成一棵BST，采用二叉链表存储，返回其根指针T*/
    RedType r;
    T=NULL; /*建空树*/
    scanf("%d",&r.key);
    while(r.key!=-1)
    {
        Insert_BST(T, r);
        scanf("%d",&r.key);
    }
}
void PreOrder(BiTree bt) /*先序遍历*/
{
    if(bt)
    {
        printf("%d ",bt->data.key);
        PreOrder(bt->lchild);
        PreOrder(bt->rchild);
    }
}
void InOrder(BiTree bt) /*中序遍历*/
{
    if(bt)
    {
        InOrder(bt->lchild);
        printf("%d ",bt->data.key);
        InOrder(bt->rchild);
    }
}


int main()
{
    BiTree T; KeyType x;BiTree parent,loc;
    Create_BST(T);/*输入一组记录的关键字，存入二叉排序树T中，即建立一棵二叉排序树T*/
    scanf("%d",&x);  /*输入待查找的关键字*/
    printf("PreOrder:");
    PreOrder(T);printf("\n");/*对二叉排序树T进行先序遍历*/
    printf("InOrder:");
    InOrder(T);printf("\n"); /*对二叉排序树T进行中序遍历*/
    loc=Search_BST(T,x,parent); /*在二叉排序树T上查找其关键字等于x的记录结点。若找到，返回该结点指针，parent指向其双亲。*/
    if(loc==NULL) printf("not find!\n");
    else printf("%d\n",parent->data.key);/*输出关键字等于x的结点的双亲结点的关键字*/
    return 0;
}

第八章 排序

8.1 直接插入排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*************************************************************
    直接插入排序  头文件   
**************************************************************/
#define MAXSIZE 100
typedef int KeyType; /*关键字类型*/
typedef struct
{
    KeyType  key;
    /*InfoType  otherinfo;*/
}RedType; /*记录类型*/
typedef struct
{
    RedType  r[MAXSIZE+1];  /*r[0]闲置或用作"监视哨"*/
    int  length; /*length存放表长*/
}SeqList; /*顺序表类型*/

/*******函数声明*******/
void SeqListInput(SeqList &L); /*输入若干记录的关键字，存放到顺序表L中*/
void SeqListOutput(SeqList L); /*输出顺序表L中各记录的关键字*/
void InsertSort(SeqList  &L); /*直接插入排序*/
void ShellInsert(SeqList &L, int d); /*对顺序表L作一趟增量为d的希尔插入排序*/
void ShellSort(SeqList &L); /*希尔排序*/
void QuickSort(SeqList &L, int low, int high); /*对顺序表L的子序列L.r[low…high]作快速排序*/
void HeapAdjust(SeqList &L, int low, int high);/*调整L.r[low].key，使L.r[low..high]成为一个新大顶堆。*/
void HeapSort(SeqList &L); /*堆排序*/
/*************************************************************
    直接插入排序  实现文件  
**************************************************************/
void InsertSort(SeqList &L) /*直接插入排序*/
{
    int i, j;
    for (i = 2; i <= L.length; i++)
    {
        RedType temp = L.r[i];
        j = i - 1;
        while (j > 0 && temp.key < L.r[j].key)
        {
            L.r[j + 1] = L.r[j];
            j--;
        }
        L.r[j + 1] = temp;

        if(i <= 4)
        for (int k = 1; k <= L.length; k++)
        {
            printf("%d ", L.r[k].key);
        }
        if(i <= 4) printf("\n");
    }
}
void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
    int i=1; KeyType x;
    scanf("%d",&x);
    while(x!=-1)
    {
        L.r[i++].key=x; scanf("%d",&x);
    }
    L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
    int i;
    for(i=1;i<=L.length;i++)
        printf("%d ",L.r[i].key);
    printf("\n");
}
int main()
{
    SeqList L;
    SeqListInput(L);/*输入一组记录的关键字，存放到顺序表L中*/
    //SeqListOutput(L);/*输出排序之前的关键字序列*/
    InsertSort(L); /*进行直接插入排序*/
    SeqListOutput(L);/*输出排序之后的关键字序列*/
    return 0;
}
8.2 希尔排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*************************************************************
    希尔排序  头文件  
**************************************************************/
#define MAXSIZE 100
typedef int KeyType; /*关键字类型*/
typedef struct
{
    KeyType  key;
    /*InfoType  otherinfo;*/
}RedType; /*记录类型*/
typedef struct
{
    RedType  r[MAXSIZE+1];  /*r[0]闲置或用作"监视哨"*/
    int  length; /*length存放表长*/
}SeqList; /*顺序表类型*/

/*******函数声明*******/
void SeqListInput(SeqList &L); /*输入若干记录的关键字，存放到顺序表L中*/
void SeqListOutput(SeqList L); /*输出顺序表L中各记录的关键字*/
void InsertSort(SeqList  &L); /*直接插入排序*/
void ShellInsert(SeqList &L, int d); /*对顺序表L作一趟增量为d的希尔插入排序*/
void ShellSort(SeqList &L); /*希尔排序*/
void QuickSort(SeqList &L, int low, int high); /*对顺序表L的子序列L.r[low…high]作快速排序*/
void HeapAdjust(SeqList &L, int low, int high);/*调整L.r[low].key，使L.r[low..high]成为一个新大顶堆。*/
void HeapSort(SeqList &L); /*堆排序*/
/*************************************************************
    希尔排序  实现文件    
**************************************************************/
void ShellInsert(SeqList &L, int d)
{
    for (int i = d + 1; i <= L.length; i++)
    {
        if (L.r[i].key < L.r[i - d].key)
        {
            L.r[0] = L.r[i]; // 备份待插入的记录
            int j;
            for (j = i - d; j > 0 && L.r[0].key < L.r[j].key; j -= d)
            {
                L.r[j + d] = L.r[j];
            }
            L.r[j + d] = L.r[0]; // 插入到正确位置
        }
    }
}
void ShellSort(SeqList &L) /*希尔排序*/
{
    int d;
    d=L.length/2;
    while(d!=0)  /*调用一趟增量为d的希尔插入排序*/
    {
        ShellInsert(L,d); d=d/2;
    }
}
void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
    int i=1; KeyType x;
    scanf("%d",&x);
    while(x!=-1)
    {
        L.r[i++].key=x; scanf("%d",&x);
    }
    L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
    int i;
    for(i=1;i<=L.length;i++)
        printf("%d ",L.r[i].key);
    printf("\n");
}
int main()
{
    SeqList L;
    SeqListInput(L);/*输入一组记录的关键字，存放到顺序表L中*/
    SeqListOutput(L);/*输出排序之前的关键字序列*/
    ShellSort(L); /*进行希尔排序*/
    SeqListOutput(L);/*输出排序之后的关键字序列*/
    return 0;
}
8.3 快速排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*************************************************************
    快速排序  头文件    
**************************************************************/
#define MAXSIZE 100
typedef int KeyType; /*关键字类型*/
typedef struct
{
    KeyType  key;
    /*InfoType  otherinfo;*/
}RedType; /*记录类型*/
typedef struct
{
    RedType  r[MAXSIZE+1];  /*r[0]闲置或用作"监视哨"*/
    int  length; /*length存放表长*/
}SeqList; /*顺序表类型*/

/*******函数声明*******/
void SeqListInput(SeqList &L); /*输入若干记录的关键字，存放到顺序表L中*/
void SeqListOutput(SeqList L); /*输出顺序表L中各记录的关键字*/
void InsertSort(SeqList  &L); /*直接插入排序*/
void ShellInsert(SeqList &L, int d); /*对顺序表L作一趟增量为d的希尔插入排序*/
void ShellSort(SeqList &L); /*希尔排序*/
void QuickSort(SeqList &L, int low, int high); /*对顺序表L的子序列L.r[low…high]作快速排序*/
void HeapAdjust(SeqList &L, int low, int high);/*调整L.r[low].key，使L.r[low..high]成为一个新大顶堆。*/
void HeapSort(SeqList &L); /*堆排序*/
/*************************************************************
    快速排序  实现文件    
**************************************************************/
void QuickSort(SeqList &L, int low, int high)
{
    if (low < high)
    {
        int i = low, j = high;
        L.r[0] = L.r[low]; // 设置基准
        while (i < j)
        {
            while (i < j && L.r[j].key >= L.r[0].key)
                j--;
            if (i < j)
                L.r[i++] = L.r[j];
            while (i < j && L.r[i].key <= L.r[0].key)
                i++;
            if (i < j)
                L.r[j--] = L.r[i];
        }
        L.r[i] = L.r[0]; // 基准归位

        QuickSort(L,low,i-1);/*对左半区L.r[low..i-1]进行快速排序*/
        QuickSort(L,i+1,high);/*对右半区L.r[i+1..high]进行快速排序*/
    }
}
void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
    int i=1; KeyType x;
    scanf("%d",&x);
    while(x!=-1)
    {
        L.r[i++].key=x; scanf("%d",&x);
    }
    L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
    int i;
    for(i=1;i<=L.length;i++)
        printf("%d ",L.r[i].key);
    printf("\n");
}



int main()
{
    SeqList L;
    SeqListInput(L);/*输入一组记录的关键字，存放到顺序表L中*/
    SeqListOutput(L);/*输出排序之前的关键字序列*/
    QuickSort(L,1,L.length); /*进行快速排序*/
    SeqListOutput(L);/*输出排序之后的关键字序列*/
    return 0;
}
8.4 堆排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*************************************************************
    堆排序  头文件    
**************************************************************/
#define MAXSIZE 100
typedef int KeyType; /*关键字类型*/
typedef struct
{
    KeyType  key;
    /*InfoType  otherinfo;*/
}RedType; /*记录类型*/
typedef struct
{
    RedType  r[MAXSIZE+1];  /*r[0]闲置或用作"监视哨"*/
    int  length; /*length存放表长*/
}SeqList; /*顺序表类型*/

/*******函数声明*******/
void SeqListInput(SeqList &L); /*输入若干记录的关键字，存放到顺序表L中*/
void SeqListOutput(SeqList L); /*输出顺序表L中各记录的关键字*/
void InsertSort(SeqList  &L); /*直接插入排序*/
void ShellInsert(SeqList &L, int d); /*对顺序表L作一趟增量为d的希尔插入排序*/
void ShellSort(SeqList &L); /*希尔排序*/
void QuickSort(SeqList &L, int low, int high); /*对顺序表L的子序列L.r[low…high]作快速排序*/
void HeapAdjust(SeqList &L, int low, int high);/*调整L.r[low].key，使L.r[low..high]成为一个新大顶堆。*/
void HeapSort(SeqList &L); /*堆排序*/
/*************************************************************
    堆排序  实现文件    
**************************************************************/  
void HeapAdjust(SeqList &L, int low, int high)
{
    int i = low, j = 2 * i; // 初始化，j指向左孩子
    L.r[0] = L.r[low];      // 记录调整前的堆顶元素

    while (j <= high)
    {
        // 比较左右孩子大小，将j指向较大的孩子
        if (j < high && L.r[j].key < L.r[j + 1].key)
            j++;
        
        // 比较堆顶元素和较大孩子的大小
        if (L.r[0].key < L.r[j].key)
        {
            L.r[i] = L.r[j]; // 将较大孩子上移
            i = j;           // 更新i为新的调整位置
            j = 2 * i;        // 更新j为左孩子
        }
        else
        {
            break; // 调整结束
        }
    }

    L.r[i] = L.r[0]; // 将堆顶元素放入最终位置
}
void HeapSort(SeqList &L) /*堆排序*/
{
    int i;
    for(i=L.length/2;i>0;i--)/*从最后一个分支结点(编号为L.length/2)开始调整，建立初始堆*/
        HeapAdjust(L,i,L.length);
    for(i=L.length;i>1;i--)
    {
        L.r[0]=L.r[1];L.r[1]=L.r[i];L.r[i]=L.r[0];/*将堆顶L.r[1]和当前最后一个记录L.r[i]交换*/
        HeapAdjust(L,1,i-1);/*将剩余记录L.r[1..i-1]重新调整为堆*/
    }
}
void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
    int i=1; KeyType x;
    scanf("%d",&x);
    while(x!=-1)
    {
        L.r[i++].key=x; scanf("%d",&x);
    }
    L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
    int i;
    for(i=1;i<=L.length;i++)
        printf("%d ",L.r[i].key);
    printf("\n");
}
int main()
{
    SeqList L;
    SeqListInput(L);/*输入一组记录的关键字，存放到顺序表L中*/
    SeqListOutput(L);/*输出排序之前的关键字序列*/
    HeapSort(L);  /*进行堆排序*/
    SeqListOutput(L);/*输出排序之后的关键字序列*/
    return 0;
}
8.5 冒泡排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*************************************************************
    冒泡排序  头文件   
**************************************************************/
#define MAXSIZE 100
typedef int KeyType; /*关键字类型*/
typedef struct
{
    KeyType  key;
    /*InfoType  otherinfo;*/
}RedType; /*记录类型*/
typedef struct
{
    RedType  r[MAXSIZE+1];  /*r[0]闲置或用作"监视哨"*/
    int  length; /*length存放表长*/
}SeqList; /*顺序表类型*/

/*******函数声明*******/
void SeqListInput(SeqList &L); /*输入若干记录的关键字，存放到顺序表L中*/
void SeqListOutput(SeqList L); /*输出顺序表L中各记录的关键字*/
void BubbleSort(SeqList  &L); /*冒泡排序*/
/*************************************************************
    冒泡排序  实现文件  
**************************************************************/  
void BubbleSort(SeqList  &L) 
{
    int i, j;
    for (i = 1; i <= L.length - 1; i++)
    {
        // 输出前三趟排序后的关键字序列
        if (i <= 4 && i >= 2)
        {
            for (j = 1; j <= L.length; j++)
                printf("%d ", L.r[j].key);
            printf("\n");
        }

        for (j = 1; j <= L.length - i; j++)
        {
            // 请在这里补充代码，完成本关任务
            /********** Begin *********/
            if (L.r[j].key > L.r[j + 1].key)
            {
                // 交换两个元素
                RedType temp = L.r[j];
                L.r[j] = L.r[j + 1];
                L.r[j + 1] = temp;
            }
            /********** End **********/
        }
    }
}

void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
    int i=1; KeyType x;
    scanf("%d",&x);
    while(x!=-1)
    {
        L.r[i++].key=x; scanf("%d",&x);
    }
    L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
    int i;
    for(i=1;i<=L.length;i++)
        printf("%d ",L.r[i].key);
    printf("\n");
}


int main()
{
    SeqList L;
    SeqListInput(L);/*输入一组记录的关键字，存放到顺序表L中*/
    BubbleSort(L); /*进行冒泡排序*/
    SeqListOutput(L);/*输出排序之后的关键字序列*/
    return 0;
}
8.6 选择排序
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*************************************************************
    选择排序  头文件   
**************************************************************/
#define MAXSIZE 100
typedef int KeyType; /*关键字类型*/
typedef struct
{
    KeyType  key;
    /*InfoType  otherinfo;*/
}RedType; /*记录类型*/
typedef struct
{
    RedType  r[MAXSIZE+1];  /*r[0]闲置或用作"监视哨"*/
    int  length; /*length存放表长*/
}SeqList; /*顺序表类型*/

/*******函数声明*******/
void SeqListInput(SeqList &L); /*输入若干记录的关键字，存放到顺序表L中*/
void SeqListOutput(SeqList L); /*输出顺序表L中各记录的关键字*/
void SelectSort(SeqList  &L); /*选择排序*/
/*************************************************************
    选择排序  实现文件  
**************************************************************/  
void SelectSort(SeqList &L)
{
    int i, j, minIndex;
    for (i = 1; i <= L.length - 1; i++)
    {
        // 输出前三趟排序后的关键字序列
        if (i <= 4 && i>=2)
        {
            for (j = 1; j <= L.length; j++)
                printf("%d ", L.r[j].key);
            printf("\n");
        }

        minIndex = i;
        for (j = i + 1; j <= L.length; j++)
        {
            // 请在这里补充代码，完成本关任务
            /********** Begin *********/
            if (L.r[j].key < L.r[minIndex].key)
                minIndex = j;
            /********** End **********/
        }

        // 交换位置
        if (minIndex != i)
        {
            RedType temp = L.r[i];
            L.r[i] = L.r[minIndex];
            L.r[minIndex] = temp;
        }
    }

    
}
void SeqListInput(SeqList &L) /*输入若干记录的关键字，存放到顺序表L中*/
{
    int i=1; KeyType x;
    scanf("%d",&x);
    while(x!=-1)
    {
        L.r[i++].key=x; scanf("%d",&x);
    }
    L.length=i-1;
}
void SeqListOutput(SeqList L) /*输出顺序表L中各记录的关键字*/
{
    int i;
    for(i=1;i<=L.length;i++)
        printf("%d ",L.r[i].key);
    printf("\n");
}


int main()
{
    SeqList L;
    SeqListInput(L);/*输入一组记录的关键字，存放到顺序表L中*/
    SelectSort(L); /*进行选择排序*/
    SeqListOutput(L);/*输出排序之后的关键字序列*/
    return 0;
}
XUE_DING_E
关注
数据结构期末复习-线性表查找
小白不白
12-26 348
从后往前逐个比较 不用每次都检查是否越界，所以可以减少时间 折半查找法 找到情况
第八章 查找【数据结构】【精致版】
小心星的博客
11-07 255
第八章 查找【数据结构】【精致版】
数据结构填空题
热门推荐
qq_40907977的博客
08-07 5万+
1、 2、 3、 4、 5、 6、 7、 8、 9、 10、 11、 12、 13、 14、 15、 16、 17、 18、 19、 20、 21、 22、 23、 24、 25、 26、 27、 28、 29、 30、 31、 32、 33、 34、 35、 36、 37、 38、 39、 40、 41、 42、 43、 44、 45、 46、 47、 48、 49、 50、 51、 52、 53、 54、 55、 56、 57、 58、 59、 60、 61、 62、 63、 64、 65、 66、 6
【数据结构练习题——查找】
Python极客
10-28 991
二叉查找树；二叉排序树；查找成功平均查找长度；查找失败平均查找长度
数据结构之查找(一)——基本概念
daocaoren_的博客
08-09 743
在哪里查找？——查找表 查找表是由同一类型的数据元素(或记录)构成的集合。由于“集合”中的数据元素之间存在着松散的关系，没有严格的前驱和后继的关系，因此查找表是一种应用灵活的结构。 什么是查找？ 根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素(或记录)。 关键字： 用来标识一个数据元素(或记录)的某个数据项的值。 主关键字：可唯一地标识一个记录的关键字 次关键字：用以识...
数据结构 期末复习
weixin_62438655的博客
12-01 1379
复习数据结构
数据结构期末复习总结
weixin_51252109的博客
12-07 3688
数据结构期末复习总结一：绪论1.数据的逻辑结构2.数据的物理结构3.算法的基本概念二：线性表 一：绪论 1.数据的逻辑结构 逻辑结构包括：线性结构、非线性结构 线性结构： 集合中存在唯一一个“第一个元素” 集合中存在唯一一个“最后一个元素” 除最后一个元素之外，其他数据元素均有唯一的“后继” 除第一个元素之外，其他数据元素均有唯一的“前驱” 非线性结构：包括树形结构、图形结构 一对多 2.数据的物理结构 物理结构包括： 顺序存储方法、链式存储方法、索引存储方法、散列存储方法 3.
数据结构期末复习速成
传播是知识存在的意义
01-06 6276
数据结构期末复习速成，没有很详细的知识点，只是对照常考的题目提醒，把关键的一些基础题目设计到的知识点重新梳理了一遍，静下心把这些都快速的过一遍，相信你能收获不少，每天复习一点就会持续更新一点！期末不挂科！ 数据和数据结构 定义 数据 数据元素：数据的基本组织单位 数据项：数据元素的组成部分 数据对象：具有相同性质的数据元素的集合 数据的结构分为数据逻辑结构和数据存储结构 数据逻辑结构 4种基本数据逻辑结构类型： 集合 线性结构 数据元素之间是一对一关系 树形结构 数据元素之间是一对多关系 图
数据结构期末复习（C语言版）
2301_77523019的博客
01-15 3264
线性表、栈和队列、串、数组和广义表、树、图的概念和常见题型，看完这篇文章，你的数据结构期末考试成绩必然在60往上，如果不够60分，你来找我补，我爱说实话。
西南交大-计算机-超级全面-数据结构期末复习资料.zip
11-18
西南交通大学的这份"超级全面"数据结构期末复习资料包含了丰富的学习资源，旨在帮助学生充分理解和掌握这一领域的关键概念。 文档“算法！.docx”和“算法！.pdf”很可能包含了各种数据结构相关的经典算法详解，如...
西安电子科技大学数据结构期末复习题.doc
07-02
西安电子科技大学数据结构期末复习题 本资源提供了西安电子科技大学数据结构期末复习题，涵盖了数据结构的基本概念、存储结构、算法、链表、栈、队列、数组、广义表等方面的知识点。 1. 数据结构的基本概念： ...
西科大数据结构期末复习题
05-26
西科大数据结构期末复习题西科大数据结构期末复习题西科大数据结构期末复习题西科大数据结构期末复习题西科大数据结构期末复习题西科大数据结构期末复习题西科大数据结构期末复习题西科大数据结构期末复习题西科大...
数据结构期末复习题.doc
08-17
"数据结构期末复习题" 数据结构是计算机科学中的一门基础学科，涉及到算法、数据存储结构、数据操作等方面。以下是对数据结构期末复习题的知识点总结： 1. 算法的计算量的大小称为计算的复杂性。算法的时间复杂度...
专升本数据结构期末复习资料.pdf
09-30
"专升本数据结构期末复习资料.pdf" 本文档是关于数据结构的期末复习资料，涵盖了算法分析、数据结构、链表、树、图等方面的知识点。 算法分析 算法分析是指对算法的时间复杂度和空间复杂度的分析。时间复杂度是指...
数据结构_2.2、顺序表插入删除查找
cfy2401926342的博客
09-29 155
线性表：是具有相同数据类型的n （n≥0）个数据元素的有限序列顺序表：用顺序存储的方式实现线性表顺序存储：把逻辑上相邻的元素存储在物理 位置上也相邻的存储单元中，元素之间的关 系由存储单元的邻接关系来体现。ElemType ：就是你的顺序表中存放的数据元素类型。
【笔记】数据结构12
最新发布
m0_52024881的博客
09-29 304
看到的社区的一个知识总结，这里记录一下。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 860
本文介绍了数据结构中的AVL树，给出了C++的代码实现
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 671
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
数据结构期末复习：关键考点详解及答案
本资源是一份针对数据结构期末复习的章节试题，包含填空题、单项选择题和简答题，旨在帮助学生巩固和理解课程内容，准备期末考试。以下是部分知识点详解： 1. 数据结构定义：数据结构是一门学科，关注非数值计算中...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值