8月6 双向循环链表 栈初学（顺序）

最新推荐文章于 2021-05-21 03:12:39 发布
最新推荐文章于 2021-05-21 03:12:39 发布
阅读量264 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fight5_j/article/details/81460444
版权

 

注释部分为双向链表 与 双向循环链表区别
此程序为完整双向循环链表




#include<stdlib.h>
#include"Linklist.h"
int Linkinit(Node **l)           
{
	*l = (Node *)malloc(sizeof(Node)*1);
	if(NULL == *l)
	{
		return FAILURE;
	}
	/*(*l)->next = NULL;   //双向链表
	(*l)->front = NULL;*/
	(*l)->next = *l;          // 双向循环
	(*l)->front = *l;
	return SUCCESS;
}
int Linkinsert(Node *l, int n, ElemType e)
{
	Node *p = l;
	int k = 1;
	if(NULL == l)
	{
		return FAILURE;
	}
	if(n > Linklength(l) + 1)
	{
		return FAILURE;
	}
	//while(k < n && p != NULL)
	while(k < n )        //**
	{
		p = p->next;
		k++;
	}
	// if(k < n || p == NULL)
	if(k > n )          //**
	{
		return FAILURE;
	}
	Node *q = (Node *)malloc(sizeof(Node)*1);
	if(NULL == q)
	{
		return FAILURE;
	}
	q->data = e;
	q->front = p;
	q->next = p->next;
	p->next = q;
	//if(q->next != NULL)      //**
	
		q->next->front = q;
	

	return SUCCESS;
}
int Linktraverse(Node *l,void (*p)(ElemType))
{
	if(NULL == l)
	{
		return FAILURE;
	}
	Node *q = l;
	while(q->next != l )           //不等于本身 **
	{
		q = q->next;
		p(q->data);
	}
	return SUCCESS;
}
/*int LinkReverse(Node *l)
{
	if(NULL == l)
	{
		return FAILURE;
	}
	Node *p = l->next;
	l->next = NULL;
	while(p != NULL)
	{	
		Node *q = p;
		p = p->next;
		q->next = l->next;
		l->next = q;
	}
	return SUCCESS;
}*/
int Linklength(Node *l)
{
	if(NULL == l)
	{
		return FAILURE;
	}
	int len = 0;
	Node *p = l->next;
	while(p != l)     // **
	{
		len++;
		p = p->next;
	}
	return len;
}
int Linkempty(Node *l)
{
	//return (l->next == NULL) ? TRUE :FALSE;  **
	return (l->next == l && l->front == l) ? TRUE : FALSE;
}
int Getelem(Node *l, int p,ElemType *e)  //p位置
{
	if(NULL == l || p < 1)
	{
		return FAILURE;
	}
	//Node *q = l; **
	Node *q = l->next;   //双向循环链表，q指向第一个结点  
	int i;
	//for(i = 0;i < p && q != NULL;i++) **
	for(i = 1;i < p && q != l; i++)  
	{
		q = q->next;
	}
	if(q == l)
	//if(!q)
	{
		return FAILURE;
	}
	*e = q->data;
	return SUCCESS;
}
int LocateElem(Node *l,ElemType e,int (*p)(ElemType, ElemType))
{
	if(NULL == l)
	{
		return FAILURE;
	}
	Node *q = l->next;
	int len = 1;
	while(q != l)       //双向循环链表 
	{
		if(p(e, q->data) == TRUE)
		{
			return len;
		}
		q = q->next;
		len++;
	}
	return FAILURE;
}
int LinkDelete(Node *l, int p, ElemType *e)
{
	Node *q = l;
	int k = 1;
	if(NULL == l)
	{
		return FAILURE;
	}
	//while(k < p && q != NULL) **
	while(k < p)
	{
		q = q->next;
		k++;
	}
	//if(k > p || q == NULL) **
	if(k > p)
	{
		return FAILURE;
	}
	Node *n = q->next;
	*e = n->data;
	q->next = n->next;
	//if(n->next != NULL)        **
	
		n->next->front = q;

	free(n);
	return SUCCESS;
}
int Linkclear(Node *l)
{
	if(NULL == l)
	{
		return FAILURE;
	}
	Node *p = l->next;
	while(p != l)   // **
	{
		l->next = p->next;
		free(p);
		p = l->next;
	}
	l->front = l;  //**
	return SUCCESS;
}
int LinkDestroy(Node **l)
{
	if(NULL == l)
	{
		return FAILURE;
	}
	free(*l);
	(*l) = NULL;
	return SUCCESS;
}











#include<stdio.h>
#include"Linklist.h"
void print(ElemType e)
{
	printf("%d ",e);
}
int equal(ElemType e1, ElemType e2)
{
	return (e1 == e2) ? TRUE : FALSE;
}
int main()
{
	srand(time(NULL));
	int ret, i;
	Node *first = NULL;
	ret = Linkinit(&first);
	 if(ret == FAILURE)
    {
        printf("Init Failure!\n");
    }
    else
    {
        printf("Init Success!\n");
    }
	for(i = 0;i < 10;i++)
	{	
		ret = Linkinsert(first,i + 1,rand() % 10);
		if(ret == FAILURE)
		{
			printf("Insert Failure!\n");
		}
		else
		{
			printf("Insert Success!\n");
		}
	}
	ret = Linktraverse(first, print);
	if(ret == FAILURE)
	{
		printf("\nTraverse Failure!\n");
	}
	else
	{
		printf("\nTraverse Success!\n");
	}
	/*ret = LinkReverse(first);
	if(ret == FAILURE)
	{
		printf("\nReverse Failure!\n");
	}
	else
	{
		printf("\nReverse Success!\n");
	}*/
	ret = Linktraverse(first, print);
	if(ret == FAILURE)
	{
		printf("\nTraverse Failure!\n");
	}
	else
	{
		printf("\nTraverse Success!\n");
	}
    ret = Linklength(first);
	if(ret == FAILURE)
	{
		printf("Get Length Failure!\n");
	}
	else
	{	
		printf("Length %d\n",ret);
	}
	ret = Linkempty(first);
	if(ret == TRUE)
	{
		printf("List is empty!\n");
	}
	else if(ret == FALSE)
	{	
		printf("List is not empty!\n");
	}
	int p = 3;
	ElemType e;
	ret = Getelem(first, p, &e);
	if(ret == FAILURE)
	{
			printf("Get element failure!n\n");
	}
	else
	{
		printf("The %dth element is %d\n", p, e);
	}
	e = 10;
	ret = LocateElem(first, e, equal);
	if(FAILURE == ret)
	{
		printf("%d not exist!\n", e);
	}
	else
	{	
		printf("%d is %dth element!\n", e, ret);
	}
	p = 3;
	ret = LinkDelete(first, p, &e);
	if(ret == FAILURE)
	{
		printf("Delete Failure!\n");
	}
	else
	{
		printf("Delete %d Success!\n",e);
	}
	ret = Linktraverse(first, print);
	if(ret == FAILURE)
	{
		printf("\nTraverse Failure!\n");
	}
	else
	{
		printf("\nTraverse Success!\n");
	}
	ret = LinkDestroy(&first);
	if(ret == SUCCESS)
	{
		printf("Destroy Success!\n");
	}
	else
	{
		printf("Destroy Failure!\n");
	}
	for(i = 0;i < 10;i++)
	{
		ret = Linkinsert(first, i + 1,rand() % 20);
		if(ret == FAILURE)
		{
			printf("Insert Failure!\n");
		}
		else
		{
			printf("Insert Success\n");
		}
	}
    return 0;
	
}








#ifndef _LINKLIST_H
#define _LINKLIST_H

#define FAILURE     10000
#define SUCCESS     10001
#define FALSE 		10002
#define TRUE 		10003

typedef int ElemType;
struct node
{
    ElemType data;
    struct node *next;
	struct node *front;

};
typedef struct node Node;
int Linkinit(Node **l);
int Linkinsert(Node *l,int n, ElemType e);
int Linktraverse(Node *l,void (*p)(ElemType));
int Linklength(Node *l);
int Getelem(Node *l, int p, ElemType *e);
int Linkempty(Node *l);
int LocateElem(Node *l, ElemType e, int (*p)(ElemType,ElemType));
int LinkDelete(Node *l, int p, ElemType *e);
int LinkReverse(Node *l);
int LinkDestroy(Node **l);
int Linkclear(Node *l);
#endif

 

顺序表与链表的比较

基于空间的比较

存储分配的方式 顺序表的存储空间是静态分配的 链表的存储空间是动态分配的

存储密度 = 结点数据本身所占的存储量/结点结构所占的存储总量

顺序表的存储密度 = 1 链表的存储密度 < 1

基于时间的比较

存取方式 

顺序表可以随机存取，也可以顺序存取 链表是顺序存取的

插入/删除时移动元素个数 顺序表平均需要移动近一半元素 链表不需要移动元素，只需要修改指针 若插入/删除仅发生在表的两端，宜采用带尾指针的循环链表

 

#include"SequenceStack.h"
#include<stdio.h>
int main()
{
    Stack *stack;
    int ret;
    ret = Stackinit(&stack);                 //stack是野指针，要修改stack的值（地址）
    if(ret == SUCCESS)
    {
        printf("Init Success!\n");
    }
    else
    {
        printf("Failure!\n");
    }
	ret = StackEmpty(stack);
	if(ret == TRUE)
	{
		printf("stack is empty\n");
	}
	else
	{
		printf("stack is not empty\n");
	}
	int i = 0;
	for(i = 0;i < 12;i++)
	{
		ret = push(stack, i + 1);
		if(ret == SUCCESS)
		{
			printf("push %d success\n",i + 1);
		}
		else if(ret == FAILURE)
		{
			printf("push %d failure\n",i + 1);
		}	
	}
	ret = GetTop(stack);
	if(ret == FAILURE)
	{
		printf("Get Top failure\n");
	}
	else
	{
		printf("Top is %d\n ",ret);
	}
	for(i = 0;i < 5;i++)
	{
		ret = pop(stack);
		if(ret == FAILURE)
		{
			printf("pop failure\n");
		}
		else
		{
			printf("pop success\n");
		}
	}
	ret = GetTop(stack);
	if(ret == FAILURE)
	{
		printf("Get Top failure\n");
	}
	else
	{
		printf("Top is %d\n",ret);
	}
	ret = StackClear(stack);
	if(ret == FAILURE)
	{
		printf("Clear failure\n");
	}
	else
	{
		printf("Clear success\n");
	}
	ret = StackDestroy(&stack);
	if(ret == FAILURE)
	{
		printf("Destroy failure\n");
	}
	else
	{
		printf("Destroy success\n");
	}
	for(i = 0;i < 12;i++)
	{
		ret = push(stack, i + 1);
		if(ret == SUCCESS)
		{
			printf("push %d success\n",i + 1);
		}
		else if(ret == FAILURE)
		{
			printf("push %d failure\n",i + 1);
		}	
	}

    return 0;
}

#include<stdlib.h>
#include"SequenceStack.h"

int Stackinit(Stack **s)
{
    (*s) = (Stack *)malloc(sizeof(Stack)*1);  //分配一个结构体，用于保存栈的信息
    if(NULL == *s)
    {
        return FAILURE;
    }
    (*s)->top = -1;                         //空栈  栈顶为-1
    (*s)->data =(ElemType *)malloc(sizeof(ElemType)*SIZE);       //为栈分配空间
    if(NULL == (*s)->data)
    {
        return FAILURE;
    }
    return SUCCESS;

}
int StackEmpty(Stack *s)
{
    return (s->top == -1) ? TRUE : FALSE;
}
int push(Stack *s, ElemType e)
{
    if(NULL == s || s->top == 9)         //入参判断
    {
        return FAILURE;
    }
    s->data[s->top + 1] = e;            //进栈
    s->top++;
    return SUCCESS;
}
int GetTop(Stack *s)
{
	if(s->top == -1)
	{
		return FAILURE;
	}
	return s->data[s->top];
}
int pop(Stack *s)
{
	if(s->top == -1)
	{
		return FAILURE;
	}
	s->top--;
	return SUCCESS;
}
int StackClear(Stack *s)
{
	if(s->top == -1)
	{
		return FAILURE;
	}
	s->top = -1;
	return SUCCESS;
}
int StackDestroy(Stack **s)
{
	if(s == NULL || *s == NULL)
	{
		return FAILURE;
	}
	free((*s)->data);
	free(*s);              
	*s = NULL;                         // 为了使其不成为野指针
	return SUCCESS;
	
}
#ifndef _SEQUENCESTACK_H
#define _SEQUENCESTACK_H

#define SUCCESS     10000
#define FAILURE     10001
#define TRUE        10002
#define FALSE       10003
#define SIZE   		10
typedef int ElemType;
typedef struct stack Stack;
struct stack
{
    int top;
    ElemType *data;
};
int Stackinit(Stack **s);
int StackEmpty(Stack *s);
int push(Stack *s, ElemType e);
int pop(Stack *s);
int GetTop(Stack *s);
int StackClear(Stack *s);
int StackDestroy(Stack **s);

#endif

 

 

fight5_j
关注
【数据结构】链表其实并不难 —— 手把手带你实现双向链表
StackFrame
11-10 3212
简述双向链表概念、C语言实现双向链表
Python全栈（二）数据结构和算法之5.双向链表的实现和栈的实现
CUFEECR的博客
11-14 1065
双向链表是一种又一种链表，其is_empty() 判断链表是否为空、length() 返回链表的长度、travel() 遍历、add(item) 在头部添加一个节点、append(item) 在尾部添加一个节点、insert(pos, item) 在指定位置pos添加节点、remove(item) 删除一个节点、search(item) 查找节点等操作与单链表、循环链表不完全一致。栈是一种后进先出的线性表，其实现依赖于顺序表或链表，相对于链表的实现更简单。有示意图相结合，简明清晰，适合初学者。
c语言之————有头循环双链表实现栈存储
long123bin的专栏
07-22 653
1、链表的实现 dlist.h
循环单链表，双向链表，顺序栈
Mars1997的博客
05-06 856
循环单链表 循环单链表是单链表的另一种形式，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。和单链表相同，循环链表也有带头结点结构和不带头结点结构两种，带头结点的循环单链表实现插入和删除操作较为方便。 package practice; class TestClink{ class Entry{//内部类 ...
双向循环链表，顺序栈
qq_42719683的博客
08-06 210
今日课程：双向链表                   双向循环链表                   顺序栈 顺序栈的排序：主函数代码如下： #include &lt;stdio.h&gt; #include "SequenceStack.h" int main() { int i, num, tmp; Stack *s1, *s2; if (StackInit(&amp;...
数据结构-双向循环链表
abcnull 的博客
02-15 641
文章目录简介Java 实现 简介 单链表对应着单向循环链表，即原来单链表最后一个结点指向本来为空，现在指向头结点；双向链表对应着双向循环链表，即原来双向链表最后一个结点的后驱结点为空，现在指向头结点，原来双向链表的头结点是没有前驱结点的，现在双向循环链表的头结点的前驱结点指向双向循环链表的尾结点 Java 实现 逻辑思路 逻辑上双向循环链表只不过是在双向链表上多加了循环这个条件，我们在初始化时候使...
双向链表简单的存储与排序
weixin_43913556的博客
03-18 1350
【问题描述】输入n个整数，创建一个双向循环链表进行存储。这些整数从第二个开始，递增有序（设a2<a3<…<an） (ai为第i个整数)。试编写程序，创建双向循环链表，依次将输入的整数存储在该链表的各节点中。然后，将第一个结点删除并插入链表中的适当位置，使整个链表递增有序。 【输入形式】先输入整数的个数，再输入整数列。 【输出形式】以整数递增的顺序，依次输出双向循环链表各个节点存储...
双向循环链表的创建,插入,读取，与删除操作
牛大春の博客
04-24 835
今天我学习了双向循环链表，不过与以往的不同，这次的双向循环链表 有坑，是巨坑… 我以为写的会很顺利 没想到 我竟然踩了“雷”… 好尴尬哦，下面我们来学习这个 双向循环链表把~ 对了，说一下为什么需要双向循环链表把，如果一个链表是单向的，那么，如果在读取过程中，要读取已读取数据的前一个 或者前面几个数据怎么办呢？ 比如 1–>2–>3–>4–>5 如果是循环链表的话，我读到了...
【数据结构】双向循环链表
xing1584114471的博客
10-10 378
（近期我在学习数据结构，于是我自己整理了单链表、循环单链表、双向链表、双向循环链表的相关代码，以巩固这段时间的学习，也希望能够帮助初学者，希望大家在阅读以下代码时发现问题纠正于我，一起探讨） CycDoubleList.h #ifndef __CYCDOUBLELISH_H #define __CYCDOUBLELISH_H #include<stdio.h> #include...
C++语言约瑟夫环，双向链表
11-17
此外，约瑟夫环问题有多种解决方案，如使用数组和位运算等，但使用双向链表能更好地模拟实际问题，对初学者理解链表和循环结构有很好的实践价值。通过学习这个案例，不仅可以提升C++编程技巧，还能加深对链表数据...
双向循环链表
qq_42232643的博客
08-06 100
#ifndef _LINKLIST_H #define _LINKLIST_H #define FAILURE 10000 #define SUCCESS 10001 #define TRUE 10002 #define FALSE 10003 typedef int ElemType; struct node //双向链表 { ElemTyp...
数据结构与算法--03 线性链表
吃不饱、力不足的博客
05-10 87
1. 线性链表 逻辑结构：线性表 存储结果：链式存储 2. 线性链表的表示 typedef struct Rectangle{//定义存储的元素，长方形 unsigned int lenth; unsigned int width; }ElemType; typedef struct LNode{//定义链表结构 ElemType data; struct LNode *next; }LNode,*LinkList; 3. 初始化一个空表 /* 初始化一
循环链表以及栈
weixin_41834187的博客
03-19 730
1.将单链表中终端结点的指针端由空指针改为指向头结点，就使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表。2.双向链表：双向链表是在单链表的每个结点中，再设置一个指向前驱结点的指针域；priordatanext           Pp-&gt;prior :P的前驱       p-&gt;data:p的数据域      p-&gt;next：p的指针域typedef struct D...
自己实现单链表Link-通俗易懂
蓝星花
06-07 1497
前言 链表在我们日常的开发过程中应该说是非常常见,各种网络框架用到的队列，底层用到的都是链表.相信有一句话大家都听书过：集合更适合查询操作，链表更适合频繁的插入，删除操作 实现单链表的思路 链表类，数据节点 节点类包含数据，和对下个节点的引用 完整代码 package com.cxx.list; /** * @Author: cxx * 单链表 * @Date: 2...
数据结构（双向链表）（C语言）
x18261294286的博客
08-10 1271
利用C语言实现双向链表的基本功能： 头文件： //LinkList.c #ifndef _LINKLIST_H #define _LINKLIST_H #define SUCCESS 10000 #define FAILURE 10001 #define TRUE 10002 #define FALSE 10003 typedef int Elemtype; typedef s...
双向循环链表c语言源码,双向循环链表的实现(Ｃ语言)
weixin_30495789的博客
05-21 258
// 线性表的双向链表存储结构typedef struct DuLNode{ElemType data;DuLNode *prior,*next;}DuLNode,*DuLinkList;双链循环线性表(存储结构由c2-4.h定义)的基本操作(14个)Status InitList(DuLinkList &L){ // 产生空的双向循环链表LL=(DuLinkList)malloc(siz...
南京工业大学在辽宁2020-2024各专业最低录取分数及位次表.pdf
10-04
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
下单系统的Spnigboot和微信小程序实现（全栈微信小程式下单）.zip
10-04
下单系统的Spnigboot和微信小程序实现（全栈微信小程式下单）
基于Java开发的智能文件管家设计源码
最新发布
10-04
该项目是一款基于Java的智能文件管家设计源码，涵盖102个文件，包括29个Java源文件、27个类文件、19个XML配置文件、10个YAML文件、8个列表文件、4个属性文件、4个JAR包文件以及1个Git忽略文件。该系统旨在提供高效便捷的文件管理解决方案。
初学者必备：数组、链表、队列、堆栈代码实现与解析
链表根据节点中链接的方向分为单向链表、双向链表和循环链表。链表的操作不依赖于数据的总大小，因此非常适合实现大数据量的动态存储结构。 array.cpp array.cpp 文件主要展示了数组数据结构的实现及其相关操作。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值