SClist.h

 #ifndef __SCLIST_H__
#define __SCLIST_H__ #include<cstdio>
#include<malloc.h>
#include<assert.h>
typedef int ElemType;
typedef struct Node {
ElemType data;
struct Node *next;
}Node,*PNode; typedef struct List {
PNode first;
PNode last;
size_t size;
}List; void InitSClist(List *list);//初始化循环单链表
void push_back(List *list, ElemType x);//在循环单链表的末尾插入元素
void push_front(List *list, ElemType x);//在循环单链表的头部插入元素
void show_list(List *list);//打印循环单链表
void pop_back(List *list);//删除循环单链表的最后一个元素
void pop_front(List *list);//删除循环单链表的第一个元素
void insert_val(List *list, ElemType val);//将数据元素插入到循环单链表中(要求此时循环单链表中的数据元素顺序排列)
Node* find(List *list, ElemType x);//查找循环单链表中数据值为x的结点
int length(List *list);//求循环单链表的长度
void delete_val(List *list, ElemType x);//按值删除循环单链表中的某个数据元素
void sort(List *list);//对循环单链表进行排序
void reverse(List *list);//逆置循环单链表
void clear(List *list);//清除循环单链表
void destroy(List *list);//摧毁循环单链表 //优化
Node* _buynode(ElemType x);//创建结点 #endif

SClist.cpp

 #include"SClist.h"

 Node* _buynode(ElemType x) {
Node *s = (Node*)malloc(sizeof(Node));
assert(s != NULL);
s->data = x;
s->next = NULL;
return s;
} void InitSClist(List *list) {
Node *s = (Node*)malloc(sizeof(Node));
assert(s != NULL);
list->first = list->last = s;
list->last->next = list->first;//让链表最后一个结点的指针域指向头结点,从而时链表循环
list->size = ;
} void push_back(List *list, ElemType x) {
Node *s = _buynode(x);
list->last->next = s;
list->last = s;
23 list->last->next = list->first;
list->size++;
} void push_front(List *list, ElemType x) {
Node *s = _buynode(x);
s->next = list->first->next;
list->first->next = s;
31 if (list->last == list->first)
32 list->last = s;
list->size++;
} void show_list(List *list) {
Node *p = list->first->next;
while (p != list->first) {
printf("%d->", p->data);
p = p->next;
}
printf("Nul.\n");
} void pop_back(List *list) {
if (list->size == ) return;
Node *p = list->first;
while (p->next != list->last)
p = p->next;
free(list->last);
list->last = p;
52 list->last->next = list->first;
list->size--;
} void pop_front(List *list) {
if (list->size == ) return;
Node *p = list->first->next;
list->first->next = p->next;
60 if (list->size == 1)
61 list->last = list->first;
free(p);
list->size--;
} void insert_val(List *list, ElemType x) {
Node *p = list->first;
while (p->next != list->last && p->next->data < x)
p = p->next;
if (p->next == list->last && p->next->data < x)
push_back(list, x);
else {
Node *s = _buynode(x);
s->next = p->next;
p->next = s;
list->size++;
}
} Node* find(List *list, ElemType key) {
if (list->size == ) return NULL;
Node *p = list->first->next;
while(p != list->first && p->data != key)
p = p->next;
85 if (p == list->first)
86 return NULL;
return p;
} int length(List *list) {
return list->size;
} void delete_val(List *list, ElemType x) {
if (list->size == ) return;
Node *p = find(list, x);
if (p == NULL) {
printf("没有要删除的数据!\n");
return;
}
if (p == list->last)
pop_back(list);
else {
Node *q = p->next;
p->data = q->data;
p->next = q->next;
free(q);
list->size--;
}
} void sort(List *list) {
if (list->size == || list->size == ) return;
Node *s = list->first->next;
Node *q = s->next;
list->last->next = NULL;
list->last = s;
list->last->next = list->first;
while (q != NULL) {
s = q;
q = q->next;
Node *p = list->first;
while (p->next != list->last && p->next->data < s->data)
p = p->next;
if (p->next == list->last &&p->next->data < s->data) {
list->last->next = s;
list->last = s;
list->last->next = list->first;
}
else {
s->next = p->next;
p->next = s;
}
}
} void reverse(List *list) {
if (list->size == || list->size == ) return;
Node *p = list->first->next;
Node *q = p->next;
list->last->next = NULL;
list->last = p;
list->last->next = list->first;
while (q != NULL) {
p = q;
q = q->next;
p->next = list->first->next;
list->first->next = p;
}
} void clear(List *list) {
Node *p = list->first->next;
while (p != list->first) {
list->first->next = p->next;
free(p);
p = list->first->next;
}
list->last = list->first;
list->last->next = list->first;
list->size = ;
} void destroy(List *list) {
clear(list);
free(list->first);
list->first = list->last = NULL;
}

main.cpp

 #include"SClist.h"

 void main() {
List mylist;
InitSClist(&mylist); ElemType item;
Node *p = NULL;
int select = ;
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] reverse [12] clear *\n");
printf("*[13*] destroy [0] quit_system *\n");
printf("*******************************************\n");
printf("请选择:>>");
scanf("%d", &select);
if (select == ) break;
switch (select) {
case :
printf("请输入要插入的数据(-1结束):>");
while (scanf("%d", &item), item != -) {
push_back(&mylist, item);
}
break;
case :
printf("请输入要插入的数据(-1结束):>");
while (scanf("%d", &item), item != -) {
push_front(&mylist, item);
}
break;
case :
show_list(&mylist);
break;
case :
pop_back(&mylist);
break;
case :
pop_front(&mylist);
break;
case :
printf("请输入要插入的数据:>");
scanf("%d", &item);
insert_val(&mylist, item);
break;
case :
printf("请输入要查找的数据:>");
scanf("%d", &item);
p = find(&mylist, item);
if (p == NULL)
printf("要查找的数据在单链表中不存在!\n");
break;
case :
printf("单链表的长度为%d\n", length(&mylist));
break;
case :
printf("请输入要删除的值:>");
scanf("%d", &item);
delete_val(&mylist, item);
break;
case :
sort(&mylist);
break;
case :
reverse(&mylist);
break;
case :
clear(&mylist);
break;
//case 13:
//destroy(&mylist);
//break;
default:
printf("选择错误,请重新选择!\n");
break;
}
}
destroy(&mylist);
}

C语言版本:循环单链表的实现的更多相关文章

  1. C语言版本:单链表的实现(优化版本)

    未优化版本:http://www.cnblogs.com/duwenxing/p/7569376.html slist.h #ifndef __SLIST_H__ #define __SLIST_H_ ...

  2. C语言版本:单链表的实现

    slist.h #ifndef __SLIST_H__ #define __SLIST_H__ #include<cstdio> #include<malloc.h> #inc ...

  3. c语言实现循环单链表

    //初始化 Node*InitList() { Node*head=(Node*)malloc(sizeof(Node)); head->next=NULL; head->data=-1; ...

  4. c语言循环单链表

    /************************************************************************* > File Name: singleLin ...

  5. c语言有头循环单链表

    /************************************************************************* > File Name: singleLin ...

  6. 带头结点的循环单链表----------C语言

    /***************************************************** Author:Simon_Kly Version:0.1 Date: 20170520 D ...

  7. 循环单链表定义初始化及创建(C语言)

    #include <stdio.h> #include <stdlib.h> /** * 含头节点循环单链表定义,初始化 及创建 */ #define OK 1; #defin ...

  8. C代码实现非循环单链表

    C代码实现非循环单链表, 直接上代码. # include <stdio.h> # include <stdlib.h> # include <malloc.h> ...

  9. 简单约瑟夫环的循环单链表实现(C++)

    刚刚接触C++以及数据结构,今天做了第一次尝试用C++和数据结构解决问题,问题是基于约瑟夫环问题的简单版. 先来看看约瑟夫环问题的介绍: 约瑟夫环是一个数学的应用问题:已知n个人(以编号1,2,3.. ...

随机推荐

  1. 【2017下集美大学软工1412班_助教博客】个人作业2——APP案例分析

    作业要求 个人作业2:APP案例分析 评分结果 按从高到低排列 学号后三位 第二次作业 Total 008 APP案例分析 23 044 第2次作业 19.5 011 App案例分析--XBMC 19 ...

  2. 2.Dubbo2.5.3注册中心和监控中心部署

    转载请出自出处:http://www.cnblogs.com/hd3013779515/ 1.注册中心Zookeeper安装 (1)搭建要求 zk服务器集群规模不小于3个节点要求各服务器之间系统时间要 ...

  3. http的长连接和短连接(数据库也一样)

    长连接与短连接 所谓长连接,指在一个TCP连接上可以连续发送多个数据包,在TCP连接保持期间,如果没有数据包发送,需要双方发检测包以维持此连接,一般需要自己做在线维持. 短连接是指通信双方有数据交互时 ...

  4. ACM模拟赛

    今天是毕业的学长给高二的同学测试.组队比赛,ACM赛制,于是就愉快的和学姐一队啦. 看到英文题面感到恐慌,不过好在不难读懂. A:并没有什么技术含量的模拟题: B:字符串题,给定一些比赛和每个队胜利的 ...

  5. Docker技术入门与实战 第二版-学习笔记-3-Dockerfile 指令详解

    前面已经讲解了FROM.RUN指令,还提及了COPY.ADD,接下来学习其他的指令 5.Dockerfile 指令详解 1> COPY 复制文件 格式: COPY  <源路径> .. ...

  6. Nginx端口占用问题

    错误信息:nginx: [emerg] listen() to 0.0.0.0:80, backlog 511 failed (98: Address already in use) 主要是端口被占用 ...

  7. Ant在MyEclipse中的配置总结

    1.在配置Ant之前,先要配置好JDK的JAVA_HOME和path:之后下载解压apache-ant-1.7.1;并配置环境变量ANT_HOME(安装目录,后不可以加分号:)及其path(安装目录/ ...

  8. PNS settings

    Before PNS,some settings should be ready: firstly,make sure that the power/ground nets exist,if not, ...

  9. JAVA框架Struts2 Action类

    一.Action书写方式: 接口地址:https://struts.apache.org/maven/struts2-core/apidocs/index.html Action类就是一个POJO类. ...

  10. day08(补)

    今日学习内容 1.文件重写方法 2.函数基本知识 文件处理: 打开文件 读/写文件 关闭文件 文件指针移动,只有t模式下的read(n),n代表的字符个数其余都是以字节为单位 f.seek有两个参数( ...