您的位置：360文档中心› 数据结构完整代码

数据结构完整代码

合集下载

数据结构代码

数据结构代码

数据结构代码
1.简介
- 介绍数据结构的定义、作用以及常见应用场景。

- 简要概述本文档内容与结构。

2.数组 (Array)
- 定义和特点
- 基本操作：插入、删除、查找、修改
- 数组的实现方式与优缺点
- 数组的常见问题与解决方法
3.链表 (Linked List)
- 单向链表、双向链表和循环链表的定义和特点 - 基本操作：插入、删除、查找、修改
- 链表的实现方式与优缺点
- 链表的常见问题与解决方法
4.栈 (Stack)
- 定义和特点
- 基本操作：入栈、出栈、获取栈顶元素、判断栈是否为空
- 栈的实现方式与优缺点
- 栈的常见问题与解决方法
5.队列 (Queue)
- 定义和特点
- 基本操作：入队、出队、获取队首元素、判断队列是否为空
- 队列的实现方式与优缺点
- 队列的常见问题与解决方法
6.树 (Tree)
- 二叉树、二叉搜索树和平衡二叉树的定义和特点
- 基本操作：插入、删除、查找
- 树的遍历方式：前序、中序、后序和层序遍历
- 树的实现方式与优缺点
- 树的常见问题与解决方法
7.图 (Graph)
- 有向图和无向图的定义和特点
- 图的表示方式：邻接矩阵和邻接表
- 图的遍历方式：深度优先搜索和广度优先搜索 - 图的常见问题与解决方法
附件：
- 相关示例代码文件
- 图片/图表文件
法律名词及注释：
- 1.法律名词A：解释A的含义和定义。

- 2.法律名词B：解释B的含义和定义。

(完整版)数据结构线性表的主要程序代码

(完整版)数据结构线性表的主要程序代码

数据结构顺序表的主要代码（LIZHULIN）1．/***有头结点的单链表的初始化、建立（表头插入、表尾插入）、求长度、插入、删除、输出***//***********单链表的初始化、建立、输出*****************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = NULL;}/*************建立一个带头结点的单链表，在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p,*q; int i;Initlist(L); /*单链表初始化*/q=L;printf("input the value\n");for(i = n;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));scanf("%d",&p->data); /*输入元素值*/q->next = p;p->next = NULL;q=p;/*插入到表尾*/}} /* Create_L *//*************建立一个带头结点的单链表，在表头插入**************Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化/*需要注意第一个数据插入时的情况/*Insert the Firset nodep = (LinkList*)malloc(sizeof(struct Lnode));printf("input the value\n");scanf("%d",&p->data); /*输入元素值L->next = p;p->next = NULL;/*将第二个及后面的数据插入for(i = n-1;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));printf("input a value\n");scanf("%d",&p->data); /*输入元素值p->next = L->next;L->next = p;/*插入到表头}} /* Create_L *//*************************求单链表的长度***********************/int Length_LinkList(LinkList *L){LinkList *p;int i=0;p=L->next;while(p!=NULL){i++;p=p->next;}return i;}/*Length_LinkList*//*************************在第i个结点前插入数据x *********************/ Insert_LinkList(LinkList *L, int i, int x){LinkList *p,*s;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i，则无意义*//*插入元素x */s=(LinkList *)malloc(sizeof(struct Lnode));s->data=x;s->next=p->next;p->next=s;}/*********************删除第i个元素，并用y将其值返回************************/ int Delete_LinkList(LinkList *L, int i){LinkList *p,*q;int y;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i，则无意义*/q=p->next;y=q->data;p->next=q->next;free(q) ;return y;} /*Delete_LinkList*//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p!=NULL){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int len;int n=0;int x=15;int y;int i=4;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =NULL;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);Insert_LinkList(L, i, x);/* y=Delete_LinkList(L,i);printf("the delete elment is y=%d\n",y);len=Length_LinkList(L);printf("the length of L is %d",len);*/display(L);getch();}2．/***无头结点的单链表建立、插入、求长度、插入、删除、输出*****/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;while(p!=NULL){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}3．/*********顺序表的建立、查找、插入运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/*******Creat SqList********/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input SqList.data\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Position Error");return;}elsereturn L->data[i-1];}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *L;/*printf("input the length of SqList\n");scanf("%d",&len);*/Create_SqList(L);Display_SqList(L);getch();}4．/*********顺序表的归并运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/************ Creat SqList*************/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input the data of SqList\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Getelem Position Error");return;}return L->data[i-1];}/************ Insert Operation *********/void ListInsert(SqList *L,int i, int x){SqList *q, *p;if(i<1 || i>L->length){printf("the insert position error");return ;}q = &(L->data[i-1]); /*q为插入位置*/for(p=&(L->data[L->length-1]); p>=q; --p)*(p+1) = *p;L->data[i-1] = x;++L->length;}/********* LA and LB Merged LC ***************/ void MergeList(SqList *LA,SqList *LB,SqList *LC) {int La_len,Lb_len,ai,bj;int i,j;int k;i=j=1;InitList(LC);La_len = ListLength(LA);Lb_len = ListLength(LB);LC->length = La_len+Lb_len;/*for(k=0;k<LC->length;k++)LC->data[k] = 0; */k=0;while((i<=La_len)&&(j<=Lb_len)){ai= GetElem(LA, i);bj= GetElem(LB, j);if(ai<bj){++k;ListInsert(LC,k,ai);++i;}elseif(ai==bj){++k;ListInsert(LC,k,ai);++k;ListInsert(LC,k,bj);++i;++j;}else{++k;ListInsert(LC,k,bj);++j;}}while(i<=La_len){/*Append the residual node into LA */ai= GetElem(LA, i);++i;++k;ListInsert(LC,k,ai);}while(j<=Lb_len){/*Append the residual node into LA */bj= GetElem(LB, j);++j;++k;ListInsert(LC,k,bj);}LC->length = La_len+Lb_len;}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *LA , *LB, *LC;Create_SqList(LA);Create_SqList(LB);MergeList(LA,LB,LC);Display_SqList(LC);getch();}5．/**** 用带头结点的循环单链表解决约瑟夫问题***********/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = L;}/*************建立一个带头结点的循环单链表，数据值为1,2,3,...n,在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化p=L;for(i = n;i>0;--i){q = (LinkList*)malloc(sizeof(struct Lnode));q->data = i; /*输入元素值p->next =qq->next = L;/*插入到表尾}} /* Create_L *//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p->next!=L){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int n;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =L;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);display(L);getch();}6．/******** 无头结点的循环单链表的建立**************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}p->next = L;/*尾结点指向第一个结点*/}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;printf("%d ",p->data);p=p->next;while(p->next !=L){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/ main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}。

数据结构-单链表基本操作实现（含全部代码）

数据结构-单链表基本操作实现（含全部代码）

数据结构-单链表基本操作实现（含全部代码）今天是单链表的实现，主要实现函数如下：InitList(LinkList &L) 参数：单链表L 功能：初始化时间复杂度 O(1)ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数：单链表L，位置i 功能：删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域，然后删除后继结点。

最坏是O(n),即从头查找p之前的结点,然后删除p所指结点LocateElem(LinkList L,ElemType e) 参数：单链表L，元素e 功能：查找第⼀个等于e的元素，返回指针时间复杂度O(n)代码：/*Project: single linkeed list (数据结构单链表)Date: 2018/09/14Author: Frank YuInitList(LinkList &L) 参数：单链表L 功能：初始化时间复杂度 O(1)ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数：单链表L，位置i 功能：删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域，然后删除后继结点。

数据结构顺序表代码

数据结构顺序表代码

数据结构顺序表代码很高兴回答这个问题。

关于数据结构的顺序表代码，我们需要先了解什么是顺序表以及其特点和常用操作。

顺序表是一种基于数组实现的线性数据结构，其特点是元素在内存中是连续存储的，可以支持快速随机访问，但插入和删除元素比较麻烦。

下面是一份简单的顺序表代码：```#define MAXSIZE 100 //定义顺序表的最大长度typedef struct {int data[MAXSIZE]; //用数组存储顺序表的元素int length; //顺序表的当前长度} SeqList;// 初始化顺序表void InitList(SeqList *L){memset(L->data, 0, sizeof(L->data)); //初始化所有元素为0L->length = 0; //长度为0}// 插入元素bool ListInsert(SeqList *L, int pos, int val){if(pos < 1 || pos > L->length + 1 || L->length == MAXSIZE) //判断是否越界或者表满return false;for(int i = L->length; i >= pos; i--) //从后向前移动元素L->data[i] = L->data[i - 1];L->data[pos - 1] = val; //插入新元素L->length++; //长度加1return true;}// 删除元素bool ListDelete(SeqList *L, int pos){if(pos < 1 || pos > L->length) //判断是否越界return false;for(int i = pos - 1; i < L->length - 1; i++) //从前向后移动元素 L->data[i] = L->data[i + 1];L->length--; //长度减1return true;}// 查找元素int LocateElem(SeqList L, int val){for(int i = 0; i < L.length; i++){ //遍历顺序表找到元素 if(L.data[i] == val)return i + 1;}return 0;}// 获取元素int GetElem(SeqList L, int pos){if(pos >= 1 && pos <= L.length) //判断是否越界 return L.data[pos - 1];elsereturn -1;}// 输出顺序表void PrintList(SeqList L){for(int i = 0; i < L.length; i++)printf("%d ", L.data[i]); //输出每个元素printf("\n");}```以上就是一个简单的顺序表代码实现，包括初始化、插入、删除、查找、获取和输出操作。

数据结构课程设计代码

数据结构课程设计代码

数据结构课程设计代码根据提供的输入输出需求，下面是一个示例的数据结构课程设计代码。

```pythonclass Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef add(self, data):new_node = Node(data)if self.head is None:self.head = new_nodeelse:current = self.headwhile current.next is not None:current = current.nextcurrent.next = new_nodedef remove(self, data):current = self.headprev = Nonewhile current is not None:if current.data == data:if prev is None:self.head = current.next else:prev.next = current.next returnprev = currentcurrent = current.nextdef display(self):current = self.headwhile current is not None:print(current.data, end=" ")current = current.nextprint()if __name__ == "__main__":linked_list = LinkedList()while True:print("1. Add element")print("2. Remove element")print("3. Display elements")print("4. Quit")choice = input("Enter your choice: ")if choice == "1":data = input("Enter element to add: ")linked_list.add(data)elif choice == "2":data = input("Enter element to remove: ")linked_list.remove(data)elif choice == "3":linked_list.display()elif choice == "4":breakelse:print("Invalid choice")```这个代码示例实现了一个简单的链表数据结构，在命令行中提供了添加元素、删除元素和显示元素的选项。

数据结构经典代码(严蔚敏)

数据结构经典代码(严蔚敏)

/* 线性表的顺序表示：类型和界面定义*//* 线性表的顺序表示：函数实现*//* 线性表的单链表表示：类型和界面函数定义*//* 线性表的单链表表示：函数实现*//* 线性表的顺序表示：类型和界面定义*//* 线性表的顺序表示：函数实现*//* 用顺序表解决josephus问题的算法*//* 用循环单链表解决josephus问题的算法*//*字符串的顺序表示*//* 字符串的链接表示 *//* 顺序栈表示：类型和界面函数声明 *//* 顺序栈表示：函数定义 *//* 栈链接表示：类型和界面函数声明 *//*栈链接表示：函数定义*//* 简化背包问题的递归算法*//* 简化背包问题的非递归算法*//* 迷宫问题的递归算法*//* 迷宫问题的非递归算法(栈实现)*//* 队列的顺序表示：类型和函数声明 *//* 队列的顺序表示：函数定义 *//*队列链接表示：类型和界面函数声明*//*队列链接表示：函数定义*//* 用队列解决农夫过河问题的算法*//* 树的长子-兄弟表示法*//* 树的父指针表示法*//* 树的子表表示法*//* 树的后根周游的递归算法*//* 树的先根周游的非递归算法*//* 树的中根周游的递归算法*//* 树的后根周游的递归算法*//* 树的广度优先周游算法*//* 二叉树的链接表示*//* 二叉树的顺序表示*//* 线索二叉树的定义,构造算法和中根周游算法*//* 二叉树前根周游的递归算法*//* 二叉树对称根周游的递归算法*//* 二叉树后根周游的递归算法*//* 二叉树后根周游的非递归算法*//* 本程序提供了用顺序表实现字典的存储表示定义*//* 本程序是用开地址法解决碰撞的散列表示方法,提供了字典的一些基本操作*//* 字典的二叉排序树实现,本程序实现了二叉排序树的基本操作的算法*/ /* 字典的AVL树实现*//* 本程序提供了用顺序表实现字典的情况下的顺序检索算法*//* 本程序提供了用顺序表实现字典的情况下的二分法检索算法*//* 本程序是用开地址法实现散列的检索算法*//* 二叉排序树的检索算法*//* AVL树的检索算法*//* 最佳二叉排序树是具有最佳检索效率的二叉排序树, 本程序提供了最佳二叉排序树的构造方法*//* 直接插入排序的算法源程序*//* 二分法插入排序的算法源程序*//* 表插入排序的算法源程序*//* shell排序的算法源程序 *//* 直接选择排序的算法源程序*//* 堆排序的算法源程序*//* 起泡排序的算法源程序*//* 快速排序的算法源程序*//* 基数排序的算法源程序*//* 二路归并排序算法的源程序*//* 用图邻接矩阵表示实现的一些基本运算*//* 用图邻接表表示实现的一些基本运算*//* 用邻接矩阵表示的图的广度优先周游算法*//* 用邻接表表示的图的广度优先周游算法*//* 用邻接矩阵表示的图的深度优先周游的递归算法*/ /* 用邻接矩阵表示的图的深度优先周游的非递归算法*/ /* 用邻接表表示的图的深度优先周游的非递归算法*/ /* 用邻接矩阵表示的图的Kruskal算法的源程序*//* 用邻接矩阵表示的图的prim算法的源程序*//* 用邻接矩阵表示的图的Dijkstra算法的源程序*//* 用邻接矩阵表示的图的Floyd算法的源程序*//* 用邻接表表示图的拓扑排序算法*//* 用邻接矩阵表示图的拓扑排序算法*//* 图的关键路径问题的算法*//* 背包问题的贪心法算法*//* 用动态规划法求组和数的算法*//* 用回溯法解决骑士周游问题的算法*//* 0/1背包问题的回溯法算法*//* 0/1背包问题的动态规划法算法*//* 0/1背包问题的分支定界法算法*//* 线性表的顺序表示：类型和界面定义*/#define TRUE 1#define FALSE 0#define SPECIAL -1/* 定义顺序表的大小。

清华严蔚敏《数据结构》的全部代码实现C语言,DOC

清华严蔚敏《数据结构》的全部代码实现C语言,DOC

/*c1.h(程序名)*/#include<string.h>#include<ctype.h>#include<malloc.h>/*malloc()等*/#include<limits.h>/*INT_MAX等*/#include<stdio.h>/*EOF(=^Z或F6),NULL*/ #include<stdlib.h>/*atoi()*/#include<io.h>/*eof()*/#include#include/*#define#define#define#define#define/*algo2-1.c实现算法2.1的程序*/#include"c1.h"typedefintElemType;#include"c2-1.h"/*c2-1.h线性表的动态分配顺序存储结构*/#define LIST_INIT_SIZE10/*线性表存储空间的初始分配量*/#define LISTINCREMENT2/*线性表存储空间的分配增量*/typedefstruct{ElemType*elem;/*存储空间基址*/int length;/*当前长度*/int}SqListStatus{/*(*L).if(!(*Lexit(*L).(*L).return}{/*free((*L(*L).(*L).(*L).return}{/*(*L).return}StatusListEmpty(SqList L){/*初始条件：顺序线性表L已存在。

操作结果：若L为空表，则返回TRUE，否则返回FALSE*/ if(L.length==0)return TRUE;elsereturn FALSE;}int List Length(SqList L)return L.length;}Status Get Elem(SqList L,int i,ElemType*e){/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*//*操作结果：用e返回L中第i个数据元素的值*/if(i<1||i>L.length)exit(ERROR);*e=*(L.elem+i-1);return OK;}int Locate Elem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)) {/*/*/*ElemTypeint i=1;p=L.elemwhile++i;if(i<=L.returnelsereturn}Status{/*/*/*int i=2;ElemTypewhile{p++;i++;}if(i>L.return INFEASIBLE;else{*pre_e=*--p;return OK;}}Status Next Elem(SqList L,ElemType cur_e,ElemType*next_e){/*初始条件：顺序线性表L已存在*//*否则操作失败，next_e无定义*/int i=1;ElemType*p=L.elem;while(i<L.length&&*p!=cur_e){i++;p++;}if(i==L.length)return INFEASIBLE;else{return}}Status{/*/*ElemTypeifreturnif((*L).{)); ifexit(*L).(*L).}q=(*L).for(p=(*q=e;/*++(*L).return}Status ListDelete(SqList*L,int i,ElemType*e)/*算法2.5*/{/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*//*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1*/ElemType*p,*q;if(i<1||i>(*L).length)/*i值不合法*/return ERROR;p=(*L).elem+i-1;/*p为被删除元素的位置*/*e=*p;/*被删除元素的值赋给e*/for(++p;p<=q;++p)/*被删除元素之后的元素左移*/*(p-1)=*p;(*L).length--;/*表长减1*/return OK;}Status ListTraverse(SqList L,void(*vi)(ElemType*)){/*初始条件：顺序线性表L已存在*//*操作结果：依次对L的每个数据元素调用函数vi()。

基础数据结构代码

基础数据结构代码
else
cout<<"\n 已找到，元素位置是 "<<loc;
}
break;
} /* switch */
}while(k!=6);
cout<<"\n 再见！";
cout<<"\n 打回车键，返回。";
int i;
cout<<"\n n=?";
cin>>L->length;
for(i=0;i<L->length;i++)
{
cout<<"\n data "<<i<<"=?";
cin>>L->data[i];
}
}
//遍历顺序表
void out_list(SqList L){
out_list(a);
}
break;
case 3:{
cout<<"\n i=?";
cin>>i;
ListDelete_Sq( &a, i, e);
out_list(a);
cout<<"\n e="<<e;
i--; /*将顺序表逻辑位序转化为data下标即物理位序*/
e=L->data[i];
for (j=i;j<L->length-1;j++) L->data[j]=L-> data[j+1];

数据结构源代码(全)

数据结构源代码(全)

/*顺序表的操作#include<iostream>#include<stdlib.h>using namespace std;Release 13.12 rev 9501 (2013/12/25 19:25:45) gcc 4.7.1 Windows/unicode - 32 bit #define MAX_SIZE 100typedef struct{int *emel;int lenth;}Sq;void init(Sq &l);void create(Sq &l);void trval(Sq &l);void find_value(Sq &l);void find_position(Sq &l);void insert(Sq &l);void dele(Sq &l);int main(){Sq l;init(l);create(l);trval(l);find_value(l);find_position(l);insert(l);trval(l);dele(l);trval(l);return 0;}void init(Sq &l){l.emel =new int[MAX_SIZE];if(l.emel ==NULL){cout<<"\t申请空间失败！"<<endl;exit(1);}l.lenth=0;cout<<"\t成功申请空间！该顺序表的长度目前为:"<<l.lenth<<endl; }void create(Sq &l){cout<<"\t请输入你想输入元素的个数：";int x;cin>>x;if((x<1)&&(x>MAX_SIZE)){cout<<"\t你说输入的数不在范围里"<<endl;return;}int i;for(i=0;i<x;i++){cin>>l.emel[i];}l.lenth=x;cout<<"\t成功赋值！"<<endl;}void trval(Sq &l){int i;cout<<"l(";for(i=0;i<l.lenth;i++){cout<<l.emel[i]<<" ";}cout<<")"<<" 该顺序表现在的长度为："<<l.lenth<<endl;}void find_value(Sq &l){int x,t=0;cout<<"\t请输入你要查找的值：";cin>>x;int i;for(i=0;i<l.lenth;i++){if(l.emel[i]==x){t=1;cout<<"\t成功找到该元素，它是顺序表的第"<<i+1<<"个元素！"<<endl;}}if(t==0){cout<<"\t无该元素！"<<endl;}}void find_position(Sq &l){int x;cout<<"\t请输入你要查找的位置：";cin>>x;int i;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内！"<<endl;return;}for(i=1;i<=l.lenth;i++){if(i==x){cout<<"\t成功找到该元素，该值是"<<l.emel[i-1]<<endl;}}}void insert(Sq &l){int i,x,y;cout<<"\t请输入你要插入的位置";cin>>x;cout<<"\t请输入你要插入的值";cin>>y;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内！"<<endl;return;}if(x==l.lenth){l.emel[l.lenth]=y;l.lenth=l.lenth+1;return;}for(i=l.lenth;i>=x;i--){l.emel[i]=l.emel[i-1];}l.emel[x-1]=y;l.lenth=l.lenth+1;}void dele(Sq &l){int i,x;cout<<"\t请输入你要删除位置：";cin>>x;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内！"<<endl;return;}for(i=x-1;i<=l.lenth;i++){l.emel[i]=l.emel[i+1];}l.lenth=l.lenth-1;}成功申请空间！该顺序表的长度目前为:0请输入你想输入元素的个数：3852成功赋值！l(8 5 2 ) 该顺序表现在的长度为：3请输入你要查找的值：5成功找到该元素，它是顺序表的第2个元素！请输入你要查找的位置：3成功找到该元素，该值是2请输入你要插入的位置3请输入你要插入的值10l(8 5 2 10 ) 该顺序表现在的长度为：4请输入你要删除位置：3l(8 5 10 ) 该顺序表现在的长度为：3--------------------------------Process exited with return value 0Press any key to continue . . .*//*#include<stdio.h>#include<stdlib.h>typedef struct Link{int num;struct Link *next;}L;L* creat(L* head){head=(L *)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败！\n");exit(-1);}head->next=NULL;return head;}void insert(L* head){int x,i;printf("请输入你想输入数据的个数：");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败！\n");exit(-1);}printf("请输入值：");scanf("%d",&q->num);q->next=NULL;p->next=q;p=q;}}void print(L* head){L *p;p=head->next;while(p!=NULL){printf("值为：%d\n",p->num);p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点！！！\n");insert(head);printf("成功输入数据！！！\n");print(head);return 0;}*//*线性表的操作#include<stdio.h>#include<stdlib.h>typedef struct Link{int num;struct Link *next;}L;L* creat(L* head){head=(L *)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败！\n");exit(-1);}head->next=NULL;return head;}void init(L* head){int x,i;printf("请输入你想输入数据的个数：");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败！\n");exit(-1);}printf("请输入值：");scanf("%d",&q->num);q->next=p->next;p->next=q;}}int print(L* head){L *p;int lenth=0;p=head->next;printf("\t\tL(");while(p!=NULL){lenth++;printf("%d ",p->num);p=p->next;}printf(")\n");return lenth;}int insert(L *head,int lenth){printf("\t\t请输入你要插入的元素的位置:");int in;scanf("%d",&in);if(in<1 || in>lenth){printf("\t\t输入值不在范围内！");return -1;}L *p,*q;p=head->next;q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败！\n");return -1;}printf("\t\t请为新节点输入值：");scanf("%d",&q->num);int i=0;while(p!=NULL){i++;if(i==in-1){q->next=p->next;p->next=q;}p=p->next;}lenth++;return lenth;}int dele(L *head,int lenth){printf("\t\t请输入你要删除的元素的位置:");int out;scanf("%d",&out);if(out<1 || out>lenth){printf("\t\t输入值不在范围内！");return -1;}L *p,*q;p=head->next;q=head;int i=0;while(p!=NULL){i++;if(i==out){q->next=p->next;}q=p;p=p->next;}lenth--;return lenth;}void find(L *head,int lenth){printf("\t\t请输入你要查找的元素的位置:");int finder;scanf("%d",&finder);if(finder<1 || finder>lenth){printf("\t\t输入值不在范围内！");return ;}L *p;p=head->next;int i=0;while(p!=NULL){i++;if(i==finder){printf("\t\t你要找的该位置所对应的值为：%d\n",p->num);}p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点！！！\n");init(head);printf("成功输入数据！！！\n");int len;len=print(head);printf("\t\t该线性表的长度为:%d\n",len);len=insert(head,len);len=print(head);printf("\t\t插入后线性表的长度为:%d\n",len);len=dele(head,len);len=print(head);printf("\t\t删除后该线性表的长度为:%d\n",len);find(head,len);return 0;}*//*顺序表的合并#include<iostream>using namespace std;struct LA{int *pa;int lenth;};struct LB{int *pb;int lenth;};struct LC{int *pc;int lenth;};void mergelist(LA la,LB lb,LC &lc);int main(){int x,y;LA la;LB lb;cout<<"\t\t请给线性表LA和LB指定长度：";cin>>x>>y;la.pa =new int(sizeof(int)*x);lb.pb =new int(sizeof(int)*y);int i;for(i=0;i<x;i++){cout<<"请输入表LA的值:";cin>>la.pa[i];}cout<<endl;la.lenth=x;for(i=0;i<y;i++){cout<<"请输入表LB的值:";cin>>lb.pb[i];}lb.lenth=y;cout<<"LA(";for(i=0;i<x;i++){cout<<la.pa[i]<<" ";}cout<<")"<<endl;cout<<"LB(";for(i=0;i<y;i++){cout<<lb.pb[i]<<" ";}cout<<")"<<endl;LC lc;mergelist(la,lb,lc);return 0;}void mergelist(LA la,LB lb,LC &lc){lc.lenth=la.lenth+lb.lenth;lc.pc=new int(sizeof(int)*lc.lenth);int *pa=la.pa,*pb=lb.pb,*pc=lc.pc;int *pa_last=la.pa+la.lenth-1;int *pb_last=lb.pb+lb.lenth-1;while(pa<=pa_last && pb<=pb_last){if(*pa <= *pb){*pc++=*pa++;}else{*pc++=*pb++;}}while(pa<=pa_last){*pc++=*pa++;}while(pb<=pb_last){*pc++=*pb++;}cout<<"LC(";int i=0;for(i=0;i<lc.lenth;i++){cout<<lc.pc[i]<<" ";}cout<<")"<<endl;}*///栈/*#include<iostream>using namespace std;#include<stdlib.h>#define MAXSIZE 100typedef struct{int *base;int *top;int stacksize;}Sqstack;int Initstack(Sqstack &s);void Push(Sqstack &s,int e);void StackTraverse(Sqstack &s);void Gettop(Sqstack &s);void Pop(Sqstack &s);int main(){Sqstack s;Initstack(s);cout<<"\t\t初始化栈成功！"<<endl;Push(s,2);cout<<"\t\t2入栈成功！"<<endl;Push(s,4);cout<<"\t\t4入栈成功！"<<endl;Push(s,6);cout<<"\t\t6入栈成功！"<<endl;Push(s,8);cout<<"\t\t8入栈成功！"<<endl;cout<<"\n由栈底至栈顶的元素为：";StackTraverse(s);Gettop(s);Pop(s);Gettop(s);return 0;}int Initstack(Sqstack &s){s.base=new int[MAXSIZE];if(s.base==NULL){exit(1);}s.top=s.base;s.stacksize=MAXSIZE;}void Push(Sqstack &s,int e){if(s.top-s.base==s.stacksize){exit(1);}*s.top++=e;}void StackTraverse(Sqstack &s){int *p=s.base,i=0;while(p<s.top){i++;cout<<*p++<<" ";}cout<<"\t\t栈的长度是"<<i<<endl;}void Gettop(Sqstack &s){if(s.base==s.top){exit(1);}cout<<"栈顶元素是："<<*(s.top-1)<<endl; }void Pop(Sqstack &s){if(s.top==s.base){exit(1);}cout<<"出栈的第一个元素是:";cout<<*--s.top<<" "<<endl;}*///队列例题：/*#include<iostream>#include<stdlib.h>using namespace std;#define MAXQSIZE 100typedef struct{int *base;int front;int rear;}SqQueue;int InitQueue(SqQueue &q);int EnQueue(SqQueue &q,int x);int DeQueue(SqQueue &q);int main(){SqQueue q;InitQueue(q);EnQueue(q,1);EnQueue(q,3);EnQueue(q,5);EnQueue(q,7);DeQueue(q);DeQueue(q);DeQueue(q);DeQueue(q);return 0;}int InitQueue(SqQueue &q){q.base=new int[MAXQSIZE];if(q.base==NULL){exit(1);}q.front=0;q.rear=0;return 0;}int EnQueue(SqQueue &q,int x){if((q.rear+1)%MAXQSIZE==q.front){exit(0);}q.base[q.rear]=x;q.rear=(q.rear+1)%MAXQSIZE;return 0;}int DeQueue(SqQueue &q){if(q.front==q.rear){exit(0);}int x=q.base[q.front];q.front=(q.front+1)%MAXQSIZE;cout<<x<<endl;}*//*#include<iostream>#include<stdlib.h>using namespace std;typedef struct Qnode{int date;struct Qnode *next;}Qnode,*Queueptr;typedef struct{Queueptr front; //队头指针Queueptr rear; //队尾指针}LinkQueue;int InitQueue(LinkQueue &Q);void EnQueue(LinkQueue &Q,int e);void TrvalQueue(LinkQueue Q);void DeQueue(LinkQueue &Q);int main(){LinkQueue Q;InitQueue(Q);EnQueue(Q,1);cout<<"\t元素1入队成功！"<<endl;EnQueue(Q,3);cout<<"\t元素3入队成功！"<<endl;EnQueue(Q,5);cout<<"\t元素5入队成功！"<<endl;EnQueue(Q,7);cout<<"\t元素7入队成功！"<<endl;cout<<"\t队列的元素分别是："<<endl;TrvalQueue(Q);cout<<"\t第一个出队的元素是："<<endl;DeQueue(Q);cout<<"\n\t第一个元素出队完成之后队列中从队头至队尾的元素为：";TrvalQueue(Q);return 0;}int InitQueue(LinkQueue &Q){Q.rear=new Qnode;Q.front=Q.rear;if(Q.front==NULL){exit(0);}Q.front->next=NULL;return 0;}void EnQueue(LinkQueue &Q,int e){Qnode *p=new Qnode;if(!p){exit(1);}p->date=e;p->next=NULL;Q.rear->next=p; //连接Q.rear=p; //修改队尾指针}void TrvalQueue(LinkQueue Q){Qnode *p=Q.front->next;//队头元素while(Q.front!=Q.rear){cout <<p->date<<" ";Q.front=p;p=p->next;}cout<<endl;}void DeQueue(LinkQueue &Q){if(Q.front==Q.rear){return;}Qnode *p=Q.front->next;cout<<"\t"<<p->date<<endl;Q.front->next=p->next;if(Q.rear==p){Q.rear=Q.front;delete p;}}*//*//表达式求值#include<iostream>#include<stdlib.h>#include<stdio.h>using namespace std;#define MAXSIZE 100typedef struct{char *base;char *top;char num;}OPND; //数据栈typedef struct{char *base;char *top;char c;}OPTR; //符号栈int Initstack(OPND &op_n,OPTR &op_t);void Pushstack(OPND &op_n,char ch);void Pushstack(OPTR &op_t,char ch);char Popstack(OPND &op_n,char ch);char Popstack(OPTR &op_t,char ch);char Gettop(OPTR op_t);char Gettop(OPND op_n);int In(char ch);char Precede(char x,char y);char operate(char z,char x,char y);int main(){OPND op_n;OPTR op_t;Initstack(op_n,op_t);Pushstack(op_t,'#');char ch;char p;cin>>ch;while(ch!='#' || Gettop(op_t)!='#'){if(!In(ch)){Pushstack(op_n,ch);cin>>ch;}else{switch( Precede(Gettop(op_t),ch) ){case '<':Pushstack(op_t,ch);cin>>ch;break;case '>':char x,y,z;x=Popstack(op_t,x);y=Popstack(op_n,y);z=Popstack(op_n,z);Pushstack(op_n,operate(z,x,y));break;case '=':p=Popstack(op_t,p);cin>>ch;break;}}}cout<<"\t表达式结果是："<<Gettop(op_n)<<endl;return 0;}int Initstack(OPND &op_n,OPTR &op_t){op_n.base=new char[MAXSIZE];op_t.base=new char[MAXSIZE];if((op_n.base==NULL) || (op_t.base==NULL)){exit(1);}op_n.top=op_n.base;op_t.top=op_t.base;op_n.num=MAXSIZE;op_t.c=MAXSIZE;return 0;}void Pushstack(OPND &op_n,char ch){if(op_n.top-op_n.base==op_n.num){return;}*op_n.top++=ch;cout<<ch<<" 入数字栈"<<endl;}void Pushstack(OPTR &op_t,char ch){if(op_t.top-op_t.base==op_t.c){return;}*op_t.top++=ch;cout<<ch<<" 入操作符"<<endl;}char Popstack(OPND &op_n,char ch)if(op_n.top==op_n.base){exit(1);}ch=*--op_n.top;cout<<ch<<" 出数字栈"<<endl;return ch;}char Popstack(OPTR &op_t,char ch){if(op_t.top==op_t.base){exit(1);}ch=*--op_t.top;cout<<ch<<" 出字符栈"<<endl;return ch;}char Gettop(OPTR op_t){char x;if(op_t.top==op_t.base){exit(1);}x=*(op_t.top-1);cout<<"得到操作符栈顶"<<x<<endl;return x;}char Gettop(OPND op_n){char x;if(op_n.top==op_n.base){exit(1);}x=*(op_n.top-1);cout<<"得到操作数栈顶"<<x<<endl;return x;}int In(char ch)if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='#') {return 1;}else{return 0;}}char Precede(char x,char y){if(x=='+' || x=='-'){if(y=='+' || y=='-' || y==')' || y=='#'){return '>';}else{return '<';}}if(x=='*'||x=='/'){if(y=='('){return '<';}else{return '>';}}if(x=='('){if(y==')'){return '=';}else if(y=='+'||y=='-'||y=='*'||y=='/'||y=='('){return '<';}}if(x==')'){if(y!='('){return '>';}}if(x=='#'){if(y=='#'){return '=';}else if(y!=')'){return '<';}}}char operate(char z,char x,char y) {if(x=='+'){return (z-'0') + (y-'0')+48;}if(x=='-'){return (z-'0') - (y-'0')+48;}if(x=='*'){return (z-'0')* (y-'0')+48;}if(x=='/'){return (z-'0')/ (y-'0')+48;}}*//*#include<iostream>using namespace std;int main(){char a[10];char *b[10];char **c[10];return 0;}*//*#include<iostream>using namespace std;char f(char x,char y){return (x-'0') * (y-'0')+48;}int main(){char a='3',b='5';char p=f(a,b);cout<<p<<endl;return 0;}*///数列出队/*#include<iostream>#include<stdlib.h>using namespace std;typedef struct Qnode{int num;struct Qnode *next;}Qnode,*Queueptr;typedef struct{Queueptr front;Queueptr rear;}LinkQueue;int InitQueue(LinkQueue &Q);void EnQueue(LinkQueue &Q,int x); int DeQueue(LinkQueue &Q,int p); int main(){LinkQueue Q;InitQueue(Q);int x,i,y,num=0,e;cout<<"请输入总人数:";cin>>x;for(i=1;i<=x;i++){EnQueue(Q,i);}cout<<"请输入第几个数淘汰:";cin>>y;{for(i=0;i<y;i++){if(i!=y-1){e=DeQueue(Q,e);EnQueue(Q,e);}else{DeQueue(Q,e);num++;}}if(num==x-1){break;}}e=DeQueue(Q,e);cout<<"最后剩下的是："<<e<<endl;return 0;}int InitQueue(LinkQueue &Q){Q.front=new Qnode;Q.rear=Q.front;if(Q.front==NULL){exit(1);}Q.front->next=NULL;}void EnQueue(LinkQueue &Q,int x){Qnode *p=new Qnode;if(!p){exit(1);}p->num=x;p->next=NULL;Q.rear->next=p;}int DeQueue(LinkQueue &Q,int e) {Qnode *p;if(Q.rear==Q.front){exit(0);}p=Q.front->next;e=p->num;Q.front->next=p->next;if(Q.rear==p){Q.front=Q.rear;}delete p;return e;}*//*二叉树#include<iostream>#include<stdlib.h>using namespace std;typedef struct BiTNode{char date;struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;void CreateBiTree(BiTree &T);int Depth(BiTree T);int NodeCount(BiTree T);int LeavesNodeCount(BiTree T);int PreOrderTraverse(BiTree T);int InOrderTraverse(BiTree T);int PostOrderTraverse(BiTree T); int main(){BiTree T;CreateBiTree(T);cout<<"二叉树的深度为："<<Depth(T)<<endl;cout<<"二叉树中结点个数为："<<NodeCount(T)<<endl;cout<<"二叉树中叶子结点个数为："<<LeavesNodeCount(T)<<endl;cout<<"先序遍历：";PreOrderTraverse(T);cout<<"\n中序遍历：";InOrderTraverse(T);cout<<"\n后序遍历：";PostOrderTraverse(T);cout<<endl;return 0;}void CreateBiTree(BiTree &T){cout<<"请为该节点赋值:";char ch;cin>>ch;if(ch=='#'){T=NULL;}else{T =new BiTNode;T->date=ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}}int Depth(BiTree T){int m,n;if(T==NULL){return 0;}else{m=Depth(T->lchild);n=Depth(T->rchild);if(m>n){return m+1;}else{return n+1;}}}int NodeCount(BiTree T){if(T==NULL){return 0;}else{return NodeCount(T->lchild)+NodeCount(T->rchild)+1;}}int LeavesNodeCount(BiTree T){if(T==NULL){return 0;}else if(T->lchild==NULL && T->rchild==NULL){return 1;}else{return LeavesNodeCount(T->lchild)+LeavesNodeCount(T->rchild);}}int PreOrderTraverse(BiTree T){if(T!=NULL){cout<<T->date;PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}int InOrderTraverse(BiTree T){if(T!=NULL){InOrderTraverse(T->lchild);cout<<T->date;InOrderTraverse(T->rchild);}}int PostOrderTraverse(BiTree T){if(T!=NULL){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);cout<<T->date;}}请为该节点赋值:-请为该节点赋值:+请为该节点赋值:a请为该节点赋值:#请为该节点赋值:#请为该节点赋值:*请为该节点赋值:b请为该节点赋值:#请为该节点赋值:#请为该节点赋值:-请为该节点赋值:c请为该节点赋值:#请为该节点赋值:#请为该节点赋值:d请为该节点赋值:#请为该节点赋值:#请为该节点赋值:/请为该节点赋值:e请为该节点赋值:#请为该节点赋值:#请为该节点赋值:f请为该节点赋值:#请为该节点赋值:#二叉树的深度为：5二叉树中结点个数为：11二叉树中叶子结点个数为：6先序遍历：-+a*b-cd/ef中序遍历：a+b*c-d-e/f后序遍历：abcd-*+ef/-Process returned 0 (0x0) execution time : 76.214 s Press any key to continue.*//*#include<iostream>#include<stdlib.h>#include<string.h>using namespace std;typedef struct{int weiget;int parent,lchild,rchild;}HTNode,*HuffmanTree;typedef char** HuffmanCode;void creat(HuffmanTree &HT,int n);void Select(HuffmanTree HT,int k,int &min1,int &min2); void creatcode(HuffmanTree HT,HuffmanCode &HC,int n); int min(HuffmanTree HT,int k);int main(){int n;cout<<"请输入叶子节点的个数:";cin>>n;HuffmanTree HT;creat(HT,n);HuffmanCode HC;creatcode(HT,HC,n);return 0;}void creat(HuffmanTree &HT,int n){if(n<1){exit(1);}int m=2*n-1,i;HT=new HTNode[m+1];for( i=1;i<=m;i++){HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}for(i=1;i<=n;i++){cout<<"请输入权值:";cin>>HT[i].weiget;}int s1,s2;for(i=n+1;i<=m;i++) //通过n-1次选择来合并创建{Select(HT,i-1,s1,s2);HT[s1].parent=i; //赋值，作为删除的标记HT[s2].parent=i;cout<<"s1:"<<s1<<" s2:"<<s2<<endl;HT[i].lchild=s1; //生成新节点HT[i].rchild=s2;HT[i].weiget=HT[s1].weiget+HT[s2].weiget;}}void Select(HuffmanTree HT,int k,int &min1,int &min2){min1=min(HT,k);min2=min(HT,k);}int min(HuffmanTree HT,int k){int i=0;int min;//存放weight最小且parent为-1的元素的序号int min_wei;//存放权值while(HT[i].parent!=0){i++;}min_wei=HT[i].weiget;min=i;for(;i<=k;i++){if(HT[i].weiget<min_wei && HT[i].parent==0){min_wei=HT[i].weiget;min=i;}}HT[min].parent=1;return min;}void creatcode(HuffmanTree HT,HuffmanCode &HC,int n){HC =new char *[n+1];char *cd=new char[n];cd[n-1]='\0';int i,start;//start指向最后，即编码结束符的位置int current,father;for(i=1;i<=n;i++){start=n-1;current=i;father=HT[i].parent;while(father!=0){--start;if(HT[father].lchild==current){cd[start]='0';}else{cd[start]='1';}current=father;father=HT[father].parent;}HC[i]=new char[n-start];strcpy(HC[i],&cd[start]);cout<<HT[i].weiget<<"对应的编码是："<<HC[i]<<endl;}delete cd;}请输入叶子节点的个数:5请输入权值:1请输入权值:2请输入权值:3请输入权值:4请输入权值:5s1:1 s2:2s1:3 s2:6s1:4 s2:5s1:7 s2:81对应的编码是：0102对应的编码是：0113对应的编码是：004对应的编码是：105对应的编码是：11Process returned 0 (0x0) execution time : 4.003 s Press any key to continue.*///折半查找#include<iostream>#include<stdio.h>using namespace std;#define ENDFLAG 10000typedef int KeyType;typedef char* InfoType;typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SSTable;void CreateSTable(SSTable &ST,int n){int i;ST.R=new ElemType[n+1];for(i=1;i<=n;i++){cout<<"请输入"<<i<<"个测试数据：";cin>>ST.R[i].key;}ST.length=n;}int Search_Bin1(SSTable ST,KeyType key){int low,high,mid;low=1;high=ST.length;while(low<=high){mid=(low+high)/2;if(key==ST.R[mid].key){return mid;}else if(key<ST.R[mid].key){high=mid-1;}else{low=mid+1;}}return 0;}int Search_Bin2(SSTable ST,int low,int high,KeyType key) {int mid;if(low>high){return 0;}mid=(low+high)/2;printf("%d+++++",key==ST.R[mid].key);if(key==ST.R[mid].key){return mid;}else if(key<ST.R[mid].key){return Search_Bin2(ST,low,mid-1,key);}else{return Search_Bin2(ST,mid+1,high,key);}}int main(){int n;KeyType key;SSTable ST;cout<<"请输入静态查找表长：";cin>>n;CreateSTable(ST,n);cout<<"请输入待查记录的关键字：";cin>>key;cout<<"Search_Bin1算法计算的位置为："<<Search_Bin1(ST,key)<<endl;cout<<"Search_Bin2算法计算的位置为："<<Search_Bin2(ST,1,ST.length,key)<<endl;return 0;}/*请输入静态查找表长：5请输入1个测试数据：1请输入2个测试数据：2请输入3个测试数据：3请输入4个测试数据：4请输入5个测试数据：5请输入待查记录的关键字：3Search_Bin1算法计算的位置为：3Search_Bin2算法计算的位置为：3Process returned 0 (0x0) execution time : 8.620 sPress any key to continue.*//*#include<iostream>using namespace std;typedef struct{int key;}ElemType;typedef struct BSTNode{ElemType date;struct BSTNode *lchild,*rchild;}BSTNode,*BSTree;void Create(BSTree &T);void Insert(BSTree &T,ElemType e);int InOrderTraverse(BSTree T);int main(){BSTree T;Create(T);InOrderTraverse(T);cout<<"\n中序遍历：";return 0;}void Create(BSTree &T){T=NULL;ElemType e;cout<<"请为节点赋值:(0为结束条件)";cin>>e.key;while(e.key!=0){Insert(T,e);cout<<"请为节点赋值:(0为结束条件)";cin>>e.key;}}void Insert(BSTree &T,ElemType e){if(!T){BSTree S;S=new BSTNode;S->date=e;S->lchild=NULL;S->rchild=NULL;T=S;}else if(e.key<T->date.key){Insert(T->lchild,e);}else{Insert(T->rchild,e);}}int InOrderTraverse(BSTree T){if(T!=NULL){InOrderTraverse(T->lchild);cout<<T->date.key<<" ";InOrderTraverse(T->rchild);}return 0;}请为节点赋值:(0为结束条件)12请为节点赋值:(0为结束条件)7请为节点赋值:(0为结束条件)17请为节点赋值:(0为结束条件)11请为节点赋值:(0为结束条件)16请为节点赋值:(0为结束条件)2请为节点赋值:(0为结束条件)13请为节点赋值:(0为结束条件)9请为节点赋值:(0为结束条件)21请为节点赋值:(0为结束条件)4请为节点赋值:(0为结束条件)02 4 7 9 11 12 13 16 17 21中序遍历：Process returned 0 (0x0) execution time : 23.808 s Press any key to continue.*/。

数据结构代码汇总

数据结构代码汇总

数据结构代码汇总数据结构是计算机科学中非常重要的一个概念，它用于组织和存储数据，以便于高效地访问和操作。

在计算机科学的学习和实践中，数据结构的掌握是至关重要的。

下面是一些常见的数据结构及其对应的代码示例。

1. 数组(Array)数组是最简单的数据结构之一，它由一系列元素组成，可以通过索引访问和修改元素。

数组的代码示例如下：python创建一个整数数组array = [1, 2, 3, 4, 5]访问数组元素print(array[0]) 输出：1修改数组元素array[1] = 6遍历数组for element in array:print(element)2. 链表(Linked List)链表是一种动态数据结构，它由一系列节点组成，每个节点包含一个值和一个指向下一个节点的指针。

链表的代码示例如下：python创建一个节点类class Node:def __init__(self, value):self.value = valueself.next = None创建链表head = Node(1)second = Node(2)third = Node(3)构建链表关系head.next = secondsecond.next = third遍历链表current = headwhile current:print(current.value)current = current.next3. 栈(Stack)栈是一种后进先出(LIFO)的数据结构，它只允许在栈的顶部进行插入和删除操作。

栈的代码示例如下：python创建一个栈类class Stack:def __init__(self):self.stack = []def push(self, value):self.stack.append(value)def pop(self):if not self.is_empty:return self.stack.popelse:return Nonedef is_empty(self):return len(self.stack) == 0使用栈stack = Stackstack.push(1)stack.push(2)stack.push(3)print(stack.pop) 输出：34. 队列(Queue)队列是一种先进先出(FIFO)的数据结构，它允许在队列的一端插入元素，在另一端删除元素。

数据结构代码汇总简版

数据结构代码汇总简版

数据结构代码汇总数据结构代码汇总概述本文档旨在汇总和介绍常见的数据结构代码示例。

数据结构是计算机科学的重要基础，能够帮助我们有效地存储和组织数据。

有了良好的数据结构代码，我们可以提高程序的执行效率，并简化问题的解决过程。

本文档将介绍以下几种常见的数据结构及其相应的代码示例：1. 数组（Array）2. 链表（Linked List）3. 栈（Stack）4. 队列（Queue）5. 树（Tree）6. 图（Graph）7. 哈希表（Hash Table）数组（Array）数组是一组具有相同数据类型的元素按照连续的内存位置存储的数据结构。

以下是数组的示例代码：```python定义一个整型数组arr = [1, 2, 3, 4, 5]输出数组中的元素for i in arr:print(i)```链表（Linked List）链表是一种线性数据结构，由节点组成，每个节点包含数据和指向下一个节点的指针。

以下是链表的示例代码：```python定义一个链表的节点类class Node:def __init__(self, data):self.data = dataself.next = None定义一个链表类class LinkedList:def __init__(self):self.head = None在链表末尾添加一个节点def append(self, data):new_node = Node(data)if self.head is None:self.head = new_node else:curr = self.headwhile curr.next:curr = curr.next curr.next = new_node 遍历并打印链表中的节点值def display(self):curr = self.headwhile curr:print(curr.data)curr = curr.next创建一个链表对象并添加节点ll = LinkedList()ll.append(1)ll.append(2)ll.append(3)打印链表中的节点值ll.display()```栈（Stack）栈是一种后进先出（LIFO）的数据结构，只能在栈顶进行元素的插入和删除。

数据结构代码(仅供参考)

数据结构代码(仅供参考)

线性表一、单链表操作（插入、删除）：#include <stdio.h>#include <stdafx.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;void InitList(LinkList &L){//初始化链表L，带表头结点L=(LinkList)malloc(sizeof(LNode));L->next=NULL;}//InitListvoid CreateList(LinkList &L,int n){//创建具有n个结点的链表，结点数据由键盘输入LinkList p;int i;for(i=0;i<n;i++){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}//for}//CreateListvoid PrintList(LinkList &L){//打印结点的每个元素值LinkList p;p=L->next;printf("结点值分别为:\n");while(p){printf("%d ",p->data);p=p->next;}//whileprintf("\n");}//PrintListvoid InsertList(LinkList &L,int i,int n){//在的L的第i个位置插入元素nLinkList p,s;s=(LinkList)malloc(sizeof(LNode));int j=0;p=L;while(p&&j<i-1){p=p->next;j++;}//whileif(!p||j>i-1){printf("i的值不合法！\n");return;}//ifs->data=n;s->next=p->next;p->next=s;}//InsertListvoid Delete(LinkList &L,int i){//删除第i个元素LinkList P,Q;P=L;int j=0;while(P->next->next&&j<i-1){P=P->next;j=j+1;}if(!P->next) return;Q=P->next;P->next=Q->next;free(Q);}//Deletevoid main(){int n,i,j;LinkList L;printf("请输入链表结点个数:\n");scanf("%d",&n);InitList (L);printf("请逆序分别输入结点值:\n");CreateList(L,n);PrintList(L);printf("请输入擦人结点位置和值:\n"); scanf("%d%d",&i,&j);InsertList(L,i,j);PrintList(L);printf("请输入删除结点位置:\n");scanf("%d",&i);Delete(L,i);PrintList(L);}二、顺序表操作(插入、删除)：#include "stdafx.h"#include <stdio.h>#include <malloc.h>#define InitListSize 100#define ListIncrement 10typedef struct {int *elem;int length;int LiskSize;}SqList;void InitList(SqList &L){//初始化顺序表LL.elem=(int *)malloc(InitListSize*sizeof(int));if(!L.elem){printf("分配失败!\n");return;}//ifL.length=0;L.LiskSize=InitListSize;}//InitListvoid InsertList(SqList &L,int i,int e){//在顺序表的第i个位置插入元素eif(i<1||i>L.length) {printf("i的位置不合法!");return;}//ifif(L.length+1>InitListSize){int *newbase;newbase=(int *)realloc(L.elem,(InitListSize+ListIncrement)*sizeof(int));if(!newbase){printf("分配失败!\n");return;}//ifL.elem=newbase;L.LiskSize =L.LiskSize +ListIncrement;}//ifint *p,*q;q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;p--)*(p+1)=*p;*q=e;L.length +=1;}//InsertListvoid DeleteList(SqList &L,int i,int &e){//删除顺序表的第i个位置的值，并用e返回if(i<1||i>L.length) {printf("i的位置不合法!");return;}//ifint *p,*q;q=&(L.elem[i-1]);e=*q;p=&(L.elem[L.length-1]);for(q=q+1;q<=p;q++)*(q-1)=*q;--L.length;}//DeleteListvoid PrintList(SqList L){//打印顺序表中的所有元素int i;for(i=0;i<=L.length-1;i++)printf("%d ",L.elem[i]);printf("\n");}void main(){int i,n;int p,q;SqList L;InitList(L);printf("请输入元素的个数:\n");scanf("%d",&n);printf("请分别输入各个链表元素:\n");for(i=0;i<n;i++){scanf("%d",&(L.elem[i]));}//forL.length=5;PrintList(L);printf("请输入擦人元素的位置和值:\n");scanf("%d%d",&p,&q);InsertList(L,p,q);PrintList(L);printf("请输入删除元素的位置:\n");scanf("%d",&p);DeleteList(L,p,q);PrintList(L);}三、顺序表操作(合并、交集（另辟空间）、交集（用表A空间）)：#include "stdafx.h"#include <stdio.h>#include <malloc.h>#define InitListSize 100#define ListIncrement 10typedef struct {int *elem;int length;int LiskSize;}SqList;void InitList(SqList &L){//初始化顺序表LL.elem=(int *)malloc(InitListSize*sizeof(int));if(!L.elem){printf("分配失败!\n");return;}//ifL.length=0;L.LiskSize=InitListSize;}//InitListvoid CreateList(SqList &L){//int n,i;printf("请输入元素的个数:\n");scanf("%d",&n);printf("请分别输入各个链表元素:\n");for(i=0;i<n;i++){scanf("%d",&(L.elem[i]));}//forL.length=n;}void InsertList(SqList &L,int e){//在顺序表的结尾插入元素eif(L.length+1>InitListSize){int *newbase;newbase=(int *)realloc(L.elem,(InitListSize+ListIncrement)*sizeof(int));if(!newbase){printf("分配失败!\n");return;}//ifL.elem=newbase;L.LiskSize =L.LiskSize +ListIncrement;}//ifL.elem[L.length]=e;L.length +=1;}//InsertListvoid PrintList(SqList L){//打印顺序表中的所有元素int i;for(i=0;i<=L.length-1;i++)printf("%d ",L.elem[i]);printf("\n");}void Merge(SqList La,SqList Lb,SqList &Lc){//La与Lb都递增，合并后的Lc也递增int *pa,*pb,*pc,*palast,*pblast;pa=La.elem;pb=Lb.elem;Lc.LiskSize=Lc.length=La.length+Lb.length;pc=Lc.elem=(int *)malloc(Lc.LiskSize*sizeof(int));if(!Lc.elem) return;palast=La.elem+La.length-1;pblast=Lb.elem+Lb.length-1;while(pa<=palast&&pb<=pblast){if(*pa<*pb) *pc++=*pa++;else *pc++=*pb++;}//whilewhile(pa<=palast) *pc++=*pa++;while(pb<=pblast) *pc++=*pb++;}//mergevoid InterSet(SqList La,SqList Lb,SqList &Ld){//顺序表合并，另辟空间为Ld，可以有相同元素InitList(Ld);int i,j=0;for(i=0;i<La.length;i++){while(Lb.elem[j]<=La.elem[i]&&j<Lb.length){if(Lb.elem[j]==La.elem[i]) InsertList(Ld,La.elem[i]);j=j+1;}}//for}//InterSetvoid DeleteList(SqList &L,int i){//删除顺序表L.elem[i]if(i<0||i>=L.length) {printf("i的位置不合法!");return;}//ifint *p,*q;q=&(L.elem[i-1]);p=&(L.elem[L.length-1]);for(q=q+1;q<=p;q++)*(q-1)=*q;--L.length;}//DeleteListvoid InterSet2(SqList &La,SqList Lb){int e,i,j=0;for(i=0;i<La.length;i++){if(i>1&&La.elem[i]==La.elem[i-1]) La.elem[i]=0;else{e=0;while(j<Lb.length&&Lb.elem[j]<=La.elem[i]){if(La.elem[i]=Lb.elem[j]) e=1; //出现相同元素标志j=j+1;}if(e==0) La.elem[i]=0; //未出现相同元素}//if}//fori=0;while(i<La.length){if(La.elem[i]==0){DeleteList(La,i);i=i-1; //因为删除，后面元素已经迁移}i=i+1;}//while}//InterSet2void main(int argc, char* argv[]){SqList La,Lb,Lc,Ld;InitList(La);InitList(Lb);CreateList(La);CreateList(Lb);Merge(La,Lb,Lc);printf("合并后为:\n");PrintList(Lc);InterSet(La,Lb,Ld);printf("交集为:\n");PrintList(Ld);InterSet2(La,Lb);printf("求交集，（用La的空间存放）为:\n");PrintList(La);}四、链表逆序合并，允许有相同值：#include "stdafx.h"#include <malloc.h>#define N 5 //假设每个链表有五个元素typedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L){//创建链表LLinkList P,Q;int i;L=(LinkList)malloc(sizeof(LNode));P=L;printf("请输入链表元素，共5个:\n");for(i=0;i<N;i++){Q=(LinkList)malloc(sizeof(LNode));scanf("%d",&Q->data);P->next=Q;P=P->next;}//forP->next=NULL;}//CreateListvoid Merge(LinkList &La,LinkList &Lb,LinkList &Lc){ LinkList Pa,Pb,Pc,Q;Pa=La->next;Pb=Lb->next;Pc=Lc=La;Pc->next=NULL;while(Pa&&Pb){if(Pa->data<=Pb->data){Q=Pa;Pa=Pa->next;Q->next=Pc->next;Pc->next=Q;}else{Q=Pb;Pb=Pb->next;Q->next=Pc->next;Pc->next=Q;}}//whileif(Pa){while(Pa){Q=Pa;Pa=Pa->next;Q->next=Pc->next;Pc->next=Q;}}else{while(Pb){Q=Pb;Pb=Pb->next;Q->next=Pc->next;Pc->next=Q;}}free(Lb);}//Mergevoid Print(LinkList L){//打印链表中所有元素LinkList P;P=L->next;while(P){printf("%d",P->data);P=P->next;}printf("\n");}//Printvoid main(int argc, char* argv[]){LinkList a,b,c;CreateList(a);CreateList(b);Merge(a,b,c);printf("a and b inverse merge is:\n");Print(c);}五、链表求交集：#include "stdafx.h"#include <malloc.h>#define N 5 //假设每个链表有五个元素typedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L){//创建链表LLinkList P,Q;int i;L=(LinkList)malloc(sizeof(LNode));P=L;printf("请输入链表元素，共5个:\n");for(i=0;i<N;i++){Q=(LinkList)malloc(sizeof(LNode));scanf("%d",&Q->data);P->next=Q;P=P->next;}//forP->next=NULL;}//CreateListvoid InterSet(LinkList La,LinkList Lb,LinkList &Lc){ //交集为Lc，另辟空间LinkList Pa,Pb,Pc,Q;Pa=La->next;Pb=Lb->next;Lc=(LinkList)malloc(sizeof(LNode));Pc=Lc;while(Pa){while(Pb&&Pb->data<=Pa->data){if(Pb->data==Pa->data){Q=(LinkList)malloc(sizeof(LNode));Q->data=Pb->data;Pc->next=Q;Pc=Pc->next;}//ifPb=Pb->next;}//whilePa=Pa->next;}//whilePc->next=NULL;}//InterSetvoid InterSet2(LinkList La,LinkList Lb,LinkList &Lc){ //利用a表空间进行交集（不可以出现相同元素）LinkList Q;LinkList Pa,Pb,Pc;Pc=Lc=La;Pa=La->next;Pb=Lb->next;while(Pa){if(!Pc->data||Pa->data!=Pc->data){while(Pb&&Pb->data<=Pa->data){if(!Pc->data||Pc->data!=Pb->data){//Pc中不存在与Pb相同的元素Pc->next=Pa;Pc=Pc->next;}Pb=Pb->next;}//while}//ifif(!Pc->data||Pc->data!=Pa->data){ //此结点没有取Q=Pa;Pa=Pa->next;free(Q);}else{Pa=Pa->next;}//if}//whilePc->next=NULL;}//InterSet2void Print(LinkList L){//打印链表中所有元素LinkList P;P=L->next;while(P){printf("%d ",P->data);P=P->next;}printf("\n");}//Printvoid main(int argc, char* argv[]){LinkList a,b,c,d;CreateList(a);CreateList(b);InterSet(a,b,c);printf("a and b 另辟空间交集（可以出现相同元素） is:\n");Print(c);InterSet2(a,b,d);printf("a and b 利用a表空间进行交集（不可以出现相同元素）is:\n");Print(d);}六、顺序表逆向求交集（真题：0501）：#include "stdafx.h"#include <stdio.h>#include <malloc.h>#define Initsize 100#define Increment 10typedef struct {int *elem;int length;int Listsize;}SqList;int N=5; //假设顺序表中各有五个元素void InitList(SqList &L){L.elem=(int*)malloc(Initsize*sizeof(int));if(!L.elem) return;L.length=0;L.Listsize=Initsize;}//InitListvoid CreateList(SqList &L){int i;char c;for(i=0;i<N;i++){scanf("%d",&L.elem[i]);c=getchar();L.length++;}}//CreateListvoid InsertList(SqList &L,int e){if(L.length>=L.Listsize){int *newbase;newbase=(int*)realloc(L.elem,(Initsize+Increment)*sizeof(int));L.elem=newbase;}//ifL.elem[L.length]=e;L.length++;}//InsertListvoid Print(SqList L){int i;for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);}//Printvoid Interset(SqList A,SqList B){SqList C;InitList(C);int i,j;j=B.length-1;for(i=A.length-1;i>=0;i--){while(B.elem[j]>=A.elem[i]){if(B.elem[j]==A.elem[i]){InsertList(C,B.elem[j]);}j=j-1;}//while}//forprintf("逆向合并后的元素为:\n");Print(C);}//Intersetvoid main(int argc, char* argv[]){SqList A,B;InitList(A);InitList(B);printf("请输入顺序表A元素(5ge):\n");CreateList(A);printf("请输入顺序表B元素(5ge):\n");CreateList(B);Interset(A,B);printf("\n");}七、单链表元素反向逆置（真题：0502）：#include "stdafx.h"#include <stdio.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int n;void CreateList(LinkList &L){LinkList P,Q;int i;L=(LinkList)malloc(sizeof(LNode));P=L;char c;for(i=0;i<n;i++){Q=(LinkList)malloc(sizeof(LNode));scanf("%d",&Q->data);c=getchar();P->next=Q;P=P->next;}//forP->next=NULL;}void InverseList(LinkList &L){LinkList P,Q;P=L->next;L->next=NULL;while(P){Q=P;P=P->next;Q->next=L->next;L->next=Q;}//while}void PrintList(LinkList L){LinkList p;p=L->next;while(p){printf("%d \n",p->data);p=p->next;}}void main(int argc, char* argv[]){LinkList L;printf("请输入链表元素个数:\n");scanf("%d",&n);printf("请输入链表元素:\n");CreateList(L);InverseList(L);printf("反向逆置后的链表元素为:\n");PrintList(L);}八、指定结点与后一个结点交换（真题0703）：#include "stdafx.h"#include <stdio.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int n; //链表元素个数void Exchange(LinkList &L,LinkList P){//将P所指的元素与其后一个元素进行交换LinkList Q;Q=L;while(Q->next!=P) Q=Q->next;Q->next=P->next;P->next=Q->next->next;Q->next->next=P;}//Exchangevoid CreateList(LinkList &L){//构造链表LinkList P,Q;int i;L=(LinkList)malloc(sizeof(LNode));P=L;for(i=0;i<n;i++){Q=(LinkList)malloc(sizeof(LNode));scanf("%d",&Q->data);P->next=Q;P=P->next;}//forP->next=NULL;}//CreateListvoid PrintList(LinkList &L){//打印链表所有元素LinkList P;P=L->next;while(P){printf("%d ",P->data);P=P->next;}}//PrintListvoid main(int argc, char* argv[]){LinkList List,P;printf("请输入链表元素个数:\n");scanf("%d",&n);printf("请输入链表元素:\n");CreateList(List);P=List->next->next->next; //假设p指向第三个结点Exchange(List,P);printf("P（假设指向第三个结点）与后一个结点交换后链表元素为:\n");PrintList(List);printf("\n");}九、静态链表（真题：0806）：#include "stdafx.h"#include <malloc.h>#define MAXSIZE 11typedef struct{int data; //存储数据int cur;}component,SLinkList[MAXSIZE];void InitSpace_SL(SLinkList &space){//将一维数组space中各分量连成一个备用链表，space[0].cur为头指针，//“0”表示空指针int i;for(i=0;i<MAXSIZE-1;++i) space[i].cur=i+1;space[MAXSIZE-1].cur=0;}//InitSpace_SLint Malloc_SL(SLinkList &space){//若备用空间链表非空，则返回分配的结点下标，否则返回0int i;i=space[0].cur;if(space[0].cur) space[0].cur=space[i].cur;return i;}//Malloc_SLvoid print(SLinkList space,int s){int i;printf("元素为:\n");for(i=space[s].cur;i<space[0].cur;i++){printf("%d",space[i].data);}//forprintf("\n");}//printvoid Free_SL(SLinkList &space,int k){//将下标为k的空闲结点回收到备用链表space[k].cur=space[0].cur;space[0].cur=k;}//Free_SLvoid Difference(SLinkList &space){//依次输入集合A与B的元素，在一维数组space中建立（A-B）U（B-A）//的静态链表，s为其头指针。

C数据结构实例代码

C数据结构实例代码

C数据结构实例代码C语言是一种通用的高级程序设计语言，也是实现数据结构的一种常用语言。

下面是一些常见的数据结构的示例代码，供参考。

1. 数组（Array）```c#include <stdio.h>int maiint arr[5] = {1, 2, 3, 4, 5}; // 创建一个有5个元素的整数数组for(int i=0; i<5; i++)printf("%d ", arr[i]); // 遍历并输出数组的所有元素}return 0;```2. 链表（Linked List）```c#include <stdio.h>#include <stdlib.h>struct Nodeint data;struct Node* next;};void printList(struct Node* head)struct Node* curr = head;while(curr != NULL)printf("%d ", curr->data);curr = curr->next;}void insert(struct Node** head, int data)struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->next = (*head);(*head) = newNode;int maistruct Node* head = NULL;insert(&head, 5);insert(&head, 4);insert(&head, 3);insert(&head, 2);insert(&head, 1);printList(head); // 输出链表的所有元素return 0;```3. 栈（Stack）```c#include <stdio.h>#define SIZE 5int stack[SIZE];int top = -1;int isEmptreturn top == -1;int isFulreturn top == SIZE - 1;void push(int item)if(isFull()printf("Stack is full.\n");} elsestack[++top] = item;printf("Pushed %d\n", item);}void poif(isEmpty()printf("Stack is empty.\n");} elseprintf("Popped %d\n", stack[top--]); }int maipush(1);push(2);push(3);pop(;push(4);push(5);push(6);pop(;return 0;```4. 队列（Queue）```c#include <stdio.h>#define SIZE 5int queue[SIZE];int front = -1; // 队头指针int rear = -1; // 队尾指针int isEmptreturn front == -1 && rear == -1; int isFulreturn rear == SIZE - 1;void enqueue(int item)if(isFull()printf("Queue is full.\n");} elseif(isEmpty()front = rear = 0;} elserear++;}queue[rear] = item;printf("Enqueued %d\n", item);}void dequeuif(isEmpty()printf("Queue is empty.\n");} elseprintf("Dequeued %d\n", queue[front]); if(front == rear)front = rear = -1;} elsefront++;}}int maienqueue(1);enqueue(2);enqueue(3);dequeue(;enqueue(4);enqueue(5);enqueue(6);dequeue(;return 0;```5. 树（Tree）```c#include <stdio.h>#include <stdlib.h>struct Nodeint data;struct Node* left;struct Node* right;};struct Node* create(int data)struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;void inorder(struct Node* root)if(root != NULL)inorder(root->left);printf("%d ", root->data);inorder(root->right);}int maistruct Node* root = create(1);root->left = create(2);root->right = create(3);root->left->left = create(4);root->left->right = create(5);root->right->left = create(6);root->right->right = create(7);printf("Inorder traversal of the tree: "); inorder(root); // 中序遍历树return 0;```。

数据结构代码汇总

数据结构代码汇总

数据结构代码汇总数据结构代码汇总1.数组 (Array)●创建数组●访问数组元素●修改数组元素●数组长度●遍历数组●数组排序算法2.链表 (Linked List)●单向链表●创建链表●插入节点●删除节点●链表长度●遍历链表●双向链表●创建链表●插入节点●删除节点●链表长度●遍历链表3.栈 (Stack)●创建栈●入栈●出栈●栈顶元素●栈的大小●判断栈是否为空4.队列 (Queue)●创建队列●入队●出队●队首元素●队列大小●判断队列是否为空5.哈希表 (Hash Table)●创建哈希表●哈希函数●插入元素●删除元素●查找元素●哈希表大小●哈希表是否为空6.树 (Tree)●二叉树 (Binary Tree)●创建二叉树●插入节点●删除节点●遍历二叉树 (前序、中序、后序)●二叉树的高度●二叉搜索树 (Binary Search Tree)●创建二叉搜索树●插入节点●删除节点●查找节点●遍历二叉搜索树 (中序)●二叉搜索树的高度●平衡二叉树 (AVL Tree)●创建平衡二叉树●插入节点●删除节点●遍历平衡二叉树 (前序、中序、后序)●平衡二叉树的高度●红黑树 (Red-Black Tree)●创建红黑树●插入节点●遍历红黑树 (中序)●红黑树的高度7.图 (Graph)●创建图●添加顶点●添加边●删除顶点●删除边●广度优先搜索 (BFS)●深度优先搜索 (DFS)●图的连通性●最短路径算法 (Dijkstra、Floyd-Warshall)●最小树算法 (Prim、Kruskal)8.堆 (Heap)●创建堆●插入元素●堆的大小●堆排序9.字典树 (Trie)●创建字典树●插入单词●查找单词●删除单词●字典树中的前缀数量●字典树中的单词数量10.图算法 (Graph Algorithms)●拓扑排序●强连通分量 (SCC)●最短路径算法 (Dijkstra、Bellman-Ford)●最小树算法 (Prim、Kruskal)●最大流算法 (Ford-Fulkerson、Edmonds-Karp)本文档涉及附件：附件1：数组代码实现示例附件2：链表代码实现示例附件3：栈代码实现示例附件4：队列代码实现示例附件5：哈希表代码实现示例附件6：树代码实现示例附件7：图代码实现示例附件8：堆代码实现示例附件9：字典树代码实现示例附件10：图算法代码实现示例本文所涉及的法律名词及注释：1.数组 (Array)：在计算机科学中，是一种由固定数量元素组成的集合。

《数据结构》的全部代码实现C语言

《数据结构》的全部代码实现C语言

/* c1.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等*/#include<limits.h> /* INT_MAX等*/#include<stdio.h> /* EOF(=^Z或F6),NULL */#include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE *//* algo2-1.c 实现算法2.1的程序*/#include"c1.h"typedef int ElemType;#include"c2-1.h"/*c2-1.h 线性表的动态分配顺序存储结构*/#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/#define LISTINCREMENT 2/* 线性表存储空间的分配增量*/typedef struct{ElemType*elem; /* 存储空间基址*/int length; /* 当前长度*/int listsize; /* 当前分配的存储容量(以sizeof(ElemType)为单位) */}SqList;#include"bo2-1.c"/* bo2-1.c 顺序表示的线性表(存储结构由c2-1.h定义)的基本操作(12个) */ Status InitList(SqList*L) /* 算法2.3 */{ /* 操作结果：构造一个空的顺序线性表*/(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!(*L).elem)exit(OVERFLOW); /* 存储分配失败*/(*L).length=0; /* 空表长度为0 */(*L).listsize=LIST_INIT_SIZE; /* 初始存储容量*/return OK;}Status DestroyList(SqList*L){ /* 初始条件：顺序线性表L已存在。

数据结构(严蔚敏)上机代码完整版

数据结构(严蔚敏)上机代码完整版

数据结构第一、二次上机：#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define list_init_size 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量typedef int Status;typedef int ElemType;typedef struct{ElemType *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量（以sizeof(ElemType)为单位）}SqList;Status InitList_Sq(SqList &L){//构造一个空的线性表LL.elem =(ElemType * )malloc(list_init_size*sizeof(ElemType));if(!L.elem )exit(OVERFLOW);//存储分配失败L.length =0; //空表长度为0L.listsize =list_init_size;//初始存储容量return OK;}//Initlist_SqStatus ListInsert_Sq(SqList &L,int i,ElemType e){//在顺序线性表L中第i个位置之前插入新的元素e，//i的合法值为1<=i<=ListLength_Sq(L)+1ElemType *p,*q,*newbase; //定义指针if(i<1||i>L.length +1)return ERROR; //i值不合法if(L.length >=L.listsize ){ //当前存储空间已满，增加分配newbase=(ElemType * )realloc(L.elem ,(L.listsize +LISTINCREMENT)*sizeof(ElemType));if(!newbase)exit(OVERFLOW); //存储分配失败L.elem =newbase; //新基址L.listsize +=LISTINCREMENT; //增加存储容量}q=&(L.elem [i-1]); //q为插入位置for(p=&(L.elem [L.length -1]);p>=q;--p)*(p+1)=*p; //插入位置及之后的元素右移*q=e; //插入e++L.length ; //表长增1return OK;}//ListInsert_SqStatus ListDelete_Sq(SqList &L,int i,ElemType &e){//在顺序线性表L中删除第i个元素，并用e返回其值//i的合法值为1<=i<=ListLength_Sq(L)ElemType *p,*q; //定义指针if((i<1) || (i>L.length ))return ERROR; //i值不合法p=&(L.elem [i-1]); //p为被删除元素的位置e=*p; //被删除元素的值赋给eq=L.elem +L.length -1; //表尾元素的位置for(++p;p<=q;++p)*(p-1)=*p; //被删除元素之后的元素左移--L.length ; //表长减1return OK;}//ListDelete_sqvoid display(SqList L){ //定义for循环函数int i;for(i=0;i<=L.length -1;i++)printf("%d\n",L.elem [i]);}int LocateElem_Sq(SqList L,ElemType e){//在顺序线性表L中查找第1个值与e满足compare()的元素的位序//若找到，则返回其在L中的位序，否则返回0ElemType *p;int i=1; //i的初值为第一个元素的位序p=L.elem ; //p的初值为第一个元素的存储位置while(i<=L.length && *p++!=e) ++i;if(i<=L.length) return i;else return 0;}//LocateElem_Sqvoid MergeList_Sq(SqList La,SqList Lb,SqList &Lc ){//已知顺序线性表La和Lb的元素按值非递减排列//归并La和Lb得到新的顺序线性表Lc，Lc的元素也按非递减排列ElemType *pa,*pb,*pc,*pa_last,*pb_last;pa=La.elem ;pb=Lb.elem ;Lc.listsize =Lc.length =La.length +Lb.length ;pc=Lc.elem =(ElemType *)malloc(Lc.listsize *sizeof(ElemType));if(!Lc.elem )exit(OVERFLOW); //存储分配失败pa_last=La.elem +La.length -1;pb_last=Lb.elem +Lb.length -1;while(pa<=pa_last && pb<=pb_last){//归并if(*pa<=*pb)*pc++=*pa++;else*pc++=*pb++;}while(pa<=pa_last) *pc++=*pa++; //插入La的剩余元素while(pb<=pb_last) *pc++=*pb++; //插入Lb的剩余元素}//MergeList_Sqvoid main(){/*SqList L;//定义线性表InitList_Sq(L);//调用空表//插入数据ListInsert_Sq(L,1,10);ListInsert_Sq(L,2,20);ListInsert_Sq(L,1,30);ListInsert_Sq(L,3,40);printf("插入后：\n");display(L);//调用循环函数ListInsert_Sq(L,3,100);//在L表第三个位置插入100printf("插入后：\n");display(L);ElemType e;//定义eListDelete_Sq(L,3,e);//删除L表的第三个元素，用e表示printf("删除后：\n");display(L);printf("被删除元素：%d\n\n\n\n",e);*/SqList La,Lb,Lc;InitList_Sq(La);ListInsert_Sq(La,1,3);ListInsert_Sq(La,2,5);ListInsert_Sq(La,3,8);ListInsert_Sq(La,4,11);printf("La插入后：\n");display(La);InitList_Sq(Lb);ListInsert_Sq(Lb,1,2);ListInsert_Sq(Lb,2,6);ListInsert_Sq(Lb,3,8);ListInsert_Sq(Lb,4,9);ListInsert_Sq(Lb,5,11);。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

(线性表顺序存储）#include"string.h"#include"ctype.h"#include"stdio.h"#include"stdlib.h"#include"io.h"#include"math.h"#include"time.h"#define OK1#define ERROR0#define TRUE1#define FALSE0#define MAXSIZE20/*存储空间初始分配量*/ typedef int Status;/*Status是函数的类型,其值是函数结果状态代码，如OK等*/typedef int ElemType;/*ElemType类型根据实际情况而定，这里假设为int*/Status visit(ElemType c){printf("%d",c);return OK;}typedef struct{ElemType data[MAXSIZE];/*数组，存储数据元素*/int length;/*线性表当前长度*/}SqList;/*初始化顺序线性表*/Status InitList(SqList*L){L->length=0;return OK;}/*初始条件：顺序线性表L已存在。

操作结果：若L为空表，则返回TRUE，否则返回FALSE*/Status ListEmpty(SqList L){if(L.length==0)return TRUE;elsereturn FALSE;}/*初始条件：顺序线性表L已存在。

操作结果：将L重置为空表*/Status ClearList(SqList*L){L->length=0;return OK;}/*初始条件：顺序线性表L已存在。

操作结果：返回L 中数据元素个数*/int ListLength(SqList L){return L.length;}/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*/ /*操作结果：用e返回L中第i个数据元素的值,注意i 是指位置，第1个位置的数组是从0开始*/Status GetElem(SqList L,int i,ElemType*e){if(L.length==0||i<1||i>L.length)return ERROR;*e=L.data[i-1];return OK;}/*初始条件：顺序线性表L已存在*//*操作结果：返回L中第1个与e满足关系的数据元素的位序。

*//*若这样的数据元素不存在，则返回值为0*/int LocateElem(SqList L,ElemType e){int i;if(L.length==0)return0;for(i=0;i<L.length;i++){if(L.data[i]==e)break;}if(i>=L.length)return0;return i+1;}/*初始条件：顺序线性表L已存在,1≤i≤ListLength(L)，*/ /*操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1*/Status ListInsert(SqList*L,int i,ElemType e){int k;if(L->length==MAXSIZE)/*顺序线性表已经满*/return ERROR;if(i<1||i>L->length+1)/*当i比第一位置小或者比最后一位置后一位置还要大时*/return ERROR;if(i<=L->length)/*若插入数据位置不在表尾*/{for(k=L->length-1;k>=i-1;k--)/*将要插入位置之后的数据元素向后移动一位*/L->data[k+1]=L->data[k];}L->data[i-1]=e;/*将新元素插入*/L->length++;return OK;}/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*/ /*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1*/Status ListDelete(SqList*L,int i,ElemType*e){int k;if(L->length==0)/*线性表为空*/ return ERROR;if(i<1||i>L->length)/*删除位置不正确*/return ERROR;*e=L->data[i-1];if(i<L->length)/*如果删除不是最后位置*/{for(k=i;k<L->length;k++)/*将删除位置后继元素前移*/L->data[k-1]=L->data[k];}L->length--;return OK;}/*初始条件：顺序线性表L已存在*//*操作结果：依次对L的每个数据元素输出*/Status ListTraverse(SqList L){int i;for(i=0;i<L.length;i++)visit(L.data[i]);printf("\n");return OK;}void unionL(SqList*La,SqList Lb){int La_len,Lb_len,i;ElemType e;La_len=ListLength(*La);Lb_len=ListLength(Lb);for(i=1;i<=Lb_len;i++){GetElem(Lb,i,&e);if(!LocateElem(*La,e))ListInsert(La,++La_len,e);}}int main(){SqList L;SqList Lb;ElemType e;Status i;int j,k;i=InitList(&L);printf("初始化L后：L.length=%d\n",L.length);for(j=1;j<=5;j++)i=ListInsert(&L,1,j);printf("在L的表头依次插入1～5后：L.data=");ListTraverse(L);printf("L.length=%d\n",L.length);i=ListEmpty(L);printf("L是否空：i=%d(1:是0:否)\n",i);i=ClearList(&L);printf("清空L后：L.length=%d\n",L.length);i=ListEmpty(L);printf("L是否空：i=%d(1:是0:否)\n",i);for(j=1;j<=10;j++)ListInsert(&L,j,j);printf("在L的表尾依次插入1～10后：L.data=");ListTraverse(L);printf("L.length=%d\n",L.length);ListInsert(&L,1,0);printf("在L的表头插入0后：L.data=");ListTraverse(L);printf("L.length=%d\n",L.length);GetElem(L,5,&e);printf("第5个元素的值为：%d\n",e);for(j=3;j<=4;j++){k=LocateElem(L,j);if(k)printf("第%d个元素的值为%d\n",k,j);elseprintf("没有值为%d的元素\n",j);}k=ListLength(L);/*k为表长*/for(j=k+1;j>=k;j--){i=ListDelete(&L,j,&e);/*删除第j个数据*/if(i==ERROR)printf("删除第%d个数据失败\n",j);elseprintf("删除第%d个的元素值为：%d\n",j,e);}printf("依次输出L的元素：");ListTraverse(L);j=5;ListDelete(&L,j,&e);/*删除第5个数据*/printf("删除第%d个的元素值为：%d\n",j,e);printf("依次输出L的元素：");ListTraverse(L);//构造一个有10个数的Lbi=InitList(&Lb);for(j=6;j<=15;j++)i=ListInsert(&Lb,1,j);unionL(&L,Lb);printf("依次输出合并了Lb的L的元素：");ListTraverse(L);system("pause");return0;}(线性表链式存储）#######开头省略#define MAXSIZE20/*存储空间初始分配量*/typedef int Status;/*Status是函数的类型,其值是函数结果状态代码，如OK等*/typedef int ElemType;/*ElemType类型根据实际情况而定，这里假设为int*/Status visit(ElemType c){printf("%d",c);return OK;}typedef struct Node{ElemType data;struct Node*next;}Node;typedef struct Node*LinkList;/*定义LinkList*//*初始化顺序线性表*/Status InitList(LinkList*L){*L=(LinkList)malloc(sizeof(Node));/*产生头结点,并使L指向此头结点*/if(!(*L))/*存储分配失败*/return ERROR;(*L)->next=NULL;/*指针域为空*/return OK;}/*初始条件：顺序线性表L已存在。

操作结果：若L为空表，则返回TRUE，否则返回FALSE*/Status ListEmpty(LinkList L){if(L->next)return FALSE;elsereturn TRUE;}/*初始条件：顺序线性表L已存在。

相关文档
最新文档