单向链表实现

单向链表

单链表有一个头节点head,指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型,节点有两个成员:整型成员(实际需要保存的数据)和指向下一个结构体类型节点的指针即下一个节点的地址(事实上,此单链表是用于存放整型数据的动态数组)。链表按此结构对各节点的访问需从链表的头找起,后续节点的地址由当前节点给出。无论在表中访问那一个节点,都需要从链表的头开始,顺序向后查找。链表的尾节点由于无后续节点,其指针域为空,写作为NULL。

<a href="http://www.emacsvi.com/wp-content/uploads/2015/10/linkedlist.bmp"><img src="http://www.emacsvi.com/wp-content/uploads/2015/10/linkedlist.bmp" alt="linkedlist" width="600" height="130" class="alignnone size-full wp-image-274" /></a>

<pre lang="c" escaped="true">

/* linkedlist.h */
#ifndef LINKEDLIST_H
#define LINKEDLIST_H

typedef struct node *link;
struct node
{
unsigned char elem;
link next;
};

link make_node(unsigned char elem);
void free_node(link p);
link search(unsigned char elem);
void insert(link p);
void delete(link p);
void traverse(void (*visit)(link));
void destroy(void);
void push(link p);
link pop(void);

#endif

</pre>

<pre lang="c" escaped="true">

#include <stdlib.h>
#include "linkedlist.h"

static link head=NULL;

link make_node(unsigned char elem)
{
link p = malloc(sizeof(*p));
p->elem = elem;
p->next = NULL;
return p;
}

void free_node(link p)
{
free(p);
}

link search(unsigned char elem)
{
link p;
for (p = head; p; p = p->next)
if (elem == p->elem)
return p;
return NULL;
}

void insert(link p)
{
p->next = head;
head = p;
}

void delete(link p)
{
link pre;
if (head == p)
{
head = p->next;
return;
}
for (pre = head; pre; pre = pre->next)
if (pre->next == p)
{
pre->next = p->next;
return;
}
}

/* 没有看太明白
void delete(link p)
{
link *pnext;
for (pnext = &head; *pnext; pnext = &(*pnext)->next)
if (*pnext == p)
{
*pnext = p->next;
return;
}
}
*/

void traverse(void (*visit)(link))
{
link p;
for (p = head; p; p = p->next)
visit(p);
}

void destroy(void)
{
link q, p=head;
head = NULL;
while (p)
{
q = p;
p = p->next;
free_node(q);
}
}

void push(link p)
{
insert(p);
}

link pop(void)
{
if (NULL == head)
return NULL;
else
{
link p = head;
head = head->next;
return p;
}
}

</pre>

<pre lang="c" escaped="true">

#include <stdio.h>
#include "linkedlist.h"

void print_elem(link p)
{
printf("%d\n", p->elem);
}

int main(void)
{
link p;

insert(make_node(10));
insert(make_node(5));
insert(make_node(90));
p = search(5);
delete(p);
free_node(p);
traverse(print_elem);
destroy();
push(make_node(100));
push(make_node(200));
push(make_node(250));
while (p = pop())
{
print_elem(p);
free_node(p);
}

return 0;
}

</pre>

时间: 2024-10-01 22:01:18

单向链表实现的相关文章

数据结构与算法学习-单向链表的实现

链表(Chain本文所说链表均为单向链表,以下均简称单向链表)实际上是由节点(Node)组成的,一个链表拥有不定数量的节点.而向外暴露的只有一个头节点(Head),我们对链表的所有操作,都是直接或者间接地通过其头节点来进行的. 节点(Node)是由一个需要储存的对象及对下一个节点的引用组成的.也就是说,节点拥有两个成员:储存的对象.对下一个节点的引用. 这样说可能大家不是很明白,我贴一张图大家可能更容易理解. package LinkedList; /** * <p><strong>

算法总结之 反转部分单向链表

给定单链表的表头节点head, 以及两个整数from 和 to, 在单向链表上把fro个节点到第to个节点这一部分进行反转 思路: 本题 有可能存在换头的问题,所以函数应该返回调整后的新的头节点 1 判断是否满足 1<=from<=to<=N 如果不满足,直接返回原来的头节点 2 找到第from-1个节点pre和第to+1个节点tPos,fPre即要反转部分的前一个节点,tPos是反转部分的后一个节点,把反转部分先反转,然后正确的链接fPre和tPos package TT; impor

C语言之字符单向链表

/* * @Author: suifengtec * @Date:   2017-09-02 16:06:33 * @Last Modified by:   suifengtec * @Last Modified time: 2017-09-02 20:47:13 **/ /* 字符单向链表 gcc -o a.exe main.c && a  */ #include <stdio.h> #include <stdlib.h> #include <stdbool

C++__单向链表(练习)

单向链表 link.h #ifndef LINK_H_ #define LINK_H_ #define HEADER 0 #define TAIL -1 typedef int data_type; enum LINK_OP { LINK_ERR = -1, LINK_OK }; class LINK { private: data_type data; LINK *next; public: LINK(); LINK(data_type data); virtual ~LINK(); data

单向链表模板

写个单向链表模板练练手: #include <bits/stdc++.h> using namespace std; //create // delete // modify // search class Node{ public: int data; Node* ptr; Node(int elem= 0, Node* node= NULL){ this->data= elem; this->ptr= NULL; } }; class MyList{ private: Node

C#学习单向链表和接口 IList&lt;T&gt;

作者:乌龙哈里 时间:2015-11-04 平台:Window7 64bit,Visual Studio Community 2015 参考: MSDN 索引器(C# 编程指南) <数据结构(C#语言版)>下载 When to use IEnumerable, ICollection, IList and List 章节: 单向链表元素 定义单向链表操作接口 逐步实现单向链表 正文: 前面学习了 IEnumerable<T>.IComparable<T>.ICollec

循环单向链表(约瑟夫环)

#include <stdio.h> #include <stdlib.h> typedef struct List { int data; struct List *next; }List; //创建循环单向链表n为长度 List *list_create(int n) { List *head, *p; int i; head = (List *)malloc(sizeof(List)); p = head; p->data = 1; //创建第一个结点 for (i =

给定单向链表的头指针和一个结点指针,定义一个函数在O(1)时间删除该结点

#include <iostream> #include <string.h> #include <stdlib.h> #include <stack> using namespace std; struct Node { int data; struct Node* next; }; struct Node* create_list(int len) { if (len <= 0) return NULL; struct Node* head; st

python数据结构链表之单向链表

本文和大家分享的主要是python中单向链表相关内容,一起来看看吧,希望对大家学习python有所帮助. 单向链表 单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域.这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值. . 表元素域elem用来存放具体的数据. . 链接域next用来存放下一个节点的位置(python中的标识) . 变量p指向链表的头节点(首节点)的位置,从p出发能找到表中的任意节点. 节点实现 class 

数据结构-单向链表 C和C++的实现

数据结构,一堆数据的存放方式. 今天我们学习数据结构中的 链表: 数组,大家相当熟悉的存放数据方式,而链表是数组的一种特殊方式,它每个节点包括两个部分: 数据域:存放数据,此部分与数组相同 指针域:存放了下一个节点的地址 链表比数组多了指针域,因为链表需要通过上一个节点的指针域去找下一个数据,比如有一个链表ABCD四个节点,我们要访问D里边的数据.操作如下: 先通过A节点的指针域找到B节点 再通过B节点的指针域找到C节点 再通过C节点的指针域找到D节点 获取D节点数据域的数据 对比数组直接通过下