精华内容
下载资源
问答
  • 链表的基本操作C语言程序,后附结果,复制粘贴到VC6.0C++中,建立相应的文件,添加即可
  • C语言实现单链表的各种基本操作
  • 链栈的基本操作C语言详解

    千次阅读 多人点赞 2020-03-24 12:43:31
    存储结构如 5. 编译环境:vc6.0。 代码如下: #include #include //存储类型结构 typedef struct StackNode { int data; //结点数据 struct StackNode* next; //结点指针 }StackNode, * LinkStack;...

    1. 带头结点和不带头结点的链栈实现方式不同,我这里是不带头结点的链栈。
    2. 头指针(Lhead):不是头结点的指针,是指向头结点(首元结点)的指针,无论链栈是否为空,头指针均存在。
    3. 二级指针:指向指针变量的指针。
    4. 存储结构如图在这里插入图片描述
    5. 编译环境:vc6.0。

    代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    
    //存储类型结构
    typedef struct StackNode
    {
    	int data;								 //结点数据
    	struct StackNode* next;					//结点指针
    }StackNode, * LinkStack;
    
    //***********************销毁链栈****************************
    int DestoryLinkStack(LinkStack* Lhead)						//形参接收头指针地址(二级指针)                           
    {
    	StackNode* p, * q;										//结点指针
    	p = (*Lhead)->next;										//指向第二个结点
    	q = *Lhead;												//q指向首元结点
    	while (p)											  //第二个结点不为空
    	{
    		free(q);                                        //释放首元结点
    		q = p;											//q指向新首元结点
    		p = p->next;									//p->指向新的第二结点
    	}
    	free(q);										 //释放首元结点
    	*Lhead = NULL;									 //头指针指向空,头指针是指向首元结点的指针
    	return 1;
    }
    
    //**********************判断链栈是否为空*********************
    int LinkStackEmpty(StackNode* Lhead)			 //判断链栈是否非空
    {
    	if (Lhead == NULL)
    		return 1;
    	else return 0;
    }
    
    //*************************入栈**************************
    int Push(LinkStack* Lhead, int e)									//形参Lhead接收头指针地址(二级指针),e接收入队元素值
    {
    	LinkStack s = (LinkStack)malloc(sizeof(StackNode));				 //动态申请内存
    	if (s == NULL)													//申请失败
    	{
    		printf("动态内存申请失败\n");
    		return 0;
    	}
    	s->data = e;
    	s->next = *Lhead;										 //插入新结点
    	*Lhead = s;												//头指针指向新首元结点
    	return 1;
    }
    
    //****************************出栈***************************
    int Pop(LinkStack* Lhead, int* e)                           //形参Lhead接收头指针地址(二级指针),e接收入队元素值       
    {
    	StackNode* p = *Lhead;									//p指向首元结点
    	if (LinkStackEmpty(p))                               //若空                
    		return 0;
    	*e = p->data;                                          //获取返回值
    	*Lhead = p->next;                                       //出栈,Lhead指针下移
    	free(p);												//释放首元结点
    	return 1;
    }
    
    //************************************遍历输出*******************************
    int StackTraverse(StackNode* Lhead)							//形参Lhead接收头指针
    {
    	StackNode* p = Lhead;									//头指针赋值给p
    	if (p == NULL)											//栈空,头指针指向空
    		return 0;
    	while (p != NULL)											//头指针不指向NULL
    	{
    		printf("%-5d", p->data);							//打印数据
    		p = p->next;
    	}
    	return 1;
    }
    
    int main()
    {
    	int i, e, n;                                  //e结点元素,n元素个数
    	LinkStack Lhead = NULL;                    //头指针,初始化为空
    	if (LinkStackEmpty(Lhead))
    		printf("链表为空\n");
    	else printf("链表不为空\n");
    
    	printf("输入插入元素个数\n");                    //插入测试
    	scanf("%d", &n);
    	for (i = 0; i < n; i++)
    	{
    		printf("输入元素第%d个元素e的值\n", i + 1);
    		scanf("%d", &e);
    		if (Push(&Lhead, e))
    			printf("进栈成功\n");
    		else printf("进栈失败\n");
    	}
    	if (!StackTraverse(Lhead))                         //遍历输出测试
    		printf("链栈为空\n");
    
    	if (Pop(&Lhead, &e))								//出栈测试
    		printf("\n\n元素%d出栈\n", e);
    	else printf("\n出栈失败\n");
    	printf("出栈后\n");
    	if (!StackTraverse(Lhead))							 //遍历输出测试
    		printf("链栈为空\n");
    
    	if (LinkStackEmpty(Lhead))                         //判空测试
    		printf("链表为空\n");
    	else printf("链表不为空\n");
    
    	DestoryLinkStack(&Lhead);								//销毁测试
    	printf("销毁后\n");
    	if (!StackTraverse(Lhead))
    		printf("链栈为空\n");
    
    	return 0;
    }
    

    测试结果
    在这里插入图片描述

    展开全文
  • 【数据结构严蔚敏】 第三章 队列基本操作C语言 队列基本操作与栈类似,区别是删除元素时根据先进先出原则(FIFO),下面给出链队列的基本操作。 代码部分 1.基本结构定义 typedef int QElemType; //元素类型 ...

    【数据结构严蔚敏】 第三章 队列基本操作C语言

    队列基本操作与栈类似,区别是删除元素时根据先进先出原则(FIFO),下面给出链队列的基本操作。

    代码部分

    1.基本结构定义

    typedef int QElemType;	//元素类型
    typedef int Status;		
    typedef struct QNode {
    	QElemType data;
    	struct QNode *next;
    }QNode,*QueuePtr;
    
    typedef	struct {
    	QueuePtr front;	//对头指针
    	QueuePtr rear;	//队尾指针
    }LinkQueue;
    

    2.基本操作函数声明 LinkQueue.h

    //构造一个空队列
    Status InitQueue(LinkQueue &Q);
    
    //销毁队列Q,Q不再存在
    Status DetroyQueue(LinkQueue &Q);
    
    //将Q清为空队列
    Status ClearQueue(LinkQueue &Q);
    
    //若Q为空队列,则返回TRUE,否则返回FLASE
    Status QueueEmpty(LinkQueue Q);
    
    //返回Q的元素个数
    int QueueLenth(LinkQueue Q);
    
    //若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR
    Status GetHead(LinkQueue Q, QElemType &e);
    
    //插入元素e为Q的新的队尾元素
    Status EnQueue(LinkQueue &Q, QElemType e);
    
    //若队列不空,则删除Q的队头元素,用e返回其值,并返回OK
    Status DeQueue(LinkQueue &Q, QElemType &e);
    
    //对队列所有元素依次进行visit()操作
    Status QueueTraverse(LinkQueue Q, Status(*visit)(QueuePtr));
    

    3.基本操作函数定义 LinkQueue.c

    #include "LinkQueue.h"
    
    Status InitQueue(LinkQueue & Q)
    {
    	//构造一个空队列Q
    	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
    	if (!Q.front)exit(OVERFLOW);
    	Q.front->next = NULL;
    	return OK;
    }
    
    Status DetroyQueue(LinkQueue & Q)
    {
    	//销毁一个队列
    	while (Q.front) {
    		Q.rear = Q.front->next;
    		free(Q.front);
    		Q.front = Q.rear;
    	}
    	return OK;
    }
    
    Status ClearQueue(LinkQueue & Q)
    {	//清除一个队列
    	while (Q.front->next) {
    		Q.rear = Q.front->next;
    		free(Q.front);
    		Q.front = Q.rear;
    	}
    	Q.front->next = NULL;
    	return OK;
    }
    
    Status QueueEmpty(LinkQueue Q)
    {	//判断队列是否为空
    	if (Q.front == Q.rear) return TRUE; 
    	return FALSE;
    }
    
    int QueueLenth(LinkQueue Q)
    {	//返回队列长度	
    	QueuePtr p;
    	p = Q.front;
    	int i=0;
    	while (!(p==Q.rear)) {
    		i++;
    		p = p->next;
    	}
    	return i;
    }
    
    Status GetHead(LinkQueue Q, QElemType & e)
    {
    	//
    	if (Q.front == Q.rear)return ERROR;
    	e = Q.front->next->data;
    	return OK;
    }
    
    Status EnQueue(LinkQueue & Q, QElemType e)
    {	//插入元素e为Q的新的队尾元素
    	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    	if (!p)return ERROR;
    	p->next = NULL;
    	p->data = e;
    	Q.rear->next = p;
    	Q.rear = p;
    	return OK;
    }
    
    Status DeQueue(LinkQueue & Q, QElemType & e)
    {//若队列不空,则删除Q的队头元素,用e返回其值,并返回OK
    	if (Q.front == Q.rear)return ERROR;
    	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));   //此处为何要给p申请空间?
    	p = Q.front->next;								//Q.front->next已经申请过内存空间
    	e = p->data;									//p = Q.front->next之后
    	Q.front->next = p->next;						//free(p)free的是哪一块?
    	if (Q.rear == p)Q.rear = Q.front;
    	free(p);
    	return OK;
    }
    
    Status QueueTraverse(LinkQueue Q, Status(*visit)(QueuePtr))
    {
    	QueuePtr p;
    	p = Q.front;
    	while (p->next)
    	{
    		p = p->next;
    		if (!(visit(p)))return ERROR;
    	}
    	return OK;
    }
    

    4.测试

    #include"LinkQueue.h"
    int visit(QueuePtr p) {
    	//visit函数用来输出队列
    	cout << p->data<<" ";
    	return OK;
    }
    int main() {
    	LinkQueue Q;
    	InitQueue(Q);
    	cout << "空队列初始化成功" << endl;
    	cout << "在队列中依次插入五个元素" << endl;
    	QElemType e;
    	for (int i = 0; i < 5; i++)
    	{
    		cin >> e;
    		EnQueue(Q, e);
    	}
    	cout << "输出整个队列" << endl;
    	QueueTraverse(Q,visit);
    	DeQueue(Q, e);
    	cout << endl;
    	cout << "删除队头元素,输出整个队列" << endl;
    	QueueTraverse(Q, visit);
    	cout << endl<<"清空队列" << endl;
    	ClearQueue(Q);
    	cout << "输出整个队列" << endl;
    	QueueTraverse(Q, visit);
    	cout << endl << "销毁队列,结束" << endl;
    	DetroyQueue(Q);
    	system("pause");
    	return 0;
    }
    

    结果:
    在这里插入图片描述

    展开全文
  • 顺序表的基本操作 C语言实现 数据结构实验
  • 队列的基本操作 C语言命令选择型的测试程序,有相应的结果,将代码添加到相应的文件中,然后再VC6.0C++工程中添加即可
  • 包括线性表的各种基本操作C语言实现(不用库函数)
  • C语言实现关于二叉树的初始化、插入、删除、路径、等数据结构的操作
  • c语言基本操作

    2013-12-03 21:14:57
    c语言基本操作,链表的基本操作,在文件中要用到基本操作
  • 循环队列:把头尾相接的顺序存储结构称为循环队列

    循环队列:把头尾相接的顺序存储结构称为循环队列
    逻辑结构如图:在这里插入图片描述
    编译环境vc6.0,代码如下:

    /*
    保留一个空间来区分队空和队满
    队满时:(Q.rear+1)%MaxSize==Q.front
    初始时(队空):Q.front=Q.rear=0
    队首指针进1:Q.front=(Q.front+1)%MaxSize
    队尾指针进1:Q.rear=(Q.rear+1)%MaxSize
    队列长度:(Q.rear+MaxSize-Q.front)%MaxSize
    出队入队时:指针都是顺时针方向进1
    */
    
    #include <stdio.h>
    #include <stdlib.h>
    #define MaxSize 10
    
    //顺序队列存储结构
    typedef struct
    {
    	int data[MaxSize];                                     //存放队列元素
    	int front, rear;										//队头指针和队尾指针
    }SqQueue;
    
    //****************************初始化**************************
    int InitQueue(SqQueue* Q)
    {
    	Q->rear = Q->front = 0;
    	return 1;
    }
    
    //****************************判断是否为空**************************
    int isEmpty(SqQueue Q)
    {
    	if (Q.rear == Q.front)
    		return 1;
    	else return 0;
    }
    
    //****************************入队**************************
    int EnQueue(SqQueue* Q, int e)
    {
    	if ((Q->rear + 1) % MaxSize == Q->front)       //队满
    		return 0;
    	Q->data[Q->rear] = e;							//将元素e赋值给队尾
    	Q->rear = (Q->rear + 1) % MaxSize;				//rear指针后移,若到最后则转到数组头部
    	return 1;
    }
    
    //****************************出队**************************
    int DeQueue(SqQueue* Q, int* e)			
    {
    	if (Q->rear == Q->front)						//队空
    		return 0;
    	*e = Q->data[Q->front];								//对头元素赋值给e
    	Q->front = (Q->front + 1) % MaxSize;				//front指针后移,若到最后则转到数组头部
    	return 1;
    }
    
    //********************求顺序表长度*********************
    int QueueLength(SqQueue Q)
    {
    	return (Q.rear + MaxSize - Q.front) % MaxSize;
    }
    
    int main()
    {
    	int i, e, n;						//e入队元素,n入队元素个数
    	SqQueue Q;
    	InitQueue(&Q);						//初始化测试
    	printf("初始化成功\n");
    	if (isEmpty(Q))
    		printf("队列为空\n");
    	else printf("队列不为空\n");
    
    	printf("请输入入队元素个数\n");					//入队测试
    	scanf("%d", &n);
    	for (i = 0; i < n; i++)
    	{
    		printf("请输入第%d个元素值", i + 1);
    		scanf("%d", &e);
    		if (EnQueue(&Q, e))
    			printf("入队成功\n");
    		else printf("入队失败\n");
    	}
    
    	if (DeQueue(&Q, &e))							//出队测试
    		printf("\n元素%d出队\n", e);
    	else printf("出队失败\n");
    
    	printf("链表长度为%d\n", QueueLength(Q));
    	return 0;
    }
    

    测试案例:
    在这里插入图片描述

    展开全文
  • 数据结构串 堆串基本操作C语言实现

    千次阅读 多人点赞 2019-03-12 19:40:42
    【数据结构】串 堆串的基本操作 以一组地址连续的存储单元存放串值字符序列,存储空间在程序执行过程中动态分配得到,操作灵活。 代码: 1.结构体定义 typedef struct { char * ch; //若是非空串,则按串长分配存储...

    【数据结构】串 堆串的基本操作

    以一组地址连续的存储单元存放串值字符序列,存储空间在程序执行过程中动态分配得到,操作灵活。

    代码:

    1.结构体定义
    typedef struct {
    	char * ch;	//若是非空串,则按串长分配存储区,否则ch为NULL
    	int length; //串长度
    }HString;
    
    2.基本操作函数声明
    // 基本操作的函数原型说明
    
    //初始化生成一个空串T
    Status StrInit(HString &T);
    
    //生成一个其值等于串常量chars的串T
    Status StrAssigh(HString &T, char * chars);
    
    //返回S的元素个数,称为串的长度
    int StrLength(HString S);
    
    //若S>T,则返回值大于0....
    Status StrCompare(HString S, HString T);
    
    //将S清为空串,并释放S所占空间 
    Status ClearString(HString &S);
    
    //用T返回由S1和S2联接而成的新串
    Status Concat(HString &T, HString S1, HString S2);
    
    //返回串S的第pos个字符起长度为len的子串
    Status SubString(HString &Sub,HString S, int pos, int len);
    
    3.函数定义
    #include "String.h"
    
    Status StrInit(HString & T)
    {
    	T.ch = NULL;
    	T.length = 0;
    	return OK;
    }
    
    Status StrAssigh(HString & T, char * chars)
    {
    	if (T.ch)free(T.ch);		//释放其原有空间
    	char* c = chars; int i = 0;
    	for (i = 0; *c; i++, ++c); //求chars的长度i
    	if (!i) {
    		T.ch = NULL;
    		T.length = 0;
    	}
    	else {
    		if (!(T.ch = (char*)malloc(i * sizeof(char)))) exit(OVERFLOW);
    		for (int  j = 0; j < i; j++)T.ch[j] = chars[j];
    		T.length = i;
    	}
    	return OK;
    }
    
    
    int StrLength(HString S)
    {
    	return S.length;
    }
    
    Status StrCompare(HString S, HString T)
    {
    	for (int i = 0; i < S.length&&i<T.length; i++)
    		if (S.ch[i] != T.ch[i])return S.ch[i] - T.ch[i];
    	return S.length - T.length;
    }
    
    Status ClearString(HString & S)
    {
    	if (S.ch) {
    		free(S.ch); S.ch = NULL;
    	}
    	S.length = 0;
    	return OK;
    }
    
    Status Concat(HString & T, HString S1, HString S2)
    {
    	if (T.ch) free(T.ch);	//释放旧空间
    	if (!(T.ch = (char*)malloc((S1.length + S2.length) * sizeof(char))))
    		exit(OVERFLOW);
    	for (int i = 0; i < S1.length; i++) T.ch[i] = S1.ch[i];
    	T.length = S1.length + S2.length;
    	for (int i = S1.length; i < T.length; i++) T.ch[i] = S2.ch[i-S1.length];
    	return OK;
    }
    
    Status SubString(HString &Sub,HString S, int pos, int len)
    {
    	if (pos<1 || pos>S.length || len<0 || len>S.length - pos + 1)return ERROR;
    	if (Sub.ch) free(Sub.ch);			//释放旧空间
    	if (!len) {
    		Sub.ch = NULL; Sub.length = 0;
    	}
    	else {
    		Sub.ch = (char*)malloc(len * sizeof(char));
    		for (int i = 0; i < len; i++)
    		{
    			Sub.ch[i] = S.ch[pos - 1 + i];
    		}
    		Sub.length = len;
    	}
    	return OK;
    }
    
    
    4.测试
    #include"String.h"
    using namespace std;
    
    void StrDisplay(HString S) {
    	//显示串
    	for (int i = 0; i < S.length; i++)
    	{
    		cout << S.ch[i];
    	}
    }
    int main() {
    	HString A;
    	StrInit(A);
    	HString B;
    	StrInit(B);
    	HString C;
    	StrInit(C);
    	char b[10] = "hello";
    	char c[10] = " world";
    
    	cout << "初始化B,显示B:" << endl;
    	StrAssigh(B, b);
    	StrDisplay(B);
    
    	cout << endl<<"初始化C,显示C:" << endl;
    	StrAssigh(C, c);
    	StrDisplay(C);
    	
    	cout << endl << "比较串B,C,返回一个数值" << endl;
    	cout << StrCompare(A, B);
    	
    	cout << endl<<"将B,C串联接成串A,输出A:" << endl;
    	Concat(A, B,C);
    	StrDisplay(A);
    
    	cout << endl << "输出串A第二个字符起后五个字符" << endl;
    	SubString(B, A, 2, 5);
    	StrDisplay(B);
    	cout << endl << "串长度为";
    	cout << StrLength(B);
    	
    	cout << endl;
    	system("pause");
    
    }
    

    测试结果:
    在这里插入图片描述

    展开全文
  • 【数据结构(严蔚敏)】 线性表基本操作C语言实现(单链表) vs2017 算法2.8–算法2.11 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;iostream&gt; using namespace std;...
  • #include<stdio.h> #include<stdlib.h> typedef struct node { int data; struct node *next; }node,*link; //初始化头结点,此时头指针就是头结点 void init(link p) { p->...}
  • C语言链表基本操作

    2012-11-03 08:16:47
    C语言链表基本操作
  • C语言数据结构之栈的基本操作,栈的各种操作C语言数据结构之栈的基本操作一.程序结构二.算法及其功能函数InitStack(SqStack *S)/*创建栈*/GetTop(SqStack *S,SElemType e) /*取栈顶元素并用e返回*/ Push(SqStack *S...
  • C语言实现栈的创建算法,进栈算法,出栈算法等的基本操作
  • 由于C语言实现了对硬件的编程操作,因此C语言集高级语言和低级语言的功能于一体。既可用于系统软件的开发,也适合于应用软件的开发。此外,C语言还具有效率高,可移植性强等特点。因此广泛地移植到了各类各型计算机...
  • C语言的一些基本操作

    2017-04-23 21:05:08
    一些基本C语言语法笔记
  • 栈的基本操作(C语言实现) 栈的基本操作(C语言实现) 栈的基本操作(C语言实现) //栈的基本操作 #define ERROR 0 #define OVERFLOW -2 #define Stack_init_size 100 #define Stackincrement 10 #include<malloc.h> #...
  • 栈的基本操作,顺序栈,链式栈,定义
  • 主要介绍了c语言实现顺序表的基本操作,需要的朋友可以参考下
  • 顺序存储结构线性表基本操作C语言实现 a simple example of Sq_List by C language by wangweinoo1[PG]
  • 线性表的基本操作 数据结构C语言实现
  • 顺序栈的基本操作-C语言

    千次阅读 多人点赞 2018-12-21 21:06:45
    顺序栈的基本操作 具体实现 顺序栈的定义 //定义一个顺序栈 #define STACK_INIT_SIZE 100 #define INCREMENT 10 typedef int ElemType; typedef struct { ElemType* base; ElemType* top; int stacksize; }...
  • 下面我们就一起来了解一下c语言中栈的基本操作C语言对栈的实现基本操作,操作如下: #include #include #include #include typedef struct Node { int data; struct Node * pNext; }NODE, * PNODE; ...
  • 数据结构-单链表基本操作-C语言代码

    万次阅读 多人点赞 2020-01-22 19:51:58
    单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码,具体思路讲解请看这篇博客:数据结构-线性结构-单链表 1.头插法建立单链表 #include<...
  • 基本操作及其C语言实现。 队列的基本操作有哪些 创建并初始化 清空/销毁队列 判断队列是否为空 队列遍历 获取队列大小 元素入队 元素出队 1. 链式队列的定义 //...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 256,869
精华内容 102,747
关键字:

图的基本操作c语言

c语言 订阅