C数据结构之双链表详细示例分析

代码如下:

typedef struct node
{
      struct node *prior;
      struct node *next;
       int num;
}NODE;
/*******双向链表的初始化********/
NODE *Init_link(void)
{
     int i;
     NODE *phead,*pb,*pi;
     phead = (NODE *)malloc(sizeof(NODE));
     printf("please input num:\n");
     scanf("%d",&(phead->num));
     phead->prior = NULL;
     phead->next = NULL;
     pb = phead;
     for(i=0; i<3; i++)
     {
          pi = (NODE *)malloc(sizeof(NODE));
          printf("please input num:\n");
              scanf("%d",&(pi->num));
          pi->next = NULL;
          pb->next = pi;
          pi->prior = pb;
          pb = pi;
     }
     return phead;
}
/******链表的输出******/
void print_link(NODE *phead)
{
 while(phead != NULL)
 {
  printf(" %d,",phead->num);
  phead = phead->next;
 }
 printf("\n");
}
/******链表的逆序******/
NODE *reverse_link(NODE *phead)
{
 NODE *pb,*pf,*temp;
 pb = phead;
 pf = pb->next;
 while(pf != NULL)
 {
  temp = pf->next;
  pf->next = pb;
  pb->prior = pf;
  pb = pf;
  pf = temp;
 }
// phead->prior = pf->prior;
 phead->next = NULL;
 phead = pb;
 return phead;
}
/*****链表的排序*****/
NODE *Order_link(NODE *phead)
{
     NODE *pb,*pf,*ptr,temp;
     pb = phead;
     while(pb->next != NULL)
     {
          pf = pb->next;
          while(pf != NULL)
          {
               if(pb->num > pf->num)
               {
                     temp = *pb;
                    *pb = *pf;
                    *pf = temp;
                     ptr = pb->next;
                     pb->next = pf->next;
                     pf->next = ptr;
                     ptr = pb->prior;
                     pb->prior = pf->prior;
                     pf->prior = ptr;
              }
             pf = pf->next;
        }
        pb = pb->next;
    }
    return phead;
}
/******链表的有序插入*****/
NODE *insert_link(NODE *phead,NODE *pi)
{
 NODE *pb,*pf;
 pb = phead;
 if(pi == NULL)
  return phead;
 if(phead == NULL)
 {
  phead = pi;
  pi->prior = NULL;
  pi->next =NULL;
 }
 else
 {
  while( (pi->num > pb->num)&&(pb->next!=NULL))
  {
   pf = pb;
   pb = pb->next;
  }
  if(pi->num <= pb->num)
  {
   if(pb == phead)
   {
    pi->next = phead;
    pi->prior = NULL;
    phead->prior = pi;
    phead = pi;
   }
   else
   {
    pi->next = pb;
    pb->prior = pi;
    pi->prior = pf;
    pf->next = pi;
   }
  }
  else
  {
   pi->next = NULL;
   pi->prior = pb;
   pb->next = pi;
  }
 }
 return phead;
}
/******链表的删除*****/
NODE *delete_link(NODE *phead, NODE *pi)
{
 NODE *pb,*pf;
 pb = phead;
 while(pb != NULL)
 {
  if(pb == pi)
  {
   if(pb == phead)
    phead = phead->next;
   else if(pb->next == NULL)
    pf->next = NULL;
   else
   {
    pf->next = pb->next;
    //pb->next->prior = pf;
   }
  }
  pf = pb;
  pb = pb->next;
 }
 return phead;
}
/*******链表的释放******/
void free_link(NODE *phead)
{
 NODE *pb;
 while(phead != NULL)
 {
  pb = phead->next;
  free(phead);
  phead = pb;
 }
 printf("released link success!\n");
}
/*******测试程序******/
int main(void)
{
 NODE *phead,*pi;
 phead = Init_link();
 printf("init link:\n");
 print_link(phead);

pi = (NODE *)malloc(sizeof(NODE));
 printf("plaese input insert num:");
 scanf("%d",&(pi->num));
 phead = insert_link(phead,pi);
 printf("after insert link:\n");
 print_link(phead);
 phead = Order_link(phead);
 printf("after sort link:\n");
 print_link(phead);

printf("after reverse link:\n");
 phead = reverse_link(phead);
 print_link(phead);
 phead = delete_link(phead, pi);
 printf("after delete link:\n");
 print_link(phead);
 free_link(phead);
 return 0;
}

(0)

相关推荐

  • C/C++ 双链表之逆序的实例详解

    C/C++ 双链表之逆序的实例详解 一.结点结构 双向链表的数据结构定义如下: typedef struct node { ElemType data; struct node *prior struct node *next; }list; 其中,ElemType可以是任意数据类型如int.float或者char等,在算法中,规定其默认为int类型. 二.带头结点 本文描述的是双向链表逆序,链表逆序需要维护3个指针,分别指向前一个节点.当前节点和下一个节点,具体代码如下: list *reve

  • 详解java数据结构与算法之双链表设计与实现

    在单链表分析中,我们可以知道每个结点只有一个指向后继结点的next域,倘若此时已知当前结点p,需要查找其前驱结点,那么就必须从head头指针遍历至p的前驱结点,操作的效率很低,因此如果p有一个指向前驱结点的next域,那效率就高多了,对于这种一个结点中分别包含了前驱结点域pre和后继结点域next的链表,称之为双链表.本篇我们将从以下结点来分析双链表 双链表的设计与实现 双链表的主要优点是对于任意给的结点,都可以很轻易的获取其前驱结点或者后继结点,而主要缺点是每个结点需要添加额外的next域,因

  • 详解Redis中的双链表结构

    Redis中双链表实现的基本结构: 1.节点结构 typedef struct listNode { struct listNode *prev; //前向节点 struct listNode *next; //后向节点 void *value; //该节点的值 } listNode; 2.双向链表结构 typedef struct list { listNode *head; //头节点 listNode *tail; //尾节点 void *(*dup)(void *ptr); //复制函数

  • Node.js环境下JavaScript实现单链表与双链表结构

    单链表(LinkedList)的javascript实现 npmjs相关库: complex-list.smart-list.singly-linked-list 编程思路: add方法用于将元素追加到链表尾部,借由insert方法来实现: 注意各个函数的边界条件处理. 自己的实现: SingleNode.js (function(){ "use strict"; function Node(element){ this.element = element; this.next = n

  • javascript数据结构之双链表插入排序实例详解

    本文实例讲述了javascript数据结构之双链表插入排序实现方法.分享给大家供大家参考,具体如下: 数组存储前提下,插入排序算法,在最坏情况下,前面的元素需要不断向后移,以便在插入点留出空位,让目标元素插入. 换成链表时,显然无需做这种大量移动,根据每个节点的前驱节点"指针",向前找到插入点后,直接把目标值从原链表上摘下,然后在插入点把链表断成二截,然后跟目标点重新接起来即可. <!doctype html> <html> <head> <t

  • PHP 双链表(SplDoublyLinkedList)简介和使用实例

    双链表是一种重要的线性存储结构,对于双链表中的每个节点,不仅仅存储自己的信息,还要保存前驱和后继节点的地址. PHP SPL中的SplDoublyLinkedList类提供了对双链表的操作. SplDoublyLinkedList类摘要如下: SplDoublyLinkedList implements Iterator , ArrayAccess , Countable { public __construct ( void ) public void add ( mixed $index ,

  • 简单介绍线性表以及如何实现双链表

    线性表是一种线性结构,它是具有相同类型的n(n≥0)个数据元素组成的有限序列. 一.数组 数组有上界和下界,数组的元素在上下界内是连续的. 存储10,20,30,40,50的数组的示意图如下: 数组的特点:数据是连续的:随机访问速度快. 数组中稍微复杂一点的是多维数组和动态数组.对于C语言而言,多维数组本质上也是通过一维数组实现的.至于动态数组,是指数组的容量能动态增长的数组:对于C语言而言,若要提供动态数组,需要手动实现:而对于C++而言,STL提供了Vector:对于Java而言,Colle

  • C++ 双链表的基本操作(详解)

    1.概念 双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱.所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点.一般我们都构造双向循环链表. 结构图如下所示: 2.基本操作实例 DoubleList.cpp #include "stdafx.h" #include "DoubleList.h" #include <stdio.h> #include <malloc.h>

  • C数据结构之双链表详细示例分析

    复制代码 代码如下: typedef struct node{      struct node *prior;      struct node *next;       int num;}NODE;/*******双向链表的初始化********/NODE *Init_link(void){     int i;     NODE *phead,*pb,*pi;     phead = (NODE *)malloc(sizeof(NODE));     printf("please inpu

  • C数据结构之单链表详细示例分析

    复制代码 代码如下: #include <stdio.h>#include <stdlib.h>typedef struct type{ int num; struct type *next;}TYPE;//=============================================================// 语法格式: TYPE *init_link_head(int n)// 实现功能: 从头到尾,正序创建一个具有n个节点的链表,并对其值进行初始化//

  • Go 语言数据结构之双链表学习教程

    目录 双链表 创建节点 双链表遍历 扩展功能 链表长度 插入 删除 反转双链表 总结 双链表 双链表 (Doubly Linked List),每个节点持有一个指向列表前一个元素的指针,以及指向下一个元素的指针. 双向链表的节点中包含 3 个字段: 数据域 Value 一个 Next 指针指向双链表中的下一个节点 一个 Prev 指针,指向双链表中的前一个节点 结构体如下: type Node struct { Prev *Node Value int Next *Node } 实际应用: 音乐

  • C语言数据结构之单向链表详解分析

    链表的概念:链表是一种动态存储分布的数据结构,由若干个同一结构类型的结点依次串连而成. 链表分为单向链表和双向链表. 链表变量一般用指针head表示,用来存放链表首结点的地址. 每个结点由数据部分和下一个结点的地址部分组成,即每个结点都指向下一个结点.最后一个结点称为表尾,其下一个结点的地址部分的值为NULL(表示为空地址). 特别注意:链表中的各个结点在内存中是可以不连续存放的,具体存放位置由系统分配. 例如:int *ptr ; 因此不可以用ptr++的方式来寻找下一个结点. 使用链表的优点

  • Java实现双链表的示例代码

    目录 一.双向链表是什么 二.具体方法实现 定义结点 下标访问异常 获取链表长度 打印链表 清空链表 头插法 尾插法 指定位置插入 查找元素 删除第一次出现的关键字 删除所有值为key的节点 三.完整代码 一.双向链表是什么 双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱.所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点.一般我们都构造双向循环链表. LinkedList底层就是一个双向链表,我们来实现一个双向链表. 这

  • PHP递归算法的详细示例分析

    我们在建设一个网站的时候,程序员们首选的当属PHP语言.我们对PHP还是比较熟悉的,接下来我们将会为大家介绍一下PHP递归算法.PHP,一个嵌套的缩写名称,是英文超级文本预处理语言(PHP:Hypertext Preprocessor)的缩写. PHP 是一种 HTML 内嵌式的语言,是一种在服务器端执行的嵌入HTML文档的脚本语言,语言的风格有类似于C语言,现在被很多的网站编程人员广泛的运用.PHP 独特的语法混合了 C.Java.Perl 以及 PHP 自创新的语法.它可以比 CGI 或者

  • mysql 关键词相关度排序方法详细示例分析

    小项目有时需要用到关键词搜索相关性排序,用sphinx显得杀鸡用牛刀,就用mysql的order by对付下.方法一: 复制代码 代码如下: select * from articles where (title LIKE '%keywords%') or (content LIKE '%helloworld%') order by ((CASE WHEN title LIKE '%keywords%' THEN 2 ELSE 0 END) + (CASE WHEN content LIKE '

  • c语言中static的用法详细示例分析

    static在c里面可以用来修饰变量,也可以用来修饰函数.先看用来修饰变量的时候.变量在c里面可分为存在全局数据区.栈和堆里.其实我们平时所说的堆栈是栈而不是堆,不要弄混. 复制代码 代码如下: int a ;int main(){    int b ;     int c* = (int *)malloc(sizeof(int));} a是全局变量,b是栈变量,c是堆变量.static对全局变量的修饰,可以认为是限制了只能是本文件引用此变量.有的程序是由好多.c文件构成.彼此可以互相引用变量,

  • 二叉树的遍历算法(详细示例分析)

    复制代码 代码如下: #include<iostream>#include<assert.h>#include<stack>#include<queue>using namespace std;struct Node{    int v;    Node *leftChild,*rightChild;    Node():leftChild(NULL),rightChild(NULL){}    Node(int vv):leftChild(NULL),ri

随机推荐