数据结构_链表

#ifndef __DOUBLE_LINK_LIST_H__
#define __DOUBLE_LINK_LIST_H__
/*链表节点*/
typedef struct ListNode
{
    int        data;//有效数据
    struct  ListNode *prev;//指向前一个节点
    struct  ListNode *next;//指向后一个节点
}LIST_NODE;
/*链表*/
typedef struct List
{
    LIST_NODE *head;//指向链表中第一个节点
    LIST_NODE *tail;//指向链表中最后一个节点
}LIST;
/*创建空链表*/
LIST *list_create(void);
/*销毁链表*/
void list_destroy(LIST *list);
/*尾部插入*/
void list_append(LIST *list, int data);
/*指定位置插入*/
int list_insert(LIST *list, int pos, int data);
/*后向遍历*/
void list_next_print(LIST *list);
/*前向遍历*/
void list_prev_print(LIST *list);
#endif
#include <stdio.h>
#include <stdlib.h>
#include "double_link_list.h"

/*创建空链表*/
LIST *list_create(void)
{
    LIST *list = malloc(sizeof(LIST));
    list->head = NULL;
    list->tail = NULL;
    return list;
}
/*销毁链表*/
void list_destroy(LIST *list)
{

}
LIST_NODE *node_create(int data, LIST_NODE *prev,
                        LIST_NODE *next)
{
    LIST_NODE *node = malloc(sizeof(LIST_NODE));
    node->data = data;
    node->prev = prev;
    node->next = next;
    return node;
}
/*尾部插入*/
void list_append(LIST *list, int data)
{
    /*需要关注head tail
      新节点的 next prev
      老的尾节点的next
    */
    /*1 动态申请节点空间,并初始化*/
    /*2 重置了链表尾结点*/
    list->tail = node_create(data,list->tail,NULL);
    /*3 如果原来为空链表, 修改head*/
    if(list->head == NULL)
    {
        list->head = list->tail;
    }
    /*4 如果原链表不为空*/
    else
    {
        /*原尾结点的next=新尾结点的地址*/
        list->tail->prev->next = list->tail;
    }
}
/*指定位置插入*/
int list_insert(LIST *list, int pos, int data)
{

}
/*后向遍历*/
void list_next_print(LIST *list)
{
    LIST_NODE *node = list->head;
    for(; node; node=node->next)
    {
        printf("%d ", node->data);
    }
    printf("\n");
}
/*前向遍历*/
void list_prev_print(LIST *list)
{

}
#include <stdio.h>
#include <stdlib.h>
#include "double_link_list.h"

int main()
{
    /*1 创建空链表*/
    LIST *list = list_create();
    /*2 尾部插入节点*/
    list_append(list, 10);
    list_append(list, 30);
    list_append(list, 60);
    /*3 遍历打印*/
    list_next_print(list);
    return 0;
}
#include <stdio.h>
#include <stdlib.h>

/*节点*/
typedef struct ListNode
{
    int data;//存放有效数据
    struct ListNode *next;//指向后继节点
}LIST_NODE;
/*链表*/
typedef struct List
{
    LIST_NODE *head;    //存放链表中第一个节点的地址
    int size ;//记录链表中节点的个数
}LIST;

LIST *list_create()
{
    LIST *list = malloc(sizeof(LIST));
    /*初始化成员变量*/
    list->head = NULL;
    list->size = 0;
    return list;
}
/*创建节点*/
LIST_NODE *node_create(int data)
{
    LIST_NODE *node = malloc(sizeof(LIST_NODE));
    node->data = data;
    node->next = NULL;
    return node;
}
/*前部插入*/
void list_insert(LIST *list, int data)
{
    LIST_NODE *node = node_create(data);
    node->next = list->head;
       list->head = node;
    list->size++;
}
/*后部插入*/
void list_insert2(LIST *list, int data)
{
    /*1 找到最后一个节点*/
    LIST_NODE *node = list->head;
    while(node != NULL)
    {
        if(node->next == NULL)//node指向最后一个节点
        {
            break;
        }
        node = node->next; //指向下个节点,继续判断是否为最后一个节点
    }
    /* 创建新的节点*/
    if(node != NULL)//原链表不为空
    {
        node->next = node_create(data);
    }
    else
    {
        list->head = node_create(data);
    }

}
void list_print(LIST *list)
{
    LIST_NODE *node = NULL;
    for(node=list->head; node; node=node->next)
    {
        printf("%d ", node->data);
    }
    printf("\n");
}
void list_del(LIST *list, int data)
{
    /*找到要删除的节点和它的前一个节点*/
    LIST_NODE *node = list->head;//指向第一个节点,可能为空链表
    LIST_NODE *prev = NULL;//保存要删除节点的前一个节点
    while(node != NULL)
    {
        if(node->data == data)//找到要删除的节点
        {
            //如果要删除的节点为链表中第一个节点
            if(node == list->head)
            {
                list->head = node->next;
                free(node);
                node = list->head; // 指向下个节点继续循环判断
            }
            else //要删除的节点不为链表中的第一个节点
            {
                //从链表中剔除node指向的节点
                prev->next = node->next;
                free(node);
                node = prev->next; //指向刚删除节点的下一个节点
            }
        }
        else //该节点不是要删除的节点
        {
            prev = node;
            node = node->next; //指向下个节点继续循环判断
        }
    }
}
LIST_NODE *node_destroy(LIST_NODE *node)
{
    LIST_NODE *next = node->next;
    free(node);
    return next;
}
void list_destroy(LIST *list)
{
    /*清空链表,使其为空链表*/
    while(list->head)
    {
        list->head = node_destroy(list->head);
    }
    free(list);
}
void list_update(LIST *list, int old, int new)
{
    LIST_NODE *node = NULL;
    /*遍历链表中的每一个节点*/
    for(node=list->head; node; node=node->next)
    {
        if(node->data == old)
        {
            node->data = new;
        }
    }
}
int main()
{
    /*1 创建空单向链表*/
    LIST *list = list_create();
    /*2 插入节点*/
    list_insert(list, 11);
    list_insert(list, 22);
    list_insert(list, 22);
    list_insert(list, 22);
    list_insert(list, 22);
    list_insert(list, 22);
    list_insert(list, 33);
    list_insert(list, 44);
    list_insert(list, 55);
    list_insert(list, 66);
    list_insert2(list, 101);
    list_insert2(list, 102);
    list_insert2(list, 103);
    /*3 遍历链表*/
    list_print(list);
    /*4 删除链表中的节点*/
    list_del(list, 33);
    list_del(list, 11);
    list_del(list, 66);
    list_print(list);
    /*5 修改节点*/
    list_update(list, 22, 99);
    list_print(list);
    /*6 销毁链表*/
    list_destroy(list);

    return 0;
}
时间: 2024-10-11 16:16:45

数据结构_链表的相关文章

C++_数据结构_链表的链式实现

传统的链表不能实现数据和链表的分离,一旦数据改变则链表就不能用了,就要重新开发. 如上说示:外层是Teacher,里面小的是node.

基本数据结构:链表(list)

copy from:http://www.cppblog.com/cxiaojia/archive/2012/07/31/185760.html 基本数据结构:链表(list) 谈到链表之前,先说一下线性表.线性表是最基本.最简单.也是最常用的一种数据结构.线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的.线性表有两种存储方式,一种是顺序存储结构,另一种是链式存储结构. 顺序存储结构就是两个相邻的元素在内存中也是相邻的.这种存储方式的优点是

数据结构_课程设计——最小生成树:室内布线

***************************************转载请注明出处:http://blog.csdn.net/lttree******************************************** 这道课程设计,费不少时间,太麻烦了= =.(明明是能力不够) ~~~~最小生成树:室内布线~~~~ 题目要求: 装修新房子是一项颇为复杂的工程,现在需要写个程序帮助房主设计室内电线的布局. 首先,墙壁上插座的位置是固定的.插座间需要有电线相连,而且要布置的整齐美

数据结构_课程设计——并查集:检查网络

***************************************转载请注明出处:http://blog.csdn.net/lttree******************************************** 这两天做数据结构课程设计,因为以前做过ACM题,感觉还可以,不是很难呀 ~~~~并查集:检查网络~~~~ 题目要求: 给定一个计算机网络以及机器间的双向连线列表,每一条连线允许两端的计算机进行直接的文件传输,其他计算机间若存在一条连通路径,也可以进行间接的文件传

数据结构之链表单向操作总结

链表是数据结构的基础内容之一,下面就链表操作中的创建链表.打印链表.求取链表长度.判断链表是否为空.查找结点.插入结点.删除结点.逆转链表.连接链表.链表结点排序等进行总结. 1.创建表示结点的类,因为链表操作中需要比较结点,因此结点需要实现comparable接口. public class Node implements Comparable<Node> { private Object data; private Node next; //构造函数 public Node() { thi

数据结构-复杂链表的复杂

题目:请实现函数ComplexListNode*  Clone(ComplexListNode* pHead),复杂一个复杂链表.在复杂链表中,每个节点除了有一个Next指针指向下一个节点外,还有一个Sibling指向链表中的任意节点或者NULL. 分析:第一反应是先复制Next,再复制Sibling.但是这种方式需要两次遍历.时间性不是很好.所以利用一个长链表方式解决时间效率. /* 剑指offer面试题26 */ #include <iostream> #include <cstri

Windows 已在 数据结构_顺序表.exe 中触发一个断点——new和delete注意事项

实现数据结构的顺序表的类时,输入,改,删,查都可以,但是最后析构函数时持续出错 错误提示"Windows 已在 数据结构_顺序表.exe 中触发一个断点" int *elem=new int(LIST_INIT_SIZE); if(!elem)cout<<"overflow"<<endl; if(leng>LIST_INIT_SIZE) cout<<"error"; else {    length=le

AT&amp;T汇编语言与GCC内嵌汇编,Linux内核数据结构之链表

最近在看<Linux内核源代码情景分析>,作者毛德操.书中刚开始介绍了AT&T汇编语言与GCC内嵌汇编,以及Linux内核数据结构之链表.可惜书中介绍的不够全面.因为推荐大家阅读下面两篇文章.很不错. AT&T汇编语言与GCC内嵌汇编:http://grid.hust.edu.cn/zyshao/Teaching_Material/OSEngineering/Chapter2.pdf. Linux内核数据结构之链表:http://www.cnblogs.com/Anker/p/

算法实例_链表结构 By:比方

前一章,我们说到了顺序表结构,而顺序表也存在一些的缺点. 在插入或者删除节点的时候,需要移动的数据比较大,如果顺序表结构比较大,有时候比较难以分配足够的连续存储空间,可能会导致内存分配失败,而导致无法存储. 而今天我们讲解的链表结构则可以很好的解决这个问题,链表的结构是一种动态存储分配的结构形式,可以根据需要动态申请所需的内存单元. 一.什么是链表结构? a)         我们用head来表示头节点. b)         数据部分保存的是存储的数据,地址地方指向下一个数据的起始部分,依次向