C语言链表完整操作演示

本文实例为大家分享了C链表操作演示的具体代码，供大家参考，具体内容如下

头文件：link_0505.h

/*
链表演示
*/
#ifndef __LINK_0505
#define __LINK_0505
typedef struct node{
  int num;
  struct node* p_next;
}node;
typedef struct
{
  node head,tail;
}link;
//链表的初始化函数
void link_init(link *);
//链表的清理函数
void link_deinit(link *);
//判断链表是否空的函数
int link_empty(link *);
//判断链表是否满的函数
int link_full(link *);
//统计有效数字个数的函数
int link_size(link *);
//在最前边插入数字的函数
int link_add_head(link *, int );
//在最后边插入新的数字的函数
int link_append(link *, int );
//把数字按照顺序插入到链表的函数
int link_insert(link *, int);
//删除最前面数字的函数
int link_remove_head(link *);
//删除最后一个有效数字
int link_remove_tail(link *);
//删除某个给定数字的函数
int link_remove(link *, int );
//获得第一个有效数字的函数
int link_get_head(link *, int *);
//获得最后一个有效数字的函数
int link_get_tail(link *, int *);
//获得指定编号数字的函数
int link_get(link *, int *, int ); 

#endif

实现代码: link_0505.cpp

/*
链表演示
*/
#include "stdlib.h"
#include "link_0505.h"
//链表的初始化函数
void link_init(link *p_link)
{
  p_link->head.p_next = &(p_link->tail);
}
//链表的清理函数
void link_deinit(link *p_link)
{
  while(p_link->head.p_next != &(p_link->tail))
  {
    node *p_first = &(p_link->head);
    node *p_mid = p_first->p_next;
    node *p_last = p_mid->p_next;
    p_first->p_next = p_last;
    free(p_mid);
    p_mid = NULL;
  }
}
//判断链表是否空的函数
int link_empty(link *p_link)
{
  return p_link->head.p_next == &(p_link->tail);
}
//判断链表是否满的函数
int link_full(link *p_link)
{
  return 0;
}
//统计有效数字个数的函数
int link_size(link *p_link)
{
  int cnt = 0;
  node *p_node = NULL;
  for (p_node = &(p_link->head);p_node != &(p_link->tail);p_node = p_node->p_next)
  {
    node *p_first = p_node;
    node *p_mid = p_first->p_next;
    node *p_last = p_mid->p_next;
    if (p_mid != &(p_link->tail))
    {
      cnt++;
    }
  }
  return cnt;
}
//在最前边插入数字的函数
int link_add_head(link *p_link, int num)
{
  node *p_temp = (node *)malloc(sizeof(node));
  if (!p_temp)
  {
    return 0;
  }   

  p_temp->num = num;
  node *p_first = &(p_link->head);
  node *p_mid = p_first->p_next;
  node *p_last = p_mid->p_next;
  p_first->p_next = p_temp;
  p_temp->p_next = p_mid; 

  return 1;
}
//在最后边插入新的数字的函数
int link_append(link *p_link, int num)
{
  node *p_tmp = (node *)malloc(sizeof(node));
  node *p_node = NULL;
  if (!p_tmp)
  {
    return 0;
  }
  p_tmp->num = num;
  for (p_node = &(p_link->head);p_node != &(p_link->tail);p_node = p_node->p_next)
  {
    node *p_first = p_node;
    node *p_mid = p_first->p_next;
    node *p_last = p_mid->p_next;
    if (p_mid == &(p_link->tail))
    {
      p_first->p_next = p_tmp;
      p_tmp->p_next = p_mid;
      break;
    }
  }
  return 1;
}
//把数字按照顺序插入到链表的函数
int link_insert(link *p_link, int num)
{
  node* p_temp = (node *)malloc(sizeof(node));
  node* p_node = NULL;
  if (!p_temp)
  {
    return 0;
  }
  p_temp->num = num;
  p_temp->p_next = NULL;
  for (p_node = &(p_link->head);p_node != &(p_link->tail);p_node = p_node->p_next)
  {
    node *p_first = p_node;
    node *p_mid = p_first->p_next;
    node *p_last = p_mid->p_next;
    if (p_mid == &(p_link->tail) || p_mid->num > p_temp->num)
    {
      p_first->p_next = p_temp;
      p_temp->p_next = p_mid;
      break;
    }
  }
  return 0;
}
//删除最前面数字的函数
int link_remove_head(link *p_link)
{
  node *p_first = &(p_link->head);
  node *p_mid = p_first->p_next;
  node *p_last = p_mid->p_next;
  if (p_link->head.p_next == &(p_link->tail))
  {
    return 0;
  }
  p_first->p_next = p_last;
  free(p_mid);
  p_mid = NULL;
}
//删除最后一个有效数字
int link_remove_tail(link *p_link)
{
  node *p_node = NULL;
  for (p_node = &(p_link->head);p_node !=&(p_link->tail);p_node = p_node->p_next)
  {
    node *p_first = p_node;
    node *p_mid = p_first->p_next;
    node *p_last = p_mid->p_next;
    if (p_last == &(p_link->tail))
    {
      p_first->p_next = p_last;
      free(p_mid);
      p_mid = NULL;
      return 1;
    }
  }
  return 0;
}
//删除某个给定数字的函数
int link_remove(link *p_link, int num)
{
  node *p_node = NULL;
  for (p_node = &(p_link->head);p_node != &(p_link->tail);p_node = p_node->p_next)
  {
    node *p_first = p_node;
    node *p_mid = p_first->p_next;
    node *p_last = p_mid->p_next;
    if (p_mid != &(p_link->tail) && p_mid->num == num)
    {
      p_first->p_next = p_last;
      free(p_mid);
      p_mid = NULL;
      return 1;
    }
  }
  return 0;
}
//获得第一个有效数字的函数
int link_get_head(link *p_link, int *p_num)
{
  if (p_link->head.p_next == &(p_link->tail))
  {
    return 0;
  }
  node *p_first = &(p_link->head);
  node *p_mid = p_first->p_next;
  node *p_last = p_mid->p_next;
  p_first->p_next = p_last;
  *p_num = p_mid->num;
  return 1;
}
//获得最后一个有效数字的函数
int link_get_tail(link *p_link, int *p_num)
{
  node *p_node = NULL;
  for (p_node = &(p_link->head);p_node != &(p_link->tail);p_node = p_node->p_next)
  {
    node *p_first = p_node;
    node *p_mid = p_first->p_next;
    node *p_last = p_mid->p_next;
    if (p_last == &(p_link->tail))
    {
      *p_num = p_mid->num;
      return 1;
    }
  }
  return 0;
}
//获得指定编号数字的函数
int link_get(link *p_link, int *p_num, int num)
{
  int cnt = 0;
  node *p_node = NULL;
  for (p_node = &(p_link->head);p_node != &(p_link->tail);p_node = p_node->p_next)
  {
    node *p_first = p_node;
    node *p_mid = p_first->p_next;
    node *p_last = p_mid->p_next;
    if (p_mid != &(p_link->tail) && cnt == num)
    {
      *p_num = p_mid->num;
      return 1;
    }
    cnt++;
  }
  return 0;
}

测试函数:

/*
 * 链表测试
 * */
#include <stdio.h>
#include "link_0505.h"
int main() {
  int size = 0, num = 0, val = 0;
  link lnk = {0};
  link_init(&lnk);
  link_add_head(&lnk, 30);
  link_add_head(&lnk, 20);
  link_append(&lnk, 90);
  link_append(&lnk, 100);
  link_insert(&lnk, 50);
  link_insert(&lnk, 60);
  link_insert(&lnk, 40);
  link_insert(&lnk, 80);
  link_insert(&lnk, 70);
  size = link_size(&lnk);
  for (num = 0;num <= size - 1;num++) {
    link_get(&lnk, &val, num);
    printf("%d ", val);
  }
  printf("\n");
  printf("------------------");
  link_remove_head(&lnk);
  link_remove_tail(&lnk);
  link_remove(&lnk, 70);
  size = link_size(&lnk);
  for (num = 0;num <= size - 1;num++) {
    link_get(&lnk, &val, num);
    printf("%d ", val);
  }
  printf("\n");
  link_get_head(&lnk, &val);
  printf("最前面的数字是%d\n", val);
  link_get_tail(&lnk, &val);
  printf("最后面的数字是%d\n", val);
  link_deinit(&lnk);
  return 0;
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

赞 (0)

相关推荐

  • C语言双向链表的表示与实现实例详解

    C语言双向链表的表示与实现实例详解

    1.概述: C语言中一种更复杂的链表是"双向链表"或"双面链表".其表中的每个节点有两个连接:一个指向前一个节点,(当这个"连接"为第一个"连接"时,指向空值或者空列表):而另一个指向下一个节点,(当这个"连接"为最后一个"连接"时,指向空值或者空列表) 一个双向链表有三个整数值: 数值, 向后的节点链接, 向前的节点链接 在一些低级语言中, XOR-linking 提供一种在双向链表中

  • c语言链表基本操作(带有创建链表 删除 打印 插入)

    复制代码 代码如下: #include <stdio.h>#include <stdlib.h>#include <malloc.h>#define LEN sizeof(struct Student)struct Student{    long num;    float score;    struct Student*next;};int n;int main(){    /*-----------------------------程序描述----------

  • 用C语言实现单链表的各种操作(一)

    最近,从新复习了一下数据结构中比较重要的几个部分,现在把自己的成果记录下来,主要就是仿照严蔚敏的<数据结构>(C 语言版),中的例子和后面的习题进行改编的.首先,是单链表的各种实现,其中,包含了一些常考的知识点.例如,单链表的逆置,单链表的合并,找到单链表的中间节点等的算法实现.下面这个是单链表的结构体的定义: 复制代码 代码如下: typedef struct LNode{ ElemType data; struct LNode *next;}LinkList; 下面的基本的单链表的操作:其

  • C语言之单链表的插入、删除与查找

    C语言之单链表的插入、删除与查找

    单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素.要实现对单链表中节点的插入.删除与查找的功能,就要先进行的单链表的初始化.创建和遍历,进而实现各功能,以下是对单链表节点的插入.删除.查找功能的具体实现: #include<stdio.h> #include<stdlib.h> #include<string.h> typedef int ElemType; /** *链表通用类型 *ElemType 代表自定义的数据类型 *struct

  • C语言创建和操作单链表数据结构的实例教程

    C语言创建和操作单链表数据结构的实例教程

    1,为什么要用到链表 数组作为存放同类数据的集合,给我们在程序设计时带来很多的方便,增加了灵活性.但数组也同样存在一些弊病.如数组的大小在定义时要事先规定,不能在程序中进行调整,这样一来,在程序设计中针对不同问题有时需要3 0个大小的数组,有时需要5 0个数组的大小,难于统一.我们只能够根据可能的最大需求来定义数组,常常会造成一定存储空间的浪费. 我们希望构造动态的数组,随时可以调整数组的大小,以满足不同问题的需要.链表就是我们需要的动态数组.它是在程序的执行过程中根据需要有数据存储就向系统要求

  • C语言实现单链表逆序与逆序输出实例

    单链表的逆序输出分为两种情况,一种是只逆序输出,实际上不逆序:另一种是把链表逆序.本文就分别实例讲述一下两种方法.具体如下: 1.逆序输出 实例代码如下: #include<iostream> #include<stack> #include<assert.h> using namespace std; typedef struct node{ int data; node * next; }node; //尾部添加 node * add(int n, node * h

  • C语言单循环链表的表示与实现实例详解

    C语言单循环链表的表示与实现实例详解

    1.概述: 对于一个循环链表来说,其首节点和末节点被连接在一起.这种方式在单向和双向链表中皆可实现.要转换一个循环链表,可以选择开始于任意一个节点然后沿着列表的任一方向直到返回开始的节点.再来看另一种方法,循环链表可以被视为"无头无尾".这种列表很利于节约数据存储缓存, 假定你在一个列表中有一个对象并且希望所有其他对象迭代在一个非特殊的排列下. 指向整个列表的指针可以被称作访问指针. 用单向链表构建的循环链表 循环链表中第一个节点之前就是最后一个节点,反之亦然.循环链表的无边界使得在这

  • C语言实现带头结点的链表的创建、查找、插入、删除操作

    本文实例讲述了C语言实现带头结点的链表的创建.查找.插入.删除操作.是数据结构中链表部分的基础操作.分享给大家供大家参考.具体方法如下: #include <stdio.h> #include <stdlib.h> typedef struct node { int data; struct node* next;// 这个地方注意结构体变量的定义规则 } Node, *PNode; Node* createLinklist(int length) { int i = 0; PNo

  • C语言实现双向链表

    C语言实现双向链表

    这个小代码是我凭自己对指针和链表的理解和认识,自己实现的,没有参考其他人的代码,如果有相同的地方,那真的只是巧合,代码我在ubuntu 15.04下测试通过,可能存在很多错误和漏洞． doublelist.c /************************************************************************* > File Name: doublelist.c > Author: ChenYiLiang > Mail: chenyilian

  • C语言单向链表的表示与实现实例详解

    C语言单向链表的表示与实现实例详解

    1.概述: C语言中的单向链表(单链表)是链表的一种,其特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始. 链表中最简单的一种是单向链表,它包含两个域,一个信息域和一个指针域.这个链接指向列表中的下一个节点,而最后一个节点则指向一个空值. 如下图所示: 一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接 一个单向链表的节点被分成两个部分.第一个部分保存或者显示关于节点的信息,第二个部分存储下一个节点的地址.单向链表只可向一个方向遍历. 链表最基本的结构是在每个节点

随机推荐