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. JQuery 学习笔记-2017.05.22

    JQuery jQuery 是一个 JavaScript 函数库. jQuery 库包含以下特性: HTML 元素选取 HTML 元素操作 CSS 操作 HTML 事件函数 JavaScript 特效 ...

  2. Mysql表类型(存储引擎)的比较

    面试官问:你知道mysql有哪些存储引擎,区别是啥? 我:一脸闷逼,于是乎下来补一补,以作备查 1.和大多数数据库不同,MySQL 中有一个存储引擎的概念,针对不同的存储需求可以选择最优的存储引擎. ...

  3. JS播放声音

    <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>JS播放声音</tit ...

  4. Qt5中运行后台网络读取线程与主UI线程互交

    项目中有一个需求就是,因为需要请求服务端数据,因为网络的读取会阻塞,所以该过程不能放在Qt中的UI主线程当中,需要用一个后台线程来读取数据,数据准备完毕后 在通过Qt5中的信号槽机制来跨线程的传递数据 ...

  5. nginx rewrite flag

    1.break可以理解为switch中的break,而last可以理解为continue,一个是跳出server{}的匹配规则,一个还将继续匹配之后的规则. 无论使用last还是break,浏览器上面 ...

  6. linux中原子操作实现方式

    原子操作提供了指令原子执行,中间没有中断.就像原子被认为是不可分割颗粒一样,原子操作(atomic operation)是不可分割的操作. 如下面简单的例子: Thread 1             ...

  7. Android漏洞——将Android恶意代码隐藏在图片中

    研究人员发现了Android上又一个严重的安全漏洞:将Android恶意代码隐藏在图片中(Hide Android Applications in Images). 在该漏洞向外界公开之前,Googl ...

  8. 20155333 《网络对抗》 Exp6 信息搜集与漏洞扫描

    20155333 <网络对抗> Exp6 信息搜集与漏洞扫描 基础问题 哪些组织负责DNS,IP的管理? 全球根服务器均由美国政府授权的ICANN统一管理,负责全球的域名根服务器.DNS和 ...

  9. SpingMVC的<context:component-scan>包扫描踩坑记录

        公司项目配置的Spring项目的包扫描有点问题,出现了一个被Spring容器管理的Bean被创建了2次的现象.在此记录下解决的过程,方便后续查阅. 改动前: 容器启动监听器中会扫描全部包,创建 ...

  10. 一波三折Miz702终于能显示桌面上网啦

    先上两张图,总结之后再说啦---