c语言一维数组单循环,数据结构与算法-C语言8-单循环列表

最新推荐文章于 2023-02-10 11:34:25 发布
最新推荐文章于 2023-02-10 11:34:25 发布
阅读量367 收藏
点赞数
文章标签： c语言一维数组单循环

数据结构与算法-目录

循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

e36b605024e6

对于单个链表，由于每个结点只存储了向后的指针，到了尾标志就停止了向后链的操作，这样当中某一结点就无法找到它的前驱结点了。

将单链表中终端结点的指针由空指针改为指向头结点，就使整个单链表形成一个环， 这种头尾相接的单链表称为单循环链表，简称循环链表。

循环链表解决了一个很麻烦的问题，如何从当中一个结点出发，访问到链表的全部结点。

循环链表和单链表的主要差异就是在于循环的判断条件上，原来是判断p->next是否为空，现在则是p->next不等于头结点，则循环未结束。

示例程序

CList.h

//CList.h

//结构体定义以及函数声明

#ifndef CLIST_H

#define CLIST_H

#include

#include

#include

#include

typedef int ElemType;

typedef struct Node

{

ElemType data;

struct Node *next;

}Node, *PNode;

typedef struct List

{

PNode head;

PNode tail;

int size;

}List,*PList;

bool InitList(PList list);

void Create_t(PList list,ElemType x); //尾插

void Create_h(PList list,ElemType x); //头插

void del_back(PList list); //尾删

void del_front(PList list); //头删

void sortList(PList list); //排序

void insert_val(PList list,ElemType x); //按值插

PNode find(PList list,ElemType x);

void del_val(PList list,ElemType x);

void modify(PList list,ElemType x1,ElemType x2);

void clear(PList list);

void destroy(PList list);

void reserve(PList list);

int length(PList list);

void menu();

void showList(PList list);

void show_tail(PList list);

ElemType next(PList list,ElemType x);

ElemType prio(PList list,ElemType x);

PNode prev(PList list,PNode p);

#endif

CList.cpp

//CList.cpp

//函数实现

#include"CList.h"

void menu() //提供选项的菜单函数

{

printf("***************************************************************\n");

printf("* [0] quit_system [1] Create_t [2] Create_h [3] showList *\n");

printf("* [4] del_back [5] del_front [6] insert_val [7] show_tail*\n");

printf("* [8] find [9] del_val [10] sortList [11] modify *\n");

printf("* [12]clear [13]destroy [14] resver [15]length *\n");

printf("* [16] next [17]prio *\n");

printf("***************************************************************\n");

}

bool InitList(PList list)

{

list->head = (PNode)malloc(sizeof(Node)); //初始化一个头结点

assert(list->head != NULL); //断言，表达式为真，接着往下执行

list->head->next = list->head; //初始化head和tail指针，使其都指向头节点

list->tail = list->head;

list->size = 0; //长度初始化为0

return true;

}

void Create_t(PList list,ElemType x) //尾插法

{

PNode s = (PNode)malloc(sizeof(Node));

assert(s != NULL);

s->data = x; //填充数据域

list->tail->next = s; //tail指向最后一个节点，把新建立的节点链接到链表的最后

s->next = list->head; //单循环链表，新节点的next指向头结点

list->tail = s; //改变尾指针的指向

list->size++;

}

void showList(PList list) //链表显示函数

{

if(1>list->size)

{

printf("--链表为空\n");

return ;

}

PNode p = list->head->next;

while(list->head != p) //逐个遍历链表

{

printf("%d ",p->data);

p=p->next;

}

printf("\n");

}

void Create_h(PList list,ElemType x) //头插法

{

PNode s = (PNode)malloc(sizeof(Node));

assert(s != NULL);

s->data = x; //填充数据域

s->next = list->head->next; //新节点指向第一个节点

list->head->next = s; //头节点的next指向新节点s

if(list->size == 0) //如果是第一次头插，需改变尾指针和尾节点的next指向，之后都不改变

{

list->tail = s;

list->tail->next = list->head;

}

list->size++; //插入一个，长度加1

}

void del_back(PList list) //尾删

{

if(0==list->size)

return;

PNode p = list->head;

while(list->head != p->next->next) //找到倒数第二个节点

{

p = p->next;

}

p->next = list->head; //把最后一个节点分离

free(list->tail); //释放最后一个节点

list->tail = p; //尾指针指向原来的倒数第二个节点(现在倒数第一)

printf("--尾节点已删除\n");

list->size--;

}

void del_front(PList list) //头删

{

if(0==list->size)

return;

else

{

PNode p = list->head->next;

if(1==list->size)

{ //只有一个节点，若删去，需改变尾指针

list->tail = list->head;

list->head->next = list->head;

}

else

{

list->head->next = p->next; //头指针指向第二个节点

}

free(p); //释放第一个节点

}

printf("--头节点已删除\n");

list->size--;

}

void show_tail(PList list) //为测试尾指针是否正确改变，需显示最后一个节点

{

printf("--链表的尾节点是：》%d \n",list->tail->data);

}

void sortList(PList list) // 对无序链表进行从小到大排序

{

if(2>list->size)

return ;

PNode p = list->head->next;

PNode q = p->next;

for(int i = 0;isize-1;i++,p = list->head->next,q = p->next) //n个数比较n-1趟

{

for(int j = 0;jsize-1-i;j++,p=q,q=q->next) //第i趟比较n-i次

{

if(p->data > q->data) //如果前面的数大于后面，则交换

{

p->data = p->data + q->data;

q->data = p->data - q->data;

p->data = p->data - q->data;

}

}

}

}

void insert_val(PList list,ElemType x) //链表有序的前提下，给一个值插入

{

PNode p = list->head->next,q = list->head;

while(list->head != p) //找到能插入的位置，会在p、q之间

{

if(xdata)

break;

q = p;

p = p->next;

}

PNode s = (PNode)malloc(sizeof(Node)); //初始化新节点

s->data = x;

q->next = s; //把新节点插入到链表中(在p,q之间插入)

s->next = p;

if(list->head == p) //如果新节点的值最大，即尾插，需改变尾指针和尾节点的next指向

{

list->tail = s;

list->tail->next=list->head;

}

list->size++;

}

PNode find(PList list,ElemType x) //返回要查找元素的前面一个的地址

{

PNode p = list->head;

while(list->tail != p && list->head != p->next && x != p->next->data)

{

p = p->next; //循环结束，p指向x的前面一个元素

}

if(list->head == p->next) //如果p指向最后一个元素，说明没有找到

{

printf("--没找到！\n");

return NULL;

}

return p;

}

void del_val(PList list,ElemType x) //删除指定的值x

{

if(0 == list->size)

return ;

PNode p = find(list,x);

PNode q = NULL;

if(NULL != p)

{

q = p->next; //q指向要删除的节点

if(q == list->tail) //若删除最后一个节点，需改变尾指针

{

p->next = list->head;

list->tail = p;

}

else

{

p->next = q->next;

}

free(q); //释放要删除的节点

list->size--;

printf("--%d已删除!\n",x);

}

return ;

}

void modify(PList list,ElemType x1,ElemType x2) //把原有的x1修改成x2

{

PNode p = find(list,x1);

if(NULL != p)

p->next->data = x2;

else

return ;

}

void clear(PList list) //删除链表的所有节点，但不删除头结点

{

PNode p = list->head->next;

PNode q = p;

while(list->head != p)

{

p = p->next; //p依次后移，跟屁虫q依次释放节点

free(q);

q = p;

}

list->tail = list->head; //修改尾指针和链表长度

list->head->next = list->head;

list->size = 0;

printf("--链表已被清空！\n");

}

void destroy(PList list) //摧毁链表，包括所有节点和头结点

{

clear(list);

free(list->head);

list->head = NULL;

list->tail = NULL;

printf("--链表已被摧毁！\n");

}

PNode prev(PList list,PNode p) //返回p指向的前面一个节点

{

if(p != list->head)

{

PNode q = list->head->next;

while(q != list->head && q->next != p) //依次往后移，知道尾指针的前面一个节点

q=q->next;

if(q->next == p)

return q;

}

return NULL;

}

void reserve(PList list) //逆置链表

{

PNode s = (PNode)malloc(sizeof(Node)); //建立一个节点

s->next = list->tail;

PNode p = list->tail;

while(list->tail != list->head->next) //把原链表的尾节点到第一个节点依次连接到新节点上

{

list->tail = prev(list,list->tail);

list->tail->next = list->head;

p->next = list->tail;

p=p->next;

}

p->next = s; //p指向第一个节点，即新链表的最后一个节点，尾指针的next指向头结点s，链表结束

free(list->head); //释放原来的头结点

list->head = s; //把s变成新的头指针

}

int length(PList list) //求链表的长度

{

return list->size;

}

ElemType next(PList list,ElemType x) //返回x的后继

{

PNode p = find(list,x);

if(NULL == p)

return -1;

if(p->next == list->tail) //因为是单循环链表，尾节点的下一个元素是第一个节点

{

return list->head->next->data;

}

p=p->next;

return p->next->data;

}

ElemType prio(PList list,ElemType x) //返回x的前驱

{

PNode p = find(list,x);

if(NULL != p)

{

if(p == list->head || p == list->tail)

{

return list->tail->data;

}

return p->data;

}

return -1;

}

main.cpp

//main.cpp

//测试函数

#include "CList.h"

int main()

{

List mylist;

InitList(&mylist);

ElemType item = 0;

int pos = 0;

int chose = 1;

PNode p = NULL;

while(chose)

{

menu();

printf("给出想要操作的序号：\n");

scanf("%d",&chose);

switch(chose)

{

case 0:

destroy(&mylist);

chose = 0;

break;

case 1:

printf("输入要尾插的数据[-1结束]：\n");

while(scanf("%d",&item),item!=-1)

{

Create_t(&mylist,item);

}

break;

case 2:

printf("输入要头插的数据：\n");

while(scanf("%d",&item),item!=-1)

{

Create_h(&mylist,item);

}

break;

case 3:

showList(&mylist);

break;

case 4:

del_back(&mylist);

break;

case 5:

del_front(&mylist);

break;

case 6:

printf("给出要插入的数：\n");

scanf("%d",&item);

insert_val(&mylist,item);

break;

case 7:

show_tail(&mylist);

break;

case 8:

printf("输入要查找的数：\n");

scanf("%d",&item);

p = find(&mylist,item);

if(NULL!=p)

printf("%d\n",p->next->data);

break;

case 9:

printf("输入要删除的数：\n");

scanf("%d",&item);

del_val(&mylist,item);

break;

case 10:

sortList(&mylist);

break;

case 11:

printf("输入要修改的数和修改后的数\n");

scanf("%d %d",&item,&pos);

modify(&mylist,item,pos);

break;

case 12:

clear(&mylist);

break;

case 13:

destroy(&mylist);

break;

case 14:

reserve(&mylist);

break;

case 15:

printf("链表长度为：%d\n",length(&mylist));

break;

case 16:

printf("输入想要找哪个一数的后继：\n");

scanf("%d",&item);

printf("%d 的后继是：%d\n",item,next(&mylist,item));

break;

case 17:

printf("输入想要找哪个一数的前驱：\n");

scanf("%d",&item);

printf("%d 的前驱是：%d\n",item,prio(&mylist,item));

break;

default:

printf("重新输入\n");

break;

}

}

return 0;

}

运行测试：

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

1

输入要尾插的数据[-1结束]：

5 6 9 2 8 2 6 -1

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

3

5 6 9 2 8 2 6

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

8

输入要查找的数：

2

2

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

7

--链表的尾节点是：》6

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

10

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

3

2 2 5 6 6 8 9

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

14

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

3

9 8 6 6 5 2 2

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

16

输入想要找哪个一数的后继：

8

8 的后继是：6

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

12

--链表已被清空！

***************************************************************

* [0] quit_system [1] Create_t [2] Create_h [3] showList *

* [4] del_back [5] del_front [6] insert_val [7] show_tail*

* [8] find [9] del_val [10] sortList [11] modify *

* [12]clear [13]destroy [14] resver [15]length *

* [16] next [17]prio *

***************************************************************

给出想要操作的序号：

3

--链表为空

得是
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言数据结构-顺序表版学生管理系统
09-26
1. **数组**：在C语言中，数组是最基本的数据结构之一，用于存储同一类型的一组数据。在这个系统中，学生信息可能会被存储在一个二维数组中，每一行代表一个学生，列则对应学生的属性如学号、姓名、年龄等。 2. **...
c代码-一维数组成绩输入输出
07-16
在C语言中，一维数组是一种非常基础且重要的数据结构，用于存储同类型的数据集合。在本项目"一维数组成绩输入输出"中，我们将会探讨如何使用C语言来处理一维数组，尤其是针对学生成绩的输入和输出。下面我们将详细地...
设计循环队列
weixin_53946312的博客
04-21 241
设计循环队列 题目描述： 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 你的实现应该支持如下操作： MyCircularQueue(k): 构造器，设置队列长度为 k 。 Front: 从队首获取元素。如
C语言中的循环
qq_45793517的博客
11-09 424
C语言中的循环 程序处理过程当中常常遇到需要重复处理的问题，就需要用到循环结构（又称重复结构）。 1.while循环 while循环的通用形式： while（表达式） 语句 语句可以是以分号结尾的简单句，也可以是用花括号括起来的复合语句（用花括号括起来的若干语句）。...
[leetcode]C语言用数组或链表实现循环队列
weixin_51062241的博客
11-29 1134
使用C语言数组、链表实现循环队列，leetcode设计循环队列
数据结构与算法-循环单链表操作及应用C语言实现（超详细注释/设计/实验/作业）
程序员老茶的博客
02-10 614
通过此次实验，进一步熟悉了循环链表操作的有关知识，对书本上的知识又有了更进一步的认识。另一方面，通过编写程序也让对C语言课程中学习到的有关知识进行了一次复习。由于在大一时对C语言的学习并不太好，尤其对结构体指针的理解并深，所以在编写程序的初期遇到了一些困难。为了解决问题，我又对C语言的相关章节进行了复习，在复习的过程中加深了对结构体、指针、字符数组、字符串函数、for循环、while循环、函数的理解。
【C语言】C语言分支与循环 (还在被分支和循环绕呢~通过本篇文章带你轻松打败分支与循环)
Welcome home | Jian Liao 's blog
11-09 300
分支和循环在C语言中几乎无处不在，作为重要的一部分，精确掌握其语法和运用逻辑，是继续向下学习的“地基”。分支与循环的语法虽然简单，但它在实际运用中确实烧脑的存在，今后几乎所有你会遇到的问题，他都需要分支与循环来逻辑实现。因此，分支与循环我们不仅要学会，还要练透，并且能十分清楚他的逻辑。
C语言编程技术实践 一维数组教学单元设计.doc
07-08
总之，一维数组是C语言编程的基础，通过深入学习和实践，学生不仅能掌握数组的基本操作，还能进一步理解结构化编程思想，为后续学习更复杂的编程概念和数据结构打下坚实基础。在教学过程中，教师应注重引导启发，...
C语言基础知识大全讲解学习数据结构.docx
最新发布
11-21
数组是C语言中另一种重要的数据结构，分为一维数组和二维数组。一维数组的定义和初始化有特定规则，而二维数组的存储方式类似于多行一维数组。字符数组，也就是字符串，以'\0'作为结束标志，C语言提供了puts()、gets...
最大前缀C语言（单循环）
bestme
12-28 573
题目： char* longestCommonPrefix(char** strs, int strsSize) { int i = 0, k = 0; //k是专门给ans[]使用的下标，从0开始 int cnt = 0; //计数器 int len = strlen(strs[0]); //计算strs中第一个字符串的元素个数 char* ans = (char*)malloc((len + 1) * sizeof...
c语言单循环
09-22
C语言单循环链接。有助于同学们解决相关课程问题，积极应对学习
C语言实现单循环链表
goldenzhouzhuo的博客
03-06 1515
第一次在CSDN这边写博客，主要是为了记录自己学习的历程，望诸位共勉。 首先循环链表是神魔恋？其实就是为了解决单链表只能从头开始过于麻烦诞生的，我愿称之为单链表2.0。（所以如果搞不清楚的话建议先学一下单链表。） 那么它和单链表之间是什么关系，单链表的结尾指向的是一个空节点，存着NULL这个空值。那么他在索引的时候出现的问题显而易见，如果你不从头结点开始那你就无法访问全部结点。 循环链表的设计者明...
单循环完成快速排序（C语言）
bairimeng16的博客
12-13 1781
注：这个代码是一位强者教我的，我以一个初学者的思维加了点注来帮助更多像我一样刚刚入门想学习算法又不会C++的编程者们理一理思路（我是屑大学生，加的注可能会有逻辑不严谨的地方），希望对你们有些帮助 下面以一个内含0~9十个数字的简单数组来展示单循环完成的快速排序 #include<stdio.h> void quicksort(int a[], int left, int right) //这个加不加void都行，加了更严谨 { int p; if (left < right)
数据结构和算法-7-单向循环列表
Anthony_tester的博客
06-14 1340
前面一篇介绍了单链表，这个单链表是基础，这篇我们来看看单链表的变种，单向循环链表，和前面唯一的区别就是列表最后一个节点指向头节点，形成一个环形。 1.单向循环列表 单链表的一个变型是单向循环链表，链表中最后一个节点的next域不再为Node，而是指向链表的头节点，形成一个环。 2.代码实现 还是前面单链表的大部分方法的实现代码，先来看看头部插入元素和尾部插入元素，链表长度，判断为...
C语言(循环结构详解、一维数组、字符串处理函数)笔记-day2
weixin_47409584的博客
04-10 1289
Linux C基础-day02
单循环链表（简称循环链表）
一个搬运知识的笨小孩
07-25 5054
循环链表（从任一结点出发，访问到链表全部结点） 访问终端结点的时间复杂度 O(n)O(n)O(n) 的循环链表形式 访问尾结点的时间复杂度 O(1)O(1)O(1) 的循环链表形式 这种形式访问开始结点和终端结点都很方便均为 O(1)O(1)O(1) 举例： 将两个循环链表合并为一个表 表A 表B 表A和表B合并 p = rearA->next; //将指向表A头结点的指针重命名 rearA->next = rearB->next->next; //将指向表B开始结点的指针
数据结构与算法——单向循环列表、栈和队列（附代码）
m0_49963403的博客
11-13 930
数据结构——单向循环列表，栈和队列的介绍，以及python实现
C语言单循环获得数组最大数和次最大数
hoderix的博客
06-09 834
C语言单循环获得数组最大数和次最大数 看了一下论坛已有代码，基本都是比较复杂的，要么就是双循环，要么用极限数据测试出错，比如全部负数，或者全部等值，（{-10,-10,-10,-10,-10} 的次最大数是0 ？？） 直接上代码，估计是全论坛最简单的单循环代码了，反正翻了好多个都比我这个差。 #include <stdio.h> int main() { //一个循环获得数组最大数和次最大数 //不写输入部分了，有需要的自己scanf int arr[]={2,0,2,-2}; //注意测试
C语言中单向循环链表与双向循环链表详解
qq_41835250的博客
07-26 5188
每日一句 It’s gonna be ok. 一切都会好的。 内容概要 单向循环链表 首先来看看图示： 图展示的是一个单向循环链表，他跟以上的单向链表对比只是多了一个指向头结点的 指针，因此，他们的算法几乎是一样的。 第一，设计节点。 单向循环链表的节点跟单向链表完全一致。 第二，初始化空链表。 跟单向链表类似，我们既可以初始化一个带有头结点的空循环链表，也可以不要头结点： 这边把两个步骤放在一起了 linklist init_list(void) // 带有头结点的单循环链表 { linklis
c语言学习第7章PPT文档.pptx
11-14
"C语言学习第7章，主要讲解了一维数组的概念、定义、引用以及初始化，通过实例展示了数组元素的访问和操作。" 在C语言中，数组是一种非常重要的数据结构，它允许我们存储一组相同类型的数据。第7章的重点是介绍一维...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值