一，数据结构——链表全操作：

链表形式：

其中，每个节点（Node）是一个结构体，这个结构体包含数据域，指针域，数据域用来存放数据，指针域则用来指向下一个节点；

特别说明：对于单链表，每个节点（Node）可以通过指针域（Node *next）来找到下一个节点，但却不能够找到上一个节点；

只需要知道头结点就可以确定整个链表；

对链表进行的操作一般都需要遍历链表，而链表结束的标志为NULL（要么next指针为空，要么头结点为空）；

若要断开两个节点联系，要先保存下个节点，否则后面的节点无法找到；

关于链表逆序，思想为将指针方向对调，最后头节点为原链表最后一个节点；

以下为链表增，删，改，查，逆序，排序的函数实现：

link.h

  1.  #ifndef LINK_H_INCLUDED
  2.  #define LINK_H_INCLUDED
  3.  #include <stdio.h>
  4.  #include <stdlib.h>
  5.  #define datatype int
  6.  
  7.  struct node
  8.  {
  9.      int num;
  10.      int data;
  11.      struct node* next;
  12.  };
  13.  
  14.  typedef struct node Node;
  15.  
  16.  void backaddnode(Node **ppnode, int num, datatype data);//增加节点
  17.  Node *backaddnodeA(Node *pnode, int num, datatype data);//
  18.  void showallnode(Node *pnode);//显示所有的节点
  19.  Node *searchfirst(Node *pnode, int num);//查询
  20.  int change(Node *pnode, int oldnum, int newnum);//修改失败返回0，成功返回1
  21.  Node *rev(Node *pnode);//链表的逆转
  22.  Node *del(Node *pnode, int num);//删除
  23.  Node *insert(Node *pnode, int findnum, int newnum, datatype data);//实现插入，前面插入
  24.  void sort(Node *pnode, char ch);//ch==>  ch==<
  25.  
  26.  #endif // LINK_H_INCLUDED

link.cpp

  1.  #include "link.h"
  2.  
  3.  void  backaddnode(Node **ppnode, int num, datatype data)
  4.  {
  5.      Node *newnode = (Node*)malloc(sizeof(Node));
  6.      newnode->num = num;
  7.      newnode->data = data;
  8.      newnode->next = NULL;
  9.  
  10.      if (*ppnode == NULL)
  11.      {
  12.          *ppnode = newnode;
  13.      }
  14.      else
  15.      {
  16.          Node *p = *ppnode;
  17.          while (p->next != NULL)
  18.          {
  19.              p = p->next;
  20.          }
  21.          p->next = newnode;
  22.      }
  23.  }
  24.  
  25.  Node *backaddnodeA(Node *pnode, int num, datatype data)
  26.  {
  27.      Node *newnode = (Node*)malloc(sizeof(Node));
  28.      newnode->num = num;
  29.      newnode->data = data;
  30.      newnode->next = NULL;
  31.  
  32.      if (pnode == NULL)
  33.      {
  34.          pnode = newnode;
  35.      }
  36.  
  37.      else
  38.      {
  39.          Node *p = pnode;
  40.          while (p->next != NULL)
  41.          {
  42.              p = p->next;
  43.          }
  44.          p->next = newnode;
  45.      }
  46.      return pnode;
  47.  }
  48.  
  49.  void showallnode(Node *pnode)
  50.  {
  51.      printf("链表:\n");
  52.      while (pnode != NULL)
  53.      {
  54.          printf("%d->", pnode->data);
  55.          pnode = pnode->next;
  56.      }
  57.      printf("NULL\n");
  58.  }
  59.  
  60.  Node *searchfirst(Node *pnode, int num)
  61.  {
  62.      while (num != pnode->num&&pnode != NULL)
  63.      {
  64.          pnode = pnode->next;
  65.      }
  66.      return pnode;
  67.  }
  68.  
  69.  int change(Node *pnode, int oldnum, int newnum)
  70.  {
  71.      while (oldnum != pnode->num&&pnode != NULL)
  72.      {
  73.          pnode = pnode->next;
  74.      }
  75.      if (pnode != NULL)
  76.      {
  77.          pnode->num = newnum;
  78.          return ;
  79.      }
  80.      else
  81.      {
  82.          return ;
  83.      }
  84.  }
  85.  
  86.  Node *del(Node *pnode, int num)
  87.  {
  88.      Node *p = pnode;
  89.      Node *ppre = pnode;
  90.  
  91.      while (p->num != num&&p != NULL)
  92.      {
  93.          ppre = p;
  94.          p = p->next;
  95.      }
  96.      if (p != pnode)
  97.      {
  98.          ppre->next = p->next;
  99.          free(p);
  100.          p = NULL;
  101.  
  102.      }
  103.      else
  104.      {
  105.          pnode = pnode->next;
  106.          free(p);
  107.      }
  108.      return pnode;
  109.  }
  110.  
  111.  Node * insert(Node *pnode, int findnum, int newnum, datatype data)
  112.  {
  113.      Node *newnode = (Node*)malloc(sizeof(Node));
  114.      newnode->num = newnum;
  115.      newnode->data = data;
  116.      newnode->next = NULL;
  117.      Node *p = pnode;
  118.      Node *ppre = pnode;
  119.      while (p->num != findnum&&p != NULL)
  120.      {
  121.          ppre = p;
  122.          p = p->next;
  123.      }
  124.  
  125.      if (p == pnode)
  126.      {
  127.          newnode->next = pnode;
  128.          pnode = newnode;
  129.      }
  130.      else if (p != NULL)
  131.      {
  132.          ppre->next = newnode;
  133.          newnode->next = p;
  134.      }
  135.      return pnode;
  136.  }
  137.  
  138.  void sort(Node *pnode, char ch)
  139.  {
  140.      if (ch == '>')
  141.      {
  142.          Node temp;
  143.          for (Node *p1 = pnode; p1!=NULL; p1=p1->next)
  144.          {
  145.              for (Node *p2 = p1; p2 != NULL; p2 = p2->next)
  146.              {
  147.                  if (p1->data<p2->data)
  148.                  {
  149.                      temp.num = p1->num;
  150.                      p1->num = p2->num;
  151.                      p2->num = temp.num;
  152.  
  153.                      temp.data = p1->data;
  154.                      p1->data = p2->data;
  155.                      p2->data = temp.data;
  156.                  }
  157.              }
  158.          }
  159.      }
  160.      else
  161.      {
  162.          Node temp;
  163.          for (Node *p1 = pnode; p1 != NULL; p1 = p1->next)
  164.          {
  165.              for (Node *p2 = p1; p2 != NULL; p2 = p2->next)
  166.              {
  167.                  if (p1->data>p2->data)
  168.                  {
  169.                      temp.num = p1->num;
  170.                      p1->num = p2->num;
  171.                      p2->num = temp.num;
  172.  
  173.                      temp.data = p1->data;
  174.                      p1->data = p2->data;
  175.                      p2->data = temp.data;
  176.                  }
  177.              }
  178.          }
  179.      }
  180.  }
  181.  
  182.  Node *rev(Node *pnode)
  183.  {
  184.      Node *p1, *p2, *p3;
  185.      if (pnode == NULL || pnode->next==NULL)
  186.      {
  187.          return pnode;
  188.      }
  189.      else
  190.      {
  191.          p1 = pnode;
  192.          p2 = pnode->next;
  193.          while (p2 != NULL)
  194.          {
  195.              p3 = p2->next;
  196.              p2->next = p1;
  197.              p1 = p2;
  198.              p2 = p3;
  199.          }
  200.          pnode->next = NULL;
  201.          pnode = p1;
  202.          return pnode;
  203.      }
  204.  }

二，链式队列（入列，出列，清空，打印，优先队列，递归实现）

队列特点：先进先出（FIFO）

入列：在链表尾部插入节点；

出列：指针p记录链表头节点head，然后将头结点head赋值为head->next，释放p并赋值为NULL,新队列头节点为head;

清空与打印：使用递归，打印时先输出节点信息，再进入下一层递归；清空队列时先进入下一层递归后释放节点空间；

优先队列：在插入元素时，按优先级使用插入排序即可得到按优先级排列的队列；

queue_link.h

  1.  struct queue
  2.  {
  3.      int num;//代表数据
  4.      int high;//优先级1111
  5.      struct queue *pNext;//存储下一个节点的地址
  6.  };
  7.  
  8.  typedef  struct queue Queue;//简化队列
  9.  
  10.  Queue * initque(Queue *queueA);//初始化
  11.  Queue * EnQueue(Queue *queueA, int num, int high);//入队
  12.  Queue * DeQueue(Queue *queueA, Queue *pout);//出队
  13.  Queue * freeall(Queue *queueA);//清空
  14.  void  sort(Queue *queueA);//优先级排队
  15.  void printfall(Queue *queueA);//打印所有数据，递归
  16.  Queue * insertEnQueue(Queue *queueA, int num, int high);

queue_link.c

  1.  #include "Queue_link.h"
  2.  #include <stdio.h>
  3.  #include <stdlib.h>
  4.  
  5.  Queue *initque(Queue *queueA)//初始化
  6.  {
  7.      queueA = NULL;
  8.      return queueA;
  9.  }
  10.  
  11.  Queue *EnQueue(Queue *queueA, int num, int high)//入队
  12.  {
  13.      Queue *newnode = (Queue *)malloc(sizeof(Queue));
  14.      newnode->num = num;
  15.      newnode->high = high;
  16.      newnode->pNext = NULL;
  17.  
  18.      if (queueA == NULL)
  19.      {
  20.          queueA = newnode;
  21.      }
  22.      else
  23.      {
  24.          Queue *p = queueA;
  25.          while (p->pNext!=NULL)
  26.          {
  27.              p = p->pNext;
  28.          }
  29.          p->pNext = newnode;
  30.      }
  31.      return queueA;
  32.  }
  33.  
  34.  Queue *DeQueue(Queue *queueA, Queue *pout)//出队
  35.  {
  36.      if (queueA == NULL)
  37.      {
  38.          pout = NULL;
  39.          return NULL;
  40.      }
  41.      else
  42.      {
  43.          pout->num = queueA->num;
  44.          pout->high = queueA->high;
  45.          pout->pNext = NULL;
  46.  
  47.          Queue *p = queueA;
  48.          queueA = queueA->pNext;
  49.          free(p);
  50.      }
  51.      return queueA;
  52.  }
  53.  
  54.  Queue *freeall(Queue *queueA)//清空
  55.  {
  56.      if (queueA == NULL)
  57.      {
  58.          return queueA;
  59.      }
  60.      else
  61.      {
  62.          freeall(queueA->pNext);
  63.          free(queueA);
  64.          queueA = NULL;
  65.      }
  66.  }
  67.  
  68.  //void  sort(Queue *queueA);//优先级排队
  69.  
  70.  void printfall(Queue *queueA)//打印所有数据，递归
  71.  {
  72.      if (queueA==NULL)
  73.      {
  74.          return;
  75.      }
  76.      else
  77.      {
  78.          printf("num=%d,high=%d,addr=%p\n",queueA->num,queueA->high,queueA);
  79.          printfall(queueA->pNext);
  80.      }
  81.  }
  82.  
  83.  Queue * insertEnQueue(Queue *queueA, int num, int high)//按优先级插入队列
  84.  {
  85.      Queue *newnode = (Queue *)malloc(sizeof(Queue));
  86.      newnode->num = num;
  87.      newnode->high = high;
  88.      newnode->pNext = NULL;
  89.  
  90.      if (queueA == NULL)
  91.      {
  92.          queueA = newnode;
  93.      }
  94.      else if (queueA->high>newnode->high)
  95.      {
  96.          newnode->pNext = queueA;
  97.          queueA = newnode;
  98.      }
  99.      else
  100.      {
  101.          Queue *p1;
  102.          for (p1 = queueA; p1->pNext!=NULL; p1=p1->pNext)
  103.          {
  104.              if (newnode->high < p1->pNext->high)
  105.              {
  106.                  break;
  107.              }
  108.          }
  109.  
  110.          newnode->pNext = p1->pNext;
  111.          p1->pNext = newnode;
  112.      }
  113.      return queueA;
  114.  }

三，链式栈（入栈，出栈，显示，清空）

栈特点：先进后出（FILO）

入栈：在链表最后增加新节点；

出栈：将链表第一个元素输出，并将其从链表删除；

stack_link.h

  1.  #define  datatype  int
  2.  struct stacknode
  3.  {
  4.      int num;//编号
  5.      datatype data;//数据
  6.      struct stacknode *pNext;//指针域
  7.  
  8.  };
  9.  typedef struct stacknode  StackNode;//简化
  10.  StackNode * init(StackNode * phead);//初始化
  11.  StackNode * push(StackNode * phead, int num, datatype data);//进栈
  12.  StackNode * pop(StackNode * phead, StackNode * poutdata);//出栈
  13.  StackNode * freeall(StackNode * phead);//清空
  14.  void printfall(StackNode * phead);//打印

stack_link.c

  1.  #include "static_link.h"
  2.  #include <stdio.h>
  3.  #include <stdlib.h>
  4.  
  5.  StackNode * init(StackNode * phead)//初始化
  6.  {
  7.      phead = NULL;
  8.      return phead;
  9.  }
  10.  
  11.  StackNode * push(StackNode * phead, int num, datatype data)//进栈
  12.  {
  13.      StackNode *newnode = (StackNode*)malloc(sizeof(StackNode));
  14.      newnode->num = num;
  15.      newnode->data = data;
  16.      newnode->pNext = NULL;
  17.      if (phead == NULL)
  18.      {
  19.          phead = newnode;
  20.      }
  21.      else
  22.      {
  23.          StackNode *p = phead;
  24.          while (p->pNext!=NULL)
  25.          {
  26.              p = p->pNext;
  27.          }
  28.          p->pNext = newnode;
  29.      }
  30.      return phead;
  31.  
  32.  }
  33.  
  34.  StackNode * pop(StackNode * phead, StackNode * poutdata)//出栈
  35.  {
  36.      if (phead == NULL)
  37.      {
  38.          poutdata = NULL;
  39.      }
  40.      else if (phead->pNext == NULL)
  41.      {
  42.          poutdata->num = phead->num;
  43.          poutdata->data = phead->data;
  44.          poutdata->pNext = NULL;
  45.          free(phead);
  46.          phead = NULL;
  47.      }
  48.      else
  49.      {
  50.          StackNode *p = phead;
  51.          while (p->pNext->pNext!=NULL)
  52.          {
  53.              p = p->pNext;
  54.          }
  55.          poutdata->num = p->pNext->num;
  56.          poutdata->data = p->pNext->data;
  57.          poutdata->pNext = NULL;
  58.  
  59.          free(p->pNext);
  60.          p->pNext = NULL;
  61.      }
  62.      return phead;
  63.  }
  64.  
  65.  StackNode * freeall(StackNode * phead)//清空
  66.  {
  67.      if (phead == NULL)
  68.      {
  69.          return NULL;
  70.      }
  71.  
  72.      else
  73.      {
  74.          /*StackNode *p1 = phead, *p2 = phead;
  75.          while (p1->pNext!=NULL)
  76.          {
  77.              p2 = p1->pNext;
  78.              p1->pNext = p2->pNext;
  79.              free(p2);
  80.              p2 = NULL;
  81.          }
  82.          free(phead);
  83.          phead = NULL;*/
  84.          freeall(phead->pNext);
  85.          free(phead);
  86.          phead = NULL;
  87.      }
  88.  }
  89.  
  90.  void printfall(StackNode * phead)//打印
  91.  {
  92.      if (phead == NULL)
  93.      {
  94.          return ;
  95.      }
  96.      else
  97.      {
  98.          printf("num=%d,data=%d,addr=%p\n",phead->num,phead->data,phead);
  99.          printfall(phead->pNext);
  100.      }
  101.  }

C语言链表全操作（增，删，改，查，逆序，递增排序，递减排序，链式队列，链式栈）的更多相关文章

  1. django单表操作 增 删 改 查

    一.实现:增.删.改.查 1.获取所有数据显示在页面上 model.Classes.object.all(),拿到数据后,渲染给前端;前端通过for循环的方式,取出数据. 目的:通过classes(班 ...

  2. iOS sqlite3 的基本使用(增 删 改 查)

    iOS sqlite3 的基本使用(增 删 改 查) 这篇博客不会讲述太多sql语言,目的重在实现sqlite3的一些基本操作. 例:增 删 改 查 如果想了解更多的sql语言可以利用强大的互联网. ...

  3. 好用的SQL TVP~~独家赠送[增-删-改-查]的例子

    以前总是追求新东西,发现基础才是最重要的,今年主要的目标是精通SQL查询和SQL性能优化.  本系列主要是针对T-SQL的总结. [T-SQL基础]01.单表查询-几道sql查询题 [T-SQL基础] ...

  4. django ajax增 删 改 查

    具于django ajax实现增 删 改 查功能 代码示例: 代码: urls.py from django.conf.urls import url from django.contrib impo ...

  5. iOS FMDB的使用(增,删,改,查,sqlite存取图片)

    iOS FMDB的使用(增,删,改,查,sqlite存取图片) 在上一篇博客我对sqlite的基本使用进行了详细介绍... 但是在实际开发中原生使用的频率是很少的... 这篇博客我将会较全面的介绍FM ...

  6. ADO.NET 增 删 改 查

    ADO.NET:(数据访问技术)就是将C#和MSSQL连接起来的一个纽带 可以通过ADO.NET将内存中的临时数据写入到数据库中 也可以将数据库中的数据提取到内存中供程序调用 ADO.NET所有数据访 ...

  7. MVC EF 增 删 改 查

    using System;using System.Collections.Generic;using System.Linq;using System.Web;//using System.Data ...

  8. python基础中的四大天王-增-删-改-查

    列表-list-[] 输入内存储存容器 发生改变通常直接变化,让我们看看下面列子 增---默认在最后添加 #append()--括号中可以是数字,可以是字符串,可以是元祖,可以是集合,可以是字典 #l ...

  9. MongoDB增 删 改 查

    增 增加单篇文档 > db.stu.insert({sn:'001', name:'lisi'}) WriteResult({ "nInserted" : 1 }) > ...

随机推荐

  1. leetcode—triangle

    1.题目描述 Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adj ...

  2. 【Java基础】static关键字的理解

    修饰范围: 可以修饰成员变量和成员方法.静态的特点: A:随着类的加载而加载 B:优先于对象存在 C:被类的所有对象共享 这其实也是我们判断该不该使用静态的依据. 举例:饮水机和水杯的问题思考可通过类 ...

  3. var_dump() 打印数组不完整 解决办法

    我们用var_dump() 打印数组, 一般会出现这种情况, 就是打印出来的数组不完整 ,会有省略号. 解决方法: 在php.ini里的xdebug节点中,加入如下 xdebug.var_displa ...

  4. linux安装svn服务器（yum方式）

    1.查看yum是否安装         在终端中输入yum即可如果已经安装,会显示yum的参数         如果没有安装,会提示yum未安装或无效命令…… 2.安装svnyum -y instal ...

  5. 实现GetHashCode时要遵循的规则

    博客搬到了fresky.github.io - Dawei XU,请各位看官挪步.最新的一篇是:实现GetHashCode时要遵循的规则.

  6. AndroidAnnotations部署

    环境: 系统:windows 8 (64bit) 开发工具:Eclipse 3.8 JDK版本:jdk1.6 构建工具:Ant(Eclipse默认的build tool) androidannotat ...

  7. 部署服务--NLB

    通过服务部署NLB,是对某一层(一层下面可以自定义VM实例数量)服务下的多台VM进行NLB,而不是对多个层进行NLB.需要先进行如下准备: 1.VM需要使用静态IP和静态MAC,所以需要先在进行NLB ...

  8. BZOJ 2049: [Sdoi2008]Cave 洞穴勘測 LCT

    入门级LCT: 仅仅有 Cut Link 2049: [Sdoi2008]Cave 洞穴勘測 Time Limit: 10 Sec  Memory Limit: 259 MB Submit: 3073 ...

  9. xcode针对不同IOS版本的代码编译问题

    有时候在项目中为了兼容低版本IOS系统,通常会针对不同的OS版本写不同的代码,例如: #define IS_IOS7_OR_LATER ([[UIDevice currentDevice].syste ...

  10. TCP并发server，每个客户一个子进程

    今天笔者带来的是server型号第一,这是最经常使用的模型的最基本的一个–TCP并发server,每个客户一个子进程. 首先简单介绍:TCP并发server,每个客户一个子进程,并发server调用f ...