链表 堆栈 队列

最新推荐文章于 2023-12-06 13:28:46 发布
最新推荐文章于 2023-12-06 13:28:46 发布
阅读量457 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shanchangyi/article/details/52230441
版权

1、链表  的创建 加入 删除 遍历 等 ······ 

    

#include <stdio.h>
#include <stdlib.h>

typedef struct student
{
    int num;
    struct student *next;

}node;

node* creat();
int length(node* n);
void print(node* n);
node* insert(node* n,int num);
node* del(node* n,int num);
node* sort(node* n);

int main()
    {
         node* p;
         p= (node *)creat();
         print(p);
         p=insert(p,5);
        p=del(p,1);
          print(p);
       p= sort(p);
         print(p);
           return 0;
    }

node* creat()
{
    node *head;
    node *p,*q;
    int a,flag=1;
    head=(node*)malloc(sizeof(node));
    head->next=NULL;
    q=head;
    while(flag)
    {
        printf("input num=\n");
        scanf("%d",&a);
        if(a)
        {
            p=(node*)malloc(sizeof(node));
            q->next=p;
            p->num=a;
            q=p;
        }
        else
            flag=0;

    }
 head=head->next;
 p->next=NULL;
 return head;

}

int length(node* n)
{

    int len=0;
    node* p=(node*)malloc(sizeof(node));
    p=n;
    while(p!=NULL)
    {
        p=p->next;
        len++;

    }
    return len;
}
void print(node* n)
{

    node* p=(node*)malloc(sizeof(node));
    p=n;
    while(p!=NULL)
    {
        printf("num=%d\n",p->num);
        p=p->next;

    }

}
node* insert(node* n,int num)
{
  node* p=(node*)malloc(sizeof(node));
  p=n;
  while(p->next!=NULL)
  {
      p=p->next;
  }
  node* q=(node*)malloc(sizeof(node));
  q->num=num;
  q->next=NULL;
  p->next=q;

  return n;

}
node* del(node* n,int num)
{
    node* p=(node*)malloc(sizeof(node));
    node*q;
    p=n;
    while((p->num!=num)&&(p->next!=NULL))
    {
       q=p;
       p=p->next;

    }
   if(p->num==num)
   {
       if(p!=n)
       {
          q->next=p->next;
          free(p);
          p=NULL;

       }
      else
        {
           n=p->next;
           free(p);
        }
   }
   else
       printf("not find this number.\n");

   return n;

 }
node* sort(node* n)
{
    node *p,*q;
    int i,j,temp;
    int len=length(n);
    if(n==NULL||n->next==NULL)
        return n;
    for(i=0;i<len-1;i++)
    {
        p=n;
        for(j=0;j<len-1-i;j++)
        {
            if(p->num>p->next->num)
            {
                q=p->next;
                temp=q->num;
                q->num=p->num;
                p->num=temp;
            }
           p=p->next;
        }
    }
 return n;

}

2、可变长度的数组  添加 删除 增长

#include <stdio.h>
#include<stdlib.h>


typedef struct
{
    int size;
    int* array;

}Array;

//int bluck 5;

Array creat_arr(int size);
void delete_arr(Array *a);
int arr_size(const Array *a);
int arr_get(const Array *a,int index);
void arr_set(Array *a,int index,int value);
void arr_bigger(Array *a,int bluck);

int main(void)
{
   Array a=creat_arr(10);
   int cnt=0;
   while(1)
   {
    int b;
   scanf("%d",&b);
   if(b!=-1)
     arr_set(&a,cnt++, b);
   else
      break;
   }
   int i=0;
   while(cnt--)
    {
      printf("a[%d]=%d\n",i++,arr_get(&a,i));
    }
    delete_arr(&a);
    return 0;
}



Array creat_arr(int size)
{
   Array a;
   a.size=size;
   a.array=(int*)malloc(size*sizeof(int));
   return a;

}



void delete_arr(Array *a)
{
  free(a->array);
  a->array=NULL;
  a->size=0;
}


int arr_size(const Array *a)
{
    return a->size;
}


int arr_get(const Array *a,int index)
{

    return a->array[index];

}


void arr_set(Array *a,int index,int value)
{
    if(index==arr_size(&a))
        arr_bigger(&a,5);

    a->array[index]=value;

}


void arr_bigger(Array *a,int bluck)
{
    int size=arr_size(&a);
    int *b=(int*)malloc(sizeof(int)*(size+bluck));
//    strcpy(b,a->array,size);
    int i;
    for(i=0;i<size;i++)
    {
        b[i]=a->array[i];

    }

    free(a->array);
    a->array=b;
    a->size=size+bluck;
}

3、、、判断压栈出栈


#include <iostream>
using namespace std;


#define MAX 1000
int arr[MAX]={0};
int front = -1;

void stk_push(int a)
{
    if(front+1<MAX)
        arr[++front] = a;
}

int stk_top()
{
    if(front>=0)
        return arr[front];
}

void stk_pop()
{
    if(front>=0)
        front--;
}

bool empty()
{
    if(front<0)return true;
    else
        return false;
}
bool IsPushPopSeq(int intput[],int len1,int output[],int len2)
{
    int index1 = 0,index2 = 0;
    while(index2<len2)
    {
        if(empty() || stk_top() != output[index2] && index1<len1)        //判断压站出站
        {
            stk_push(intput[index1++]);
        }
        else if(!empty() && stk_top() == output[index2])
        {
            index2++;
            stk_pop();
        }
        else
            return false;
    }
    return true;
}

int main()
{
    cout << "Hello World!" << endl;
    int a[]={5,2,3,1,4},a1[]={1,2,3,4,5};

    cout<<IsPushPopSeq(a1,5,a,5)<<endl;

    return 0;
}


4、

、约瑟夫问题


#include<stdio.h>
#include<stdlib.h>

typedef struct note
{
    int data;
    struct note* next;

}node;


node* creat_s(int num)
{
    node*p=(node*)malloc(sizeof(node));
    node*w=p;
    int i;
    for(i=1;i<=num;i++)
    {
         node*q=(node*)malloc(sizeof(node));                  //约瑟夫问题   费劲

         q->data=i;
         q->next=NULL;
         w->next=q;
         w=q;
    }
    node*q;
    q=p;
    p=p->next;
    free(q);
    w->next=p;
 return p;
}

//node*insert(node*p,int num)
//{

// return p;
//}
node*del(node*p,int num)
{
  node*now,*pre;
  pre=p;
  now=p->next;
  while(now->data!=num)
  {
      pre=now;
      now=now->next;
  }
  printf("kell the num:%d\n",now->data);
  pre->next=now->next;
  free(now);
  return pre->next;
}

int main()
{
    int a,k=3;
    node*p=NULL;
   printf("please input a num\n");
   scanf("%d",&a);

   p=creat_s(a);
   node*w=p;
  while(w->next!=w)
  {
      node*q;
      q=w->next->next;
      int num=q->data;
      w=del(w,num);
  }
  p=w;
  printf("the least people %d\n",p->data);
return 0;
}


5    栈

#include <stdio.h>
#include <stdlib.h>
typedef struct dui
{
    int data;
    struct dui* next;

}node;

typedef struct lie
{
    node *frist;
    node * rear;

}duilie;

duilie* creat();
duilie* push(duilie*p,int num);                   //栈
duilie* pop(duilie*p,int*num);
void dest(duilie*p);
void print(duilie* p);

int main(void)
{
    int a;
    duilie *p=creat();
    p=push(p,1);
    p=push(p,2);
    p=push(p,3);
    p=push(p,4);
    print(p);
    p=pop(p,&a);
    print(p);
//    dest(p);
   return 0;
}

duilie *creat()
{
   duilie* p;
    p->frist=NULL;
    p->rear=NULL;
   return p;

}


duilie* push(duilie*p,int num)
{

    node*q=(node*)malloc(sizeof(node));
    q->data=num;
    q->next=NULL;

     if(p->frist==NULL)
     {
         p->frist=q;
         p->rear=q;
     }
      else
     {
         p->frist->next=q;
         p->frist=q;

     }
     return p;

}


duilie* pop(duilie*p,int* num)
{
    node*a;
     if(p->frist==NULL)
     {

         printf("meiyou shuju sb\n");

     }
    else
     {
         *num=p->frist->data;
         printf("chuzhan %d\n",*num);
          a=p->frist;
         if(p->rear==p->frist)
         {

            p->frist=NULL;
            p->rear=NULL;

         }
         else
        {
             node*b=p->rear;

             while(b->next!=p->frist)
             {
                 b=b->next;

             }

             p->frist=b;
             p->frist->next=NULL;
               free(a);
         }
     }
     return p;
}
void dest(duilie*p)
{
    node*a=p->frist;
    node*b=NULL;
    while(a!=NULL)
    {
        b=a;
        a=a->next;
        free(b);
        b=NULL;
    }

}
void print(duilie* p)
{
    node*a=p->rear;

  while(a!=NULL)
  {
      printf("%d\n",a->data);
      a=a->next;

  }

}

7、、队列  

#include <stdio.h>
#include <stdlib.h>
typedef struct dui
{
    int data;
    struct dui* next;

}node;

typedef struct lie
{
    node *frist;
    node * rear;

}duilie;

duilie* creat();
duilie* in(duilie*p,int num);
duilie* out(duilie*p);
void dest(duilie*p);
void print(duilie* p);

int main(void)
{
    duilie *p=creat();
    p=in(p,1);
    p=in(p,2);
    p=in(p,3);
    p=in(p,4);
    print(p);
    p=out(p);
    print(p);
 //   dest(p);
   return 0;
}

duilie *creat()
{
   duilie* p;
    p->frist=NULL;
    p->rear=NULL;
   return p;

}


duilie* in(duilie*p,int num)
{

    node*q=(node*)malloc(sizeof(node));       //队列
    q->data=num;
    q->next=NULL;

     if(p->frist==NULL)
     {
         p->frist=q;
         p->rear=q;
     }
      else
     {
         p->rear->next=q;
         p->rear=q;

     }
     return p;

}


duilie* out(duilie*p)
{
    node*a;
    int num;
     if(p->frist==NULL)
     {

         printf("meiyou shuju sb\n");

     }
    else
     {
         num=p->frist->data;
         printf("shuzhan %d\n",num);
          a=p->frist;
         if(p->rear==p->frist)
         {

            p->frist=NULL;
            p->rear=NULL;

         }
         else
        {
             p->frist=p->frist->next;
               free(a);
         }
     }
     return p;
}
void dest(duilie*p)
{
    node*a=p->frist;
    node*b=NULL;
    while(a!=NULL)
    {
        b=a;
        a=a->next;
        free(b);
        b=NULL;
    }

}
void print(duilie* p)
{
    node*a=p->frist;

  while(a!=NULL)
  {
      printf("%d\n",a->data);
      a=a->next;

  }

}


shanchangyi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
链表，堆栈与队列
sesiria的博客
04-11 396
一，链表 定义： struct link_node { int value; struct link_node * next; }; 1. 判断链表是否有没有环 使用两个快慢指针 慢指针往后面以动一个节点 快指针每次移动两个节点 // check whether the link list is a ring // 1 for true, and 0 for false. int isRing(struct link_node* head) { if (head ==
链表，栈，队列
多元思考力
01-08 481
目录 一些算法题 1.1 问题1：系统数数 1.2 问题2：战平即可出线 1.3 问题3：逻辑推理 1.4 问题4：天平与假币 链表 2.1 链表相加 2.2 链表的部分翻转 堆，栈 队列 1.一些算法题算法包罗万象 推理，逻辑，“机智“ 演绎，归纳，类比 严格归纳 以上任何一种能力，都要用到，而且用熟， 如果合理利用，可以非常便利得减少时间复杂度和空间复杂度。看几个问题： 1.1
链表【+逆序链表】、循环队列、堆栈讲解（头插法和尾插法）
m0_51429770的博客
05-31 3007
链表是一种常用的数据结构。相较于数组，链表的好处在于可以动态地分配内存空间，因此可以适应更为灵活的内存需求。数据域和指针域。数据域存储节点的数据，指针域指向下一个节点。将所有的节点连接起来，就形成了一个链表。可以动态地分配内存空间，不受固定大小的限制；插入和删除操作效率高，时间复杂度为O(1)；可以轻松地实现栈、队列等数据结构。随机访问不方便，需要遍历整个链表；内存空间占用较大，因为每个节点都需要额外的指针域；不支持快速排序等高级算法。队列是一种特殊的线性表结构，它只允许在队尾。
数据结构复习：链表、数组、栈、队列、哈希表、堆、二叉树
weixin_47723114的博客
12-06 517
饺子的数据结构复习章节：链表、数组、栈、队列、哈希表、堆、二叉树等知识点简单回顾
数据结构（栈/队列/链表）
weixin_47667133的博客
07-20 937
线性数据结构 2. 什么叫做数据结构 数据结构是计算机存储、组织数据的方式。指的是相互之间存在一种或多种特定关系的数据元素的集合。 ​ – 百度百科 可比喻成一个企业的组织结构，组织结构其实就是部门与部门之间的关系结构。 数据结构就是用来描述数据与数据之间的关系 线性和非线性数据结构 线性结构：数据元素之间一对一的关系 非线性结构：数据元素之间一对多的关系 存储方式 顺序存储：Set、Array 散列存储：Map、Object
“数组、堆栈”与“链表、队列”的区别是什么？
一个喜欢诗和远方的程序媛
11-17 1590
“数组、堆栈”与“链表、队列”的区别是什么？
C# 链表 堆栈 队列
01-06
本文将深入探讨C#中的链表、堆栈和队列这三种基本数据结构及其实现方式。 首先，我们来看链表。链表是一种线性数据结构，与数组不同，它的元素并不在内存中连续存储。每个链表节点包含两部分：数据和指向下一个节点...
数据结构 链表 队列 堆栈
06-27
完整代码 正确产生结果 三个类分开写 class linklist { protected: struct node { int data; node *next; }; node *head; int length; public:
嵌入式数据结构链表队列堆栈
07-17
嵌入式常用数据结构-链表、队列、堆栈、可删除key值链表、优先级队列，消息队列
数据结构C++版 链表，堆栈，队列
06-16
通过这次专题实习，巩固和加深对所学相关知识点的理解，进一步熟悉基本自定义类、函数的应用加强对模块化程序设计和面向对象程序设计的理解。掌握C++语言程序设计的基本思想，了解简单的系统分析和设计方法。...
堆栈链表与队列链表的基本操作
05-28
堆栈、链表和队列是三种基本的数据结构，广泛应用于各种软件开发中。本篇文章将详细探讨堆栈链表和队列链表的基本操作。 首先，让我们了解堆栈（Stack）的概念。堆栈是一种后进先出（LIFO，Last In First Out）的...
python 实现链表、堆栈、队列
weixin_46707493的博客
02-17 1277
目录： 一、实现单链表 二、通过链表实现堆栈 三、通过链表实现队列 一、实现链表： class Node(): """结点类""" def __init__(self, data): self.data = data self.next = None class LinkList(): """链表类""" def __init__(self,node = None): self.__head = node
链表 栈 队列 堆 二叉树 （超级详细）
qq_53217755的博客
12-20 923
目录 链表 栈 队列 堆 二叉树 链表 栈 队列 堆 二叉树
栈,队列和链表三者之间的关系与区别
老司机的后备箱
12-16 2166
为大家准备了一个前端资料包。包含54本，2.57G的前端相关电子书，《前端面试宝典（附答案和解析）》，难点、重点知识视频教程（全套）。 数组在内存中最为关键的一个特征，就是它一般是对应一段位于自己上界和下界之间的、一段**连续**的内存空间。元素与元素之间，紧紧相) 关系进行一下简化) 要想访问链表中的任何一个元素，我们都得从起点结点开始，逐个访问 next，一直访问到目标结点为止。
Python使用列表与链表分别来实现堆栈和队列
深度学习领域优质创作者，CSDN博客专家
11-24 679
熟悉堆栈和队列两种数据结构
浙大数据结构ch2：链表，队列，堆栈
weixin_52812620的博客
08-31 372
浙大数据结构
数据结构（1）线性结构——数组、链表、堆栈、队列（介绍和JAVA代码实现）
Joker_ZJN的博客
11-10 1283
详细介绍、数组、链表、堆栈、队列，包含JAVA版代码实现
毕业设计asp.net投票管理系统三层-qkr源码含文档工具包
最新发布
08-15
毕业设计asp.net投票管理系统三层-qkr源码含文档工具包 asp.net，数据库sqlserver，开发工具用Microsoft Visual Studio 在线投票系统 投票结果 投票结果 投票人数 如修改 投票项目 编辑删除 用户登陆 权限管理 帐户管理 包含：源码、数据库脚本、论文、答辩ppt、环境工具包（在说明文档中）
描述数组、链表、队列、堆栈的区别
04-05
数组、链表、队列和堆栈是常见的数据结构，它们有以下区别： 1. 数组是一种线性数据结构，用于存储相同类型的元素。数组的元素在内存中是连续存储的，可以根据索引快速访问元素。但是，数组的大小是固定的，无法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值