单循环链表的实现

最新推荐文章于 2022-12-19 16:16:33 发布
最新推荐文章于 2022-12-19 16:16:33 发布
阅读量62 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/qingjiaowoxiaoxioashou/p/5776937.html
版权

Main.cpp文件：

#include"SCList.h"
void main()
{
    List mylist;
    InitSCList(&mylist);

    ElemType Item;
    int select = 1;
    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] reserve                  [12] clear                    *\n");
        printf(" [13*] destory                 [0] quit_system          *\n");
        printf("*************************************************\n");
        printf("请选择：");
        scanf("%d", &select);
        if (select == 0)
            break;
        switch (select)
        {
        case 1:
            printf("请输入要插入的数据（-1结束）");
            while (scanf("%d", &Item), Item != -1)
            {
                push_back(&mylist, Item);
            }
            break;
        case 2:
            printf("请输入要插入的数据（-1结束）");
            while (scanf("%d", &Item), Item != -1)
            {
                push_front(&mylist, Item);
            }
            break;
        case 3:
            show_list(&mylist);
            break;
        case 4:
            pop_back(&mylist);
            break;
        case 5:
            pop_front(&mylist);
            break;
        case 6:
            printf("请输入要插入的数值");  //升序的顺序进行插入
            scanf("%d", &Item);
            insert_val(&mylist, Item);
            break;
        case 7:
            printf("请输入要查找的数据");
            scanf("%d", &Item);
            Node* p;
            p = find(&mylist, Item);
            if (p == NULL)
            {
                printf("查找的数据在链表中不存在\n");
            }
            break;
        case 8:
            printf("链表的长度为：%d\n", length(&mylist));
            break;
        case 9:
            printf("请输入要删除的数据：");
            scanf("%d", &Item);
            delete_val(&mylist, Item);
            break;
        case 10:
            sort(&mylist);
            break;
        case 11:
            reserve(&mylist);
            break;
        case 12:
            clear(&mylist);
            break;
            case 13:
            /*destory(&mylist);*/
            break;
        default:
            printf("输入的命令错误，请重新输入！");
            break;
        }
    }
    destory(&mylist);
}

SCList.h文件：

#ifndef _SCLIST_H_
#define _SCLIST_H_

#include<stdio.h>
#include<assert.h>
#include<malloc.h>

#define ElemType int
typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;

typedef struct List
{
    Node* first;
    Node* 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);
int length(List *list);
void delete_val(List *list, ElemType x);
void sort(List *list);
void reserve(List *list);
void clear(List *list);
void destory(List *list);
///
Node* buyNode(ElemType x);


#endif

 

SCList.cpp文件：

#include"SCList.h"

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 = 0;
}

void push_back(List *list, ElemType x)
{
    Node* p=buyNode(x);

    list->last->next = p;
    list->last = p;
    list->last->next = list->first;
    list->size++;
}

void push_front(List *list, ElemType x)
{
    Node* p = buyNode(x);

    p->next=list->first->next;
     list->first->next=p;
     if (list->first == list->last)
     {
         list->last = p;
     }
    list->size++;
}

void show_list(List *list)
{
    Node* p = list->first->next;
    while (p != list->first)
    {
        printf("%d--> ", p->data);
        p = p->next;
    }
    printf("NULL.\n");
}

void pop_back(List *list)
{
    if (list->size == 0)
        return;

    Node* p = list->first;
    while (p->next != list->last)
    {
        p = p->next;
    }
    free(list->last);
    list->last=p;
    list->last->next = list->first;
    list->size--;
}

void pop_front(List *list)
{
    if (list->size == 0)
        return;

    Node* p = list->first->next;
     list->first->next=p->next;
    free(p);
    if (list->size == 1)
    {
        list->last = list->first;
    }
    list->size--;
}

void insert_val(List *list, ElemType val)  //设链表是升序的
{
    Node* p = list->first;
    while (p->next != list->last&&p->next->data < val)
        p = p->next;

    if (p->next == list->last&&p->next->data < val)    //尾部插入
    {
        push_back(list,val);
    }
    else
    {
        Node* s = buyNode(val);
        s->next = p->next;
        p->next = s;
        list->size++;
    }
}

Node* find(List *list, ElemType x)
{
    if (list->size == 0)
        return NULL;

    Node* p = list->first->next;
    while (p != list->first&&p->data != x)
        p = p->next;

    if (p == list->first)
        return NULL;
    return p;
}

int length(List *list)
{
    return list->size;
}

void delete_val(List *list, ElemType x)
{
    if (list->size == 0)
        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 == 0 || list->size == 1)
        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)    //尾部插入
        {
            s->next = list->last->next;
            list->last->next = s;
            list->last = s;
        }
        else
        {
            s->next = p->next;
            p->next = s;
        }
    }
}

void reserve(List *list)
{
    if (list->size == 0 || list->size == 1)
        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;

        s->next = list->first->next;
        list->first->next = s;
    }
}

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 = 0;
}

void destory(List *list)
{
    clear(list);
    free(list->first);
    list->last = list->first = NULL;
}

Node* buyNode(ElemType x)
{
    Node* p = (Node *)malloc(sizeof(Node));
    assert(p != NULL);
    p->data = x;
    p->next = NULL;
    return p;
}

转载于:https://www.cnblogs.com/qingjiaowoxiaoxioashou/p/5776937.html

weixin_30653097
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构】单向循环链表实现
Chen_yuazzy的博客
07-28 393
#include<stdio.h> #include<time.h> #include<stdlib.h> typedef struct Linklist{ int data; struct Linklist *next; }LL; LL *create1_list(int n);//尾插法创建单向循环链表 void print_list(LL *p);...
算法与数据结构-循环单链表
12-02
C/C++算法与数据结构：循环单链表的实现代码！能运行！适用于初学者
数据结构复习：单向循环链表的实现
rj2017211811的博客
07-28 158
单向循环链表
C语言单循环链表的表示与实现实例详解
09-04
主要介绍了C语言单循环链表的表示与实现,对于学习数据结构与算法的朋友来说很有参考借鉴价值,需要的朋友可以参考下
Josephus问题C++单循环链表实现
09-22
这个完全符合课本上习题的要求，我作业交的就是这个，我自己还在里面做了详细的注释
单循环链表
01-02
单循环链表
用C++实现的循环链表
04-15
这是一个单循环链表，具备基本的操作，在普通链表的基础上，实现了定长循环链表的循环输入，判断链表是否有环等较为特殊的操作。增删改查自然也有。
数据结构之自建算法库——循环单链表
weixin_33860737的博客
09-12 165
本文针对数据结构基础系列网络课程(2)：线性表中第13课时循环链表。 按照“0207将算法变程序”[视频]部分建议的方法，建设自己的专业基础设施算法库。 双链表算法库算法库采用程序的多文件组织形式，包括两个文件： 　　 　　1.头文件：clinklist.h，包含定义双链表数据结构的代码、宏定义、要实现算法的函数的声明； ...
数据结构例14.试编写算法创建一个带头结点的单向循环链表la={a1,a2,…an}， 并从指定的结点序号起输出循环链表。
m0_51374762的博客
01-16 784
/* 试编写算法创建一个带头结点的单向循环链表la={a1,a2,…an}， 并从指定的结点序号起输出循环链表。 */ # include <iostream> # include <stdlib.h> # include <stdio.h> using namespace std; typedef struct Node { int elem; struct Node* next; }*linklist; void inlinklist(linklist &am
循环单链表的建立算法
yychenxie21的专栏
10-12 1267
1，循环单链表的建立：其和线性链表的操作基本一致，区别在于循环条件不是p->next是否存在，而是p->next是否等于头结点。       代码如下：    #include "stdafx.h" #include #include #define SIZE 100 #define INCREMENT_SIZE 10 typedef struct LNode { int dat
一步一步写算法（之循环单向链表）
hgcghhgg的博客
11-09 256
一步一步写算法（之循环单向链表）
创建循环单链表（头插法）
tkp2014的专栏
07-03 3633
#include #include typedef int ItemValue; typedef struct LinkNode { ItemValue value; struct LinkNode *next; } Node, *pNode; /* 尾插法*/ Node* CreateCylicSingleLinkedList() { Node *head = (Node *)m
单向循环链表的创建/插入/删除/输出算法
LemonLee‘s Blog
07-16 7011
单向循环链表
数据结构与算法（单循环链表）
云都小生
06-04 748
单循环链表实际上只是在单链表的基础上，多加了个尾指针的概念，将尾结点的指针指向头结点，构成一个单循环，难度并不难。许多功能跟单循环都是一样的，不解释，上代码。 #include #include #include int Sdata; //链表数据数量 #define LEN sizeof(struct listdata) typedef struct listdata { i
单循环链表（不带表头）的C语言实现（详细）
qq_983030560的博客
12-19 1620
单循环链表（不带表头）的C语言实现，非常详细
数据结构 链表 循环单链表的建立 C语言版
你若盛开 清风自来
08-27 1028
#include #include typedef struct Node { int data; struct Node * next; } Node,* Linklist; //定义链表的结点，链表头 void Initlist (Linklist *CL) //初始化链表 { *CL=(Linklist)malloc(sizeof(Node)); (
用c语言写一个单循环链表实现以下要求：一、实现单循环链表的初始化、求数据元素个数、插入、删除、取数据元素等操作；建立带头结点的单循环链表；设计一个测试主函数验证所设计单循环链表的正确性。二、具体分析代码中的函数模块划分和代码中的算法思想
最新发布
10-27
以下是一个简单的C语言单循环链表实现的代码，其中包括上述基本操作的实现： ``` #include #include // 定义链表节点结构体 typedef struct Node { int data; struct Node *next; } Node; // 初始化链表 void...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值