c/c++ 线性表之双向链表
c/c++ 线性表之双向链表
线性表之双向链表
不是存放在连续的内存空间,链表中的每个节点的next都指向下一个节点,每个节点的before都指向前一个节点,最后一个节点的下一个节点是NULL。
真实的第一个节点是头节点,头节点不存放数据,单纯为了编写程序方便。但是下面注释里写的【第一个节点】的含义是头节点的下一节点,也就是真实存放数据的第一个节点。
下面的代码实现了以下功能
函数 | 功能描述 |
---|---|
push_back | 从链表的最后插入节点 |
push_front | 从链表的起始插入节点 |
show_list | 打印出链表里每个节点的值 |
pop_back | 删除链表最后一个节点 |
pop_front | 删除链表起始节点 |
insert_val | 在合适的位置插入一个节点; 比如原来的链表:1->3->NULL,当要插入的节点的值为2的时候,就会在1和3之间插入这个节点,插入后的链表:1->2->3->NULL |
find | 查找指定的节点 |
length | 返回链表中节点的个数 |
delete_val | 删除指定的节点 |
sort | 排序,重新排列节点 |
resver | 按倒序,重新排列节点 |
clear | 释放除了头节点之外的所有节点所占用的内存空间 |
destroy | 释放所有节点的所占用的内存空间,包括头节点 |
shuangnode.h
#ifndef __SHUANGNODE__
#define __SHUANGNODE__
#include <stdio.h>
#include <malloc.h>
#include <assert.h>
#include <memory.h>
#include <stdbool.h>
#define ElemType int
typedef struct Node{
ElemType data;
struct Node* before;
struct Node* next;
}Node;
typedef struct NodeList{
Node* first;
Node* last;
size_t size;
}NodeList;
void init(NodeList*);
void push_back(NodeList*, ElemType);
void push_front(NodeList*, ElemType);
void pop_back(NodeList*);
void pop_front(NodeList*);
void show_list(NodeList*);
void insert_val(NodeList*, ElemType);
Node* find(NodeList*, ElemType);
void delete_val(NodeList*, ElemType);
void sort(NodeList*);
void sort1(NodeList*);
void resver(NodeList*);
void resver1(NodeList*);
void resver2(NodeList*);
void clear(NodeList*);
void destroy(NodeList*);
#endif
shuangnode.c
#include "shuangnode.h"
void init(NodeList* list){
list->first = (Node*)malloc(sizeof(Node));
list->last = list->first;
list->last->next = NULL;
list->size = 0;
}
Node* create_node(ElemType val){
Node* node = (Node*)malloc(sizeof(Node));
assert(NULL != node);
node->data = val;
node->before = NULL;
node->next = NULL;
return node;
}
void push_back(NodeList* list, ElemType val){
Node* p = create_node(val);
p->before = list->last;
p->next = NULL;
list->last->next = p;
list->last = p;
list->size++;
}
void push_front(NodeList* list, ElemType val){
Node* p = create_node(val);
//设置p的before和next
p->before = list->first;
p->next = list->first->next;
//第一次添加节点的时候要移动未指针
if(NULL == list->first->next){
list->last = p;
}
//不是第一次添加节点的时候,要把原第一个节点的before指向,新添加的节点
else{
list->first->next->before = p;
}
//设置头指针的next节点
list->first->next = p;
list->size++;
}
void show_list(NodeList* list){
Node* tmp = list->first->next;
while(tmp != NULL){
printf("%d->", tmp->data);
tmp = tmp->next;
}
printf("NULL\n");
}
void pop_back(NodeList* list){
if(list->size == 0)return;
free(list->last);
//让尾指针的next指向NULL
list->last->before->next = NULL;
//让尾指针指向原尾节点的前一个节点
list->last = list->last->before;
list->size--;
}
void pop_front(NodeList* list){
if(list->size == 0)return;
free(list->first->next);
//就剩一个节点的时候,要移动尾指针。因为list->first->next已经为NULL,下面的list->first->next->before就会在执行时候崩掉,所以要return掉
if(list->first->next == list->last){
list->last = list->first;
list->last->next = NULL;
list->size--;
return;
}
//头指针的next指向第二个节点
list->first->next = list->first->next->next;
//第二个节点的before指向头节点
list->first->next->before = list->first;
list->size--;
}
void insert_val(NodeList* list, ElemType val){
Node* n = create_node(val);;
Node* p = list->first;
while(p->next != NULL && val > p->next->data){
p = p->next;
}
//第一次加节点,或者,最后一个节点也没有给的值大的时候
if(NULL == p->next){
n->next = NULL;
n->before = list->last;
list->last->next = n;
list->last = n;
list->size++;
return;
}
//新节点的next指向原节点的下一个节点
n->next = p->next;
//原节点的next指向新节点,注意这句的位置必须在上句的下面
p->next = n;
//新节点的下一个节点的before指向新节点
n->next->before = n;
//新节点的before指向原节点
n->before = p;
list->size++;
}
//寻找给定值的节点的位置
Node* find(NodeList* list, ElemType val){
if(list->size == 0)return NULL;
Node* p = list->first;
while(p->next != NULL && p->next->data != val){
p = p->next;
}
if(NULL == p->next){
return NULL;
}
printf("%d is found\n", p->next->data);
return p->next;
}
//寻找给定值的节点的前一个节点的位置
Node* find1(NodeList* list, ElemType val){
if(list->size == 0)return NULL;
Node* p = list->first;
while(p->next != NULL && p->next->data != val){
p = p->next;
}
if(NULL == p->next){
return NULL;
}
printf("%d is found\n", p->next->data);
return p;
}
void delete_val(NodeList* list, ElemType val){
Node* p = find1(list, val);
if(NULL == p) return;
free(p->next);
//删除的节点是尾节点的时候,要移动last
if(p->next == list->last){
list->last = p;
p->next = NULL;
list->size--;
return;
}
p->next->next->before = p;
p->next = p->next->next;
list->size--;
}
void sort(NodeList* list){
if(list->size == 1 || list->size == 0)return;
//p为第一个节点
Node* p = list->first->next;
//t是空白list,往t里加节点
Node* t = list->first;
list->last = list->first;
list->last->next = NULL;
size_t sz = list->size;
Node* tmp;
while(sz-- > 0){
//p的next会被改变,所以提前保存
tmp = p->next;
while(t->next != NULL && p->data > t->next->data){
t = t->next;
}
//t为first,或者t为last,都是尾插
if(t->next == NULL){
t->next = p;
p->next = NULL;
p->before = t;
list->last = p;
}
else{
p->next = t->next;
t->next->before = p;
t->next = p;
p->before = t;
}
p = tmp;
t = list->first;
}
}
void resver(NodeList* list){
if(list->size == 1 || list->size == 0)return;
//第一个节点
Node* head = list->first->next;
//第二个节点
Node* second = head->next;
//head就是last,所以要head->next = NULL;
list->last = head;
list->last->next = NULL;
Node* tmp;
while(second != NULL){
//必须保存second的next,因为下面的代码,会改变second的next
tmp = second->next;
second->next = list->first->next;
list->first->next->before = second;
list->first->next = second;
second->before = list->first;
second = tmp;
}
}
void clear(NodeList* list){
Node* p = list->first->next;
while(p != NULL){
free(p);
p = p->next;
}
list->last = list->first;
list->last->next = NULL;
list->size = 0;
}
void destroy(NodeList* list){
Node* p = list->first;
while(p != NULL){
free(p);
p = p->next;
}
list->size = 0;
}
shuangnodemain.c
#include "shuangnode.h"
int main(){
NodeList list;
init(&list);
int select = 1;
ElemType item;
Node* node = NULL;
while(select){
printf("*****************************************\n");
printf("*** [1] push_back [2] push_front ***\n");
printf("*** [3] show_list [4] pop_back ***\n");
printf("*** [5] pop_front [6] insert_val ***\n");
printf("*** [7] find [8] length ***\n");
printf("*** [9] delete_val [10] sort ***\n");
printf("*** [11] sort [12] resver ***\n");
printf("*** [13] [14] clear ***\n");
printf("*** [0] quit [15*]destroy ***\n");
printf("*****************************************\n");
printf("请选择:>");
scanf("%d", &select);
if(0 == select)
break;
switch(select){
case 1:
printf("请输入要插入的数据,以-1结束>\n");
while(scanf("%d",&item) && item != -1){
push_back(&list, item);
}
show_list(&list);
break;
case 2:
printf("请输入要插入的数据,以-1结束>\n");
while(scanf("%d", &item) && item != -1){
push_front(&list, item);
}
show_list(&list);
break;
case 3:
show_list(&list);
break;
case 4:
pop_back(&list);
show_list(&list);
break;
case 5:
pop_front(&list);
show_list(&list);
break;
case 6:
printf("请输入要插入的数据>\n");
scanf("%d",&item);
insert_val(&list, item);
show_list(&list);
break;
case 7:
printf("please enter what you shoule find out>\n");
scanf("%d",&item);
node = find(&list, item);
if(node == NULL){
printf("can not find %d\n", item);
}
break;
case 8:
printf("length is %ld\n", list.size);
break;
case 9:
printf("please enter what you want to delete>\n");
scanf("%d",&item);
delete_val(&list, item);
show_list(&list);
break;
case 10:
// sort(&list);
//show_list(&list);
break;
case 11:
sort(&list);
show_list(&list);
break;
case 12:
resver(&list);
show_list(&list);
break;
case 13:
resver(&list);
show_list(&list);
break;
case 14:
clear(&list);
show_list(&list);
break;
case 15:
destroy(&list);
break;
default:
break;
}
}
destroy(&list);
}
c/c++ 线性表之双向链表的更多相关文章
- [数据结构 - 第3章] 线性表之双向链表(C语言实现)
一.什么是双向链表? 双向链表(double linked list)是在单链表的每个结点中,再设置一个指向其前驱结点的指针域.所以在双向链表中的结点都有两个指针域,一个指向直接后继,另一个指向直接前 ...
- 【Java】 大话数据结构(5) 线性表之双向链表
本文根据<大话数据结构>一书,实现了Java版的双向链表. 在每个数据结点中都有两个指针,分别指向直接后继和直接前驱,这样的链表称为双向链表. 双向链表的结构如图所示: 查找元素可以根据元 ...
- (续)线性表之双向链表(C语言实现)
在前文实现单向链表的基本操作下,本文实现双向链表的基本操作. 双向链表与单链表差异,是双向链表结点中有前向指针和后向指针.所以在插入和删除新结点元素时候不见要考虑后向指针还要考虑前向指针. 以下是双向 ...
- 【algo&ds】2.线性表
1.线性表 线性表(英语:Linear List)是由n(n≥0)个数据元素(结点)a[0],a[1],a[2]-,a[n-1]组成的有限序列. 其中: 数据元素的个数n定义为表的长度 = " ...
- 玩转C线性表和单向链表之Linux双向链表优化
前言: 这次介绍基本数据结构的线性表和链表,并用C语言进行编写:建议最开始学数据结构时,用C语言:像栈和队列都可以用这两种数据结构来实现. 一.线性表基本介绍 1 概念: 线性表也就是关系户中最简单的 ...
- 线性表->链式存储->双向链表
文字描述 之前的链表(单链表.循环链表)的链式存储结构中只有一个指示直接后继的指针域.由此,从某个结点出发只能顺指针往后寻查其他结点.若要寻查结点的直接前驱,则需从表头指针出发.即单链表中,NextE ...
- 线性表的Java实现--链式存储(双向链表)
有了单向链表的基础,双向链表的实现就容易多了. 双向链表的一般情况: 增加节点: 删除节点: 双向链表的Java实现: package com.liuhao.algorithm; publi ...
- 线性表源码分享(c++),包含顺序表、单链表、循环链表、双向链表
---恢复内容开始--- 我是一个c++和数据结构的初学者,本文主要是把清华大学出版社的数据结构(用面向对象方法与c++语言描述)(第2版)这本书中第二章线性表的源码抄下来,在学习的过程中有助于加深印 ...
- 数据结构(Java描述)之线性表
基础概念 数据结构:是相互之间存在一种或多种关系的数据元素的集合. 逻辑结构和物理结构 关于数据结构,我们可以从逻辑结构和物理结构这两个维度去描述 逻辑结构是数据对象中数据元素之间的关系,是从逻辑意义 ...
随机推荐
- 【Python】Python3纯代码极简教程
#!/usr/bin/python3 ''' Python3.6.x简单教程 示例.注释 交互式和脚本式编程 变量类型 数字(Number) 字符串(String) 列表(Li ...
- SpringBoot(5) SpringBoot个性化启动
1.在类路径下增加一个banner.txt,里面是启动要输出的信息 自定义banner在线生成工具: http://www.bootschool.net/ascii _ _ _ _ __ | | __ ...
- JAVA课程设计——一个简单的教务人事管理系统
大三上学期期末总结,没错,上学期,写在下学期新学期开始,哈哈哈. 上学期学习了面向对象程序设计,课程设计的题目使用JAVA语言完成一个简单的教务人事管理系统,能够实现访问数据库的登录验证,分别按部门和 ...
- You must reset your password using ALTER USER statement before executing this statement.
MySQL 5.7之后,刚初始化的MySQL实例要求先修改密码.否则会报错: mysql> create database test; ERROR 1820 (HY000): You must ...
- Hive默认数据库修改配置
此文是基于上一篇文章:Hive环境搭建及测试 因为Hive默认的数据库是derby,不支持同时开启两个./hive的命令终端: 而将Hive的默认数据库修改成mysql后,可以解决该问题. 仅在安装H ...
- js模块化编程之彻底弄懂CommonJS和AMD/CMD!
先回答我:为什么模块很重要? 答:因为有了模块,我们就可以更方便地使用别人的代码,想要什么功能,就加载什么模块.但是,这样做有一个前提,那就是大家必须以同样的方式编写模块,否则你有你的写法,我有我的写 ...
- springMVC_10拦截器
一,简介 拦截器概念和struts概念一致 实现拦截器 实现HandlerInterceptor接口 配置拦截器 <mvc:interceptors> <mvc:intercepto ...
- Mybatis foreach标签含义
背景 考虑以下场景: InfoTable(信息表): Name Gender Age Score 张三 男 21 90 李四 女 20 87 王五 男 22 92 赵六 女 19 94 孙七 女 23 ...
- java体系架构
java概念 java本身是一种面向对象的语言,最显著的特性有两方面,一是所谓的“书写一次,到处运行”(write once ,run anywhrer),能够非常容易的获得跨平台能力,另外就是垃圾收 ...
- vim 的:x和:wq
vim是Unix/Linux系统最常用的编辑器之一,在保存文件时,我通常选择":wq",因为最开始学习vim的时候,就只记住了几个常用的命令:也没有细究命令的含义. 但是,最近我在 ...