数据结构第二章 线性表

最新推荐文章于 2024-07-23 12:29:02 发布
最新推荐文章于 2024-07-23 12:29:02 发布
阅读量474 收藏 5
点赞数 1
分类专栏： 数据结构与算法（C++） 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjy131248/article/details/117431879
版权

文章目录

1 线性表的概念

线性表（List）概念：由n个类型相同的数据元素组成的有限序列。（类似排队，具有线一样性质的结构。）

线性表性质：

  1. 同一性：元素类型相同
  2. 有穷性：有限元素
  3. 有序性：存在序偶关系

2 线性表的顺序存储

2.1 顺序表存储结构

用一组地址连续的存储单元依次存储线性表中的各个元素，其物理结构和逻辑结构一致。可以将顺序表归纳为：“关系线性化，结点顺序存”。

顺序表第i个元素所在地址的计算：Loc(ai) = Loc(a1) + (n-1) * k。其中Loc（a1） 称为基地址，k是每个元素所占单元数。

2.2 顺序表抽象数据类型定义

C语言代码如下：

#define MAXSIZE 255

typedef struct {
	ElemType elem[MAXSIZE];
	int last;  //记录线性表最后一个元素在elem[]中的位置（下标），空表为-1
}SeqList;

说明：

  • Elem 应该根据实际情况而定，可以是int、double、char等
  • 变量L的定义和使用的两种方式：
    • 通过变量定义语句：
      • SeqList L；
      • 利用L.elem[i-1]访问第i个元素，利用L.last得到顺序表最后一个元素的下标，L.last+1是顺序表长度。
    • 通过指针变量定义语句：
      • SeqList L1， *L； L = &L1；
      • 利用L -> elem[i-1]访问第i个元素，利用L -> last +1得到顺序表长度

2.3 顺序表基本运算

2.3.1 查找

int SeqSearch(SeqList L, ElemType e)
{
    int i = 0;
    while((i<=L.last)&&(L.elem[i]!=e))
    {
        i++;
    }
    if(i<=L.last)
        return (i+1);  //i是e元素在elem[]中的下标，i+1是e元素在线性表中的位置
    else
        return(-1);  //e不在elem[]中,返回-1
}

2.3.2 插入

#define OK 1
#define ERROR 0

int SeqInsert(SeqList *L, int i, ElemType e)
/*
    在顺序表第i个位置之前插入一个元素e
*/
{
    int k;
    if((i<1)||(i>L->last+2))
    {
        printf("插入位置i值不合法");
        return ERROR;
    }
    if(L->last >= MAXSIZE -1)
    {
        printf("表已满，无法插入");
        return ERROR;
    }
    for(k = L->last; k>= i-1; k--)
    {
        L->elem[k+1] = L->elem[k];
    }
    L->elem[i-1] = e;
    L->last++;
    return OK;
}

2.3.3 删除

#define OK 1
#define ERROR 0

int SeqDelete(SeqList *L,int i, ElemType *e)
/*
    删除在顺序表第i个位置的元素，用e返回其值
*/
{
    int k;
    if((i<1)||(i>L->last+1))
    {
        printf("删除位置不合法");
        return ERROR;
    }
    e = L->elem[i-1];
    for(k = i; k<= L->last; k++)
    {
        L->elem[k-1] = L->elem[k];
    }
    L->last--;
    return OK;
}

2.3.4 合并

前提：
有两个顺序表LA和LB，其元素均为非递减有序排列，编写一个算法，将它们合并成一个顺序表LC，要求LC也是非递减有序排列。

算法思想：
设表LC是一个空表。设置两个指针i、j分别指向表LA和LB中的元素。

  • 若LA.elem[i] ≤ LB.elem[j]，则先将LA.elem[j]插入到表LC中
  • 若LB.elem[i] ≤ LA.elem[j]，则先将LB.elem[i]插入到表LC中
  • 最后再将未扫描完的表中剩余的所有元素放到表LC中
void MergeSeqList(SeqList *LA, SeqList *LB, SeqList *LC)
{
    int i=0,j=0,k=0,l;
    while(i<=LA->last && j<=LB->last)
    {
        if (LA->elem[i] <= LB->elem[j])
        {
            LC->elem[k] = LA->elem[i];
            i++;
            k++;
        }
        else
        {
            LC->elem[k] = LB->elem[j];
            j++;
            k++;
        }
    }
    while(i<=LA->last)
    {
        LC->elem[k] = LA->elem[i];
        i++;
        k++;
    }
    while(j<=LB->last)
    {
        LC->elem[k] = LA->elem[j];
        j++;
        k++;
    }
    LC->last = LA->last+LB->last+1;
}

2.4 顺序存储的优点和缺点

2.4.1 优点

  1. 无需为表示结点间的逻辑关系而增加额外的存储空间。
  2. 可方便地随机存取表中的任一元素。

2.4.2 缺点

  1. 插入或删除运算不方便，除表尾的位置外，在表的其它位置上进行插入或删除操作都必须移动大量的结点，效率较低。
  2. 由于顺序表要求占用连续的存储空间，存储分配只能预先进行静态分配。因此当表长变化较大时，难以确定合适的存储规模。

3 线性表的链式存储

3.1 链表的概念

概念：用一组任意的存储单元存储线性表的数据元素。每一个数据元素就是一个结点，包括数据域和指针域。

结点：数据元素信息（数据域：data）+ 后继结点的地址（指针域：next）

3.2 单链表

概念：只有一个next指针域的线性链表。链表里每个结点的存储地址存放在前驱结点的指针域中。由于线性表第一个结点无前驱，所以应该设一个头指针H指向第一个结点。由于线性表最后一个结点没有直接后继，指定单链表最后一个结点的指针域为空。

3.2.1 单链表抽象数据类型定义

C语言代码如下：

typedef struct Node{
	ElemType data;
	struct Node *next;  //记录线性表最后一个元素在elem[]中的位置（下标），空表为-1
}Node, *LinkList;

说明：LinkList与Node * 同为结构指针类型，两种类型等价。通常习惯用LinkList说明指针变量，强调它是某个单链表的头指针变量。用Node*来定义单链表中结点的指针，表明指向单链表中结点的指针变量。

3.2.2 初始化单链表

InitList(LinkList *L)
{
	*L = (LinkList)malloc(sizeof(Node)); //建立头节点
    (*L)->next = NULL;  //建立空的单链表L*
}

3.2.3 单链表的建立

头插法建表：

void GreatFromHead(LinkList L)
{
    Node *s;
    char c;
    int flag = 1;
    while(flag)
    {
        c = getchar();
        if(c!='$')
        {
            s = (Node * )malloc(sizeof(Node));//建立新结点s
            s->data = c;
            s->next = L->next;
            L->next = s;
        }
        else
            flag = 0;
    }
}

尾插法建表（推荐）：

void GreatFromTail(LinkList L)
{
    Node *s, *r;
    char c;
    int flag = 1;
    r = L;
    while(flag)
    {
        c = getchar();
        if(c!='$')
        {
            s = (Node * )malloc(sizeof(Node));//建立新结点s
            s->data = c;
            r->next = s;
            r = s;
        }
        else
        {
            flag = 0;
            r->next = NULL;
        }
    }
}

3.2.4 单链表的查找

按序号查找

Node * Get(LinkList L, int i)
{
	if(i<=0)
        return null;
    int j = 0;
    Node *p
    p = L;
    while((p->next!=NULL)&&(j<i))
    {
     p = p->next;
     j++;   
    }
    if(j==i)
        return p;
    else
        return NULL;
}

按值查找

Node * Locate(LinkList L, ElemType key)
{
    Node * p;
    p = L->next;
    while(p!=NULL)
    {
        if(p->data!=key)
            p = p->next;
        else
            break;
    }
    return p;
}

3.2.5 单链表的插入

void InsList(LinkList L, int i, ElemType e)
{
	//第i个数据元素之前插入一个数据元素e
	if(i<=0)
        return ERROR;
    Node *pre, *s;
    int k = 0;
    pre = L;
    while(pre!=NULL && k<i-1)
    {
        pre = pre->next;
        k++;
    }
    if(pre==NULL)
    {
        printf("插入位置不合理！");
        return ERROR;
    }
    s = (Node*)mallcon(sizeof(Node))
    s->data = e;
    s->next = pre->next;
    pre->next = s;
    return OK;
}

3.2.6 单链表的删除

int DelList(LinkList L, int i,ElemType e)
{
    Node *pre,*r;
    int k=0;
    pre = L;
    while(pre->next!=NULL&&k<i-1)
    {
        pre=pre->next;
        k++;
    }
    if(pre->next==NULL)
    {
        printf("删除结点的位置不合理！");
        return ERROR;
    }
    r = pre->next;
    pre->next = r->next;
    *e = r->data;
    free(r);
    return OK;
}

3.2.7 两个单链表的差

前提：假设集合A用单链表LA表示，集合B用单链表LB表示，设计算法求两个集合的差，即A-B。

void Difference (LinkList LA,LinkList LB) 
/*此算法求两个集合的差集*/
{ 
	Node *pre, *p, *r;
	pre=LA;
	p=LA->next; /*p是表中的某一结点，pre始终指向p的前驱*/
	while(p!=NULL){
		q=LB->next; /*扫描LB中的结点，寻找与LA中*P结点相同的结点*/
		while (q!=NULL&&q->data!=p->data) 
			q = q->next;
		if (q!=NULL){ 
			r = p; 
			pre->next = p->next; 
			p = p->next; 
			free(r); 
		}
		else{ 
			pre = p;
			p = p->next; 
		}
	}
}

3.3 循环链表

概念：循环链表是一个首尾相接的链表。

特点：

  • 表中最后一个结点的指针指向第一个结点或表头结点（如有表头结点的话）。
  • 循环链表的运算与线性链表基本一致。但两者判断是否到表尾的条件不同。

3.3.1 循环链表抽象数据类型定义

typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node,*LinkList;

3.3.2 初始化循环链表

InitCLinkList(LinkList *CL)
{
    *CL = (LinkList)malloc(sizeof(Node));
    (*CL)->next = *CL;
}

3.3.3 循环链表的建立

void GreateCLinkList(LinkList *CL)
{
    Node *rear, *s;
    char c;
    rear =  CL;
    c = getchar();
    while(c!='$')
    {
        s = (Node * )malloc(sizeof(Node));
        s->data = c;
        rear->next = s;
        rear = s;
        c = getchar();
    }
    rear->next = CL;
}

3.3.4 循环链表的合并

//循环单链表合并算法1
LinkList merge_1(LinkList LA, LinkList LB)
{
    Node *p,*q;
    p = LA;
    q = LB;
    while(p->next!=LA) p = p->next;
    while(q->next!=LB) q = q->next;
    q->next = LA;
    p->next = LB->next;
    free(LB);
    return(LA);
}

//循环单链表合并算法2
//RA、RB指向表尾
LinkList merge_2(LinkList RA, LinkList RB)
{
    Node *p;
    p = RA->next;
    RA->next = RB->next->next;
    free(RB->next);
    RB->next = p;
    return RB;
}

3.4 双向链表

结点：prior（前驱指针域)、data（数据域）、next（后继指针域）
双向链表结点结构

3.4.1 双向链表抽象数据类型定义

#define ERROR 0
#define OK 1

typedef struct DNode{
    ElemType data;
    struct DNode *prior,*next;
}DNode,*DoubleList;

3.4.2 双向链表的插入

int DlinkIns(DoubleList L,int i,ElemType e)
{
    if(i<0) 
    	return ERROR;
    DNode *s, *p;
    int k = 0;
    p = L;
    while(p!=NULL && k<i)
    {
        p = p->next;
        k++;
    }
    if(p==NULL)
    {
        printf("插入位置不合理！");
        return ERROR;
    }
    s = (DNode * )malloc(sizeof(DNode));
    if(s)
    {
        s->data = e;
        s->prior = p->prior;
        p->prior->next = s;
        s->next = p;
        p->prior = s;
        return OK;
    }
    else
        return ERROR;
}

3.4.3 双向链表的删除

int DlinkDel(DoubleList L,int i,ElemType *e)
{
    if(i<0) 
    	return ERROR;
    DNode *p;
    int k = 0;
    p = L;
    while(p!=NULL && k<i)
    {
        p = p->next;
        k++;
    }
    if(p==NULL)
    {
        printf("删除位置不合理！");
        return ERROR;
    }
    *e = p->data;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    free(p);
    return OK;
}

4 线性表应用

4.1 一元多项式

一元多项式的表示：Pn(x) = P0 + P1x +P2x^2 +……+Pnx^n

一元多项式存储:

  • 顺序存储表示：只存储一元多项式各项的系数，每个系数所对应的指数则隐含在存储系数的顺序表下标中。
  • 链式存储表示：存储非零项系数和非零项指数这两项
//链式存储
//一元多项式结点结构定义如下：
typedef struct Polynode {
    int coef; //系数
    int exp;  //指数
    struct Polynode * next;
}Polynode,*Polylist;

//用尾插法建立一元多项式的链表
Polylist PolyCreate {
    Polynode * head, * rear, * s;
    int c, e;
    head = (Polynode *)malloc(sizeof(Polynode));
    rear = head;
    scanf("%d,%d",&c,&e);//输入系数和指数项
    while(c!=0)
    {
        s = (Polynode *)malloc(sizeof(Polynode));
        s->coef = c;
        s->exp = e;
        rear->next = s;
        rear = s;
        scanf("%d,%d",&c,&e);
    }
    rear->next = NULL;
    return(head);
}

//一元多项式的相加运算
void PolyAdd(Polylist polya,Polylist polyb)
{
    Polynode * p, * q, * tail, *temp;
    int sum;
    p = polya->next;
    q = polyb->next;
    tail = polya;
    while(p!=NULL && q!=NULL)
    {
        if(p->exp < q->exp)
        {
            tail->next = p;
            tail = p;
            p=p->next;
        }
        else if(p->exp == q->exp)
        {
            sum = q->coef + q->coef;
            if(sum!=0)
            {
                p->coef=sum;
                tail->next = p;
                tail = p;
                p = p->next;
                temp = q;
                q = q->next;
                free(temp);
            }
            else
            {
                temp = p;
                p = p->next;
                free(temp);
                temp = q;
                q = q->next;
                free(temp);
            }
        }
        else
        {
            tail->next = q;
            tail = q;
            q = q->next;
        }
    }
    if(p!=NULL)
    {
        tail->next = p;
    }
    if(q!=NULL)
    {
        tail->next = q;
    }
}

4.2 就地逆置问题

//相当于头插法
void ReverseList(LinkList L)
{
    Node *p, *q;
    p = L->next;
    L->next = NULL;
    while(p!=NULL)
    {
        q = p->next;
        p->next = L->next;
        L->next = p;
        p = q;
    }
}

5 顺序表和链表的比较

5.1 空间角度

  1. 顺序表的存储空间是静态分配的，在程序执行之前必须明确规定它的存储规模。适合于线性表长度变化不大，且容易估计长度的情况下。
  2. 存储密度(Storage Density), 是指结点数据本身所占的存储量和整个结点结构所占的存储量之比。若不考虑顺序表中的备用结点空间，则顺序表的存储空间利用率为100%，而单链表的存储空间利用率为50%

结论：当线性表的长度变化不大， 易于事先确定其大小时，为了节约存储空间，宜采用顺序表作为存储结构。

5.2 时间角度

  1. 若线性表的操作主要是进行查找，很少做插入和删除时，宜采用顺序表做存储结构。
  2. 在链表中的任何位置上进行插入和删除，都只需要修改指针。而在顺序表中进行插入和删除，平均要移动表中近一半的结点，尤其是当每个结点的信息量较大时，移动结点的时间开销就相当可观。
  3. 对于频繁进行插入和删除的线性表，宜采用链表做存储结构。 若表的插入和删除主要发生在表的首尾两端，则宜采用尾指针表示的单循环链表。

5.3 语言角度

  1. 对于没有提供指针类型的高级语言，若要采用链表结构，则可以使用光标实现的静态链表。虽然静态链表在存储分配上有不足之处，但它和动态链表一样，具有插入和删除方便的特点。
  2. 对那些具有指针类型的语言，静态链表也有其用武之地。特别是当线性表的长度不变，仅需改变结点之间的相对关系时，静态链表比动态链表可能更方便

6 链式存储方式的比较

链式存储方式的比较

7 实验课题目

7.1 链表删除

#include <stdio.h>
#include <stdlib.h>

//单链表的存储结构描述：
typedef struct Node
{
    int data;
    struct Node * next;
}Node,*LinkList;

//初始化单链表：
void CreatFromTail(LinkList L)
{
    struct Node *s;
    struct Node *r;
    int value;
    r = L;
    printf("请输入元素值（输入0表示结束输入）：");
    while(1) {
        scanf("%d",&value);
        if(value == 0){
            return;
        }
        s = (struct Node *)malloc(sizeof(struct Node));
        s->data = value;
        r->next = s;
        r = s;
        r->next = NULL;
  }
  return;
}
//删除
void DelList(LinkList L, int e){
    struct Node *pre;
    struct Node *r;
    pre = L;
    r = L->next;
    while(r!=NULL) {
        if(r->data == e) {
        pre->next = r->next;
        }
    r = r->next;
    pre = pre->next;
    }
}

//输出链表
void printList(struct Node *L) {
  struct Node *p;
  p = L->next;
  while(p != NULL) {
    printf("%d ",p->data);
    p = p->next;
  }
  return;
}

int main()
{
  int x;
  struct Node *L;
  L = ( struct Node *)malloc(sizeof(struct Node));
  L->next = NULL;
  CreatFromTail(L);
  printf("请输入要删除的元素：");
  scanf("%d",&x);
  printf("删除前");
  printList(L);
  printf("\n");
  printf("删除后");
  DelList(L,x);
  printList(L);
}

结果如下：
在这里插入图片描述

7.2 链表逆序

#include <stdio.h>
#include <stdlib.h>


//单链表的存储结构描述：
typedef struct Node
{
    int data;
    struct Node * next;
}Node,*LinkList;

//初始化单链表：
void CreatFromTail(LinkList L)
{
    struct Node *s;
    struct Node *r;
    int value;
    r = L;
    printf("请输入元素值（输入0表示结束输入）：");
    while(1) {
        scanf("%d",&value);
        if(value == 0){
            return;
        }
        s = (struct Node *)malloc(sizeof(struct Node));
        s->data = value;
        r->next = s;
        r = s;
        r->next = NULL;
  }
  return;
}

void ReverseList(LinkList L)
{
    Node *p, *q;
    p = L->next;
    L->next = NULL;
    while(p!=NULL)
    {
        q = p->next;
        p->next = L->next;
        L->next = p;
        p = q;
    }
}

//输出链表
void printList(struct Node *L) {
  struct Node *p;
  p = L->next;
  while(p != NULL) {
    printf("%d ",p->data);
    p = p->next;
  }
  return;
}

int main()
{
  int x;
  struct Node *L;
  L = ( struct Node *)malloc(sizeof(struct Node));
  L->next = NULL;
  CreatFromTail(L);
  printf("逆序前");
  printList(L);
  printf("\n");
  printf("逆序后");
  ReverseList(L);
  printList(L);
}

结果如下：
在这里插入图片描述

7.3 链表合并

#include <stdio.h>
#include <stdlib.h>


//单链表的存储结构描述：
typedef struct Node
{
    int data;
    struct Node * next;
}Node,*LinkList;


//初始化单链表：
void CreatFromTail(LinkList L)
{
    struct Node *s;
    struct Node *r;
    int value;
    r = L;
    printf("请输入元素值（输入0表示结束输入）：");
    while(1) {
        scanf("%d",&value);
        if(value == 0){
            return;
        }
        s = (struct Node *)malloc(sizeof(struct Node));
        s->data = value;
        r->next = s;
        r = s;
        r->next = NULL;
  }
  return;
}

//输出链表
void printList(struct Node *L) {
  struct Node *p;
  p = L->next;
  while(p != NULL) {
    printf("%d ",p->data);
    p = p->next;
  }
  return;
}

//两个有序的单链表合并
LinkList MergeLinkList(LinkList LA, LinkList LB)
{
    Node *pa, *pb, *pc,*r;
    LinkList LC;
    pa = LA->next;
    pb = LB->next;
    LC = LA;
    LC->next = NULL;
    r = LC;
    while(pa!=NULL&&pb!=NULL)
    {
        if(pa->data<=pb->data)
        {
            r->next = pa;
            r = pa;
            pa = pa->next;
        }
        else
        {
            r->next = pb;
            r = pb;
            pb = pb->next;
        }
    }
    if(pa)
        r->next = pa;
    else
        r->next = pb;
    free(LB);
    //去重
    pc = LC->next;
    while(pc->next!=NULL){
        if(pc->next->data == pc->data)
        {
            pc->next = pc->next->next;
        }
        pc = pc->next;
    }
    return(LC);
}

int main()
{
  struct Node *la;
  struct Node *lb;
  struct Node *lc;
  la = ( struct Node *)malloc(sizeof(struct Node));
  la->next = NULL;
  lb = ( struct Node *)malloc(sizeof(struct Node));
  lb->next = NULL;
  lc = ( struct Node *)malloc(sizeof(struct Node));
  lc->next = NULL;

  CreatFromTail(la);
  CreatFromTail(lb);
  printf("合并前la:");
  printList(la);
  printf(",");
  printf("合并前lb:");
  printList(lb);
  printf("\n");
  printf("合并后lc:");
  lc = MergeLinkList(la,lb);
  printList(lc);
}

结果如下：
在这里插入图片描述

7.4 顺序表合并

#include <stdio.h>
#include <stdlib.h>
#define MAX 20

//顺序表的存储结构描述：
typedef struct
{
	int elem[MAX]; /*线性表占用的数组空间*/
    int last; /*记录线性表中最后一个元素在数组elem[]的位置*/
}SeqList;


//初始化顺序表：
void CreateList(SeqList *L)
{
    int value = 0;
    int i = 0;
    printf("创建顺序表，请输入元素值：");
    while(1)
    {
        scanf("%d",&value);
        if(value == 0)
        {
            break;
        }
        L->elem[i] = value;
        i++;
    }
    L->last = i;
    return;
}

//输出顺序表
void printList(SeqList *L) {
    int i=0;
    while(i<L->last)
    {
        printf("%d ",L->elem[i]);
        i++;
    }
}

void DelList(SeqList *L,int i)
/*
    删除在顺序表第i个位置，用e返回其值
*/
{
    int k;
    if((i<1)||(i>L->last+1))
    {
        printf("删除位置不合法");
        return;
    }
    //e = L->elem[i-1];
    if(L->last >= 20-1)
    {
        printf("表已满，无法插入");
        return;
    }
    for(k = i; k<= L->last; k++)
    {
        L->elem[k-1] = L->elem[k];
    }
    L->last--;
    return;
}

//两个有序的顺序表合并：
void MergeLinkList(SeqList *LA, SeqList *LB,SeqList *LC)
{
    int i=0;
    int j=0;
    int k=0;
    while(i<=LA->last && j<=LB->last)
    {
        if(LA->elem[i]<=LB->elem[j])
        {
            LC->elem[k] = LA->elem[i];
            i++;k++;
        }
        else if(LA->elem[i]>LB->elem[j])
        {
            LC->elem[k] = LB->elem[j];
            j++;k++;
        }
    }
    while(i<LA->last)
    {
        LC->elem[k]=LA->elem[i];
        i++;k++;
    }
    while(j<LB->last)
    {
        LC->elem[k]=LB->elem[j];
        j++;k++;
    }
    LC->last = LA->last+LB->last;
    //去重
    i = 0;
    while(i<LC->last){
        if(LC->elem[i+1]==LC->elem[i])
        {
            DelList(LC,i+1);
        }
        i++;
    }
}

int main()
{
  SeqList *la;
  SeqList *lb;
  SeqList *lc;

  la = (SeqList *)malloc(sizeof(SeqList));
  lb = (SeqList *)malloc(sizeof(SeqList));
  lc = (SeqList *)malloc(sizeof(SeqList));

  CreateList(la);
  CreateList(lb);

  printf("合并前la:");
  printList(la);
  printf(",");
  printf("合并前lb:");
  printList(lb);
  printf("\n");
  printf("合并后lc:");
  MergeLinkList(la,lb,lc);
  printList(lc);
}

结果如下：
在这里插入图片描述

7.5 约瑟夫环

题目描述：
在这里插入图片描述

#include "stdio.h"
#include "stdlib.h"

//链表结构描述：
typedef struct Node{
    int index;
    struct Node *next;
} LinkList;


//初始化线性表
LinkList* CreateList(LinkList *L,int n){

    LinkList *p;
    LinkList *r;

    L=(LinkList*)malloc(sizeof(struct Node));
    L->next=NULL;
    r=L;
    for (int i=1; i<=n; i++)
    {
        p=(LinkList*)malloc(sizeof(struct Node));
        p->index=i;
        r->next=p;
        r=p;
    }
    r->next=L->next;
    L = L->next;
    return L;
}

//删除
void DelList(LinkList *L,int n){
    LinkList *q;
    while(L!=L->next)
    {
        for (int i = 2; i <n; i++)
        {
            L=L->next;
        }
        q=L->next;
        L->next=L->next->next;
        free(q); //释放节点
        L=L->next;
    }
    printf("最后剩余的猴子是:%d",L->index);
}

int main(){

    LinkList *L;
    LinkList *Head=NULL;
    LinkList *Circle;

    int n,m,start;
    printf("猴子个数：");
    scanf("%d",&n);
    printf("设置M为:");
    scanf("%d",&m);
    Head = CreateList(L,n);
    DelList(Head,m);
    return 0;
}

结果如下：
在这里插入图片描述

看风结种子
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法设计-归并两个非递减有序排列的线性表
愚 公
04-15 5811
已知线性表La和Lb中的数据元素按值非递减有序排列，现要求将两个线性表归并为一个新的线性表Lc,Lc中的数据要求按值非递减有序。 void MergerList(List &amp;La,List &amp;Lb,List &amp;Lc)     {                                                                  //归并a,b线...
非递减有序排列的线性表合并
weixin_43928264的博客
03-30 2310
若线性表LA与LB中的数据元素是按非递减有序排列的，现在要把这两个线性表合并为一个新的非递减有序排列的线性表LC，那么应该用到什么算法呢？ 其实，我们需要两个指针i、j，分别指向LA、LB中的某个元素，然后比较两个指针指的值，进行插入即可，算法如下： void UnionList(List La, List Lb, List &Lc){ //已知La与Lb是非递减有序排列的 ...
线性表的应用：一元多项式的表示及其相加
caoleiwe的博客
07-11 1035
     以下内容主要参考了严蔚敏版的数据结构教材，仅为加强学习，不做其他用途。      一元多项式pn(x)=p0+p1x+p2x2+...+pnxnp_n(x)=p_0+p_1x+p_2x^2+...+p_nx^npn​(x)=p0​+p1​x+p2​x2+...+pn​xn一共有n+1n+1n+1个系数，在计算机中可以用线性表来表示。每一个节点的数据域存储每一项的系数：第0个节点存储系数p0p_0p0
有两个顺序表LA和LB，其元素，其元素均为非递减有序排列，编写一个算法，将它们合并成一个顺序表LC，要求LC也是非递减有序排序。
qq_45917176的博客
03-02 8123
有两个顺序表LA和LB，其元素，其元素均为非递减有序排列，编写一个算法，将它们合并成一个顺序表LC，要求LC也是非递减有序排序。 C语言版 解法一： #include <stdio.h> typedef struct { int *elem; int len } SqList; void MergeList(SqList *LA, SqList *LB, SqList *LC) { int i, j, n; for (i = LA->len - 1, j
【程序设计: 设有线性表 LA=(3,5,8,11)和 LB=(2,6,8,9,11,15,20)； 1.若LA和LB分别表示两个集合A和B，求新集合A二AUB(“并”操作，相同元素不保留)】
c_origin_的博客
02-26 813
程序设计: 设有线性表 LA=(3,5,8,11)和 LB=(2,6,8,9,11,15,20); 1.若LA和LB分别表示两个集合A和B，求新集合A二AUB(“并”操作，相同元素不保留); 2.将LA归并到LB表中且仍保持有序(相同元素要保留)。--引自教材例2.1和2.2
数据结构 第二章 线性表
weixin_44413191的博客
11-16 308
创建带头结点的单链表 CreatList函数： Node* CreatList() { Node*head = (Node*)malloc(sizeof(Node)); head->next = NULL; Node* p = head; int a; cin >> a; while(a!=-1) { Node *q= (Node*)malloc(sizeof(No...
第二章 数据结构-线性表
qq_45604925的博客
10-08 644
注：这是本人观看B站王卓老师讲的数据结构与算法的学习笔记
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
专升本数据结构第二章 线性表.pdf
01-14
线性表是数据结构的基础部分，它是一种特殊的数据组织形式，由n（n>=0）个相同类型的数据元素构成的有限序列。线性表的每个元素都有一个直接前驱和直接后继，除了首元素（没有前驱）和尾元素（没有后继）。这种结构...
数据结构第二章线性表.pdf
09-30
数据结构第二章线性表.pdf 本章主要介绍了线性表的逻辑结构、顺序存储结构和链式存储结构，并对顺序表和链表进行了比较。学习目的要求学生能够熟悉线性表的逻辑结构和各种存储表示方法，以及定义在逻辑结构上的各种...
数据结构第二章线性表
03-03
线性表的定义和基本操作 线性表的顺序存储结构 线性表的链式存储结构 线性表的应用举例
数据结构第二章线性表习题.doc
09-24
数据结构第二章线性表习题 本节习题涵盖了数据结构第二章线性表的主要知识点，包括线性表的定义、顺序表和链表的存储结构、插入、删除、查找等基本操作的时间复杂度分析，以及栈的实现和应用。 1. 线性表是有限...
数据结构 线性表
SongYuLong
03-12 394
线性表的类型定义： 线性表(linear_list)是最常用且最简单的一种数据结构。一个线性表是n个数据元素的有限序列。 一个数据元素可以由若干个数据项（item）组成。 线性表中元素的个数n(n&gt;=0)定义为线性表的长度，n=0时称为空表。 抽象数据类型线性表的定义如下： ADT List { 数据对象：D={ai | ai属于ElemSet, i=1,2,......
2007.08.16
blacklord的专栏
08-16 620
算法       线性表的删除与插入运算类似，在顺序表上实现删除运算也必须移动结点，这样才能反映出结点间的逻辑关系的变化。若i=L->last+1，则移位语句L->elem[k-1]=L->elem[k]不执行，因为循环变量的初值大于终值，此时不需要移动元素，仅将表长度减1即可。显然，删除算法中移位语句L->elem[k-1]=L->elem[k]的执行频度也与删除位置i有关。在顺序表中插
有两个顺序表LA,LB，其元素均为非递减有序排列，编写算法将它们合并成一个顺序表LC，要求LC也是非递减有序排列。 例如：LA={2,2,3} LB={1,3,3,4} 则LC={1,2,2,3，3，
qq_50504109的博客
09-13 2518
1、有两个顺序表LA,LB，其元素均为非递减有序排列，编写算法将它们合并成一个顺序表LC，要求LC也是非递减有序排列。 例如：LA={2,2,3} LB={1,3,3,4} 则LC={1,2,2,3，3，3,4} 部分函数的调用请参考：https://blog.csdn.net/qq_50504109/article/details/120273546 #include<stdio.h> #include "InstanceLinearList.c" //相当于java中的导包，利用我
数据结构 实验四：（栈实验，设计性）
m0_47161653的博客
04-13 1040
一、实验目的 通过本实验的学习，掌握栈的特性，理解栈结构的构造方法，为灵活运用栈奠定基础。 二、实验内容 （1）采用链式存储实现栈的初始化、入栈、出栈操作。 （2）给定一个括号序列，里面包括圆括号和方括号，编程检验该括号序列中括号是否配对 三、实验原理、方法和手段 1、根据实验内容编程，上机调试、得出正确的运行程序。 2、编译运行程序，观察运行情况和输出结果。 四、实验环境、条件 硬件：计算机一台。 软件：DEV C++, Visual C++。 五、实验组织运行要求 以学生自主训练为主的开放模式组织教学。
单链表的应用（集合的差集）
qq_58299006的博客
10-04 1599
目录 题目内容 算法分析 概要设计 函数类型 算法流程图 源代码 运行结果 题目内容 如果以单链表表示集合，假设集合A用单链表LA表示，集合B用单链表LB表示，设计算法求两个集合的差，即A-B。 算法分析 本设计使用单链表实现。 由集合算法的规则可知，集合的差A-B中包含所有属于集合A而不属于集合B的元素。具体做法：先定义结构体类型，然后用尾插法建立空表用于存储集合A和集合B，在设计差集运算时，从集合A的第一个元素开始遍历，寻找元素e，对于集合A中每一个元素e，在集合...
单链表求差集
douxianer
10-06 1381
/*时间：2021年10月6日 版本：Dve-C++ 5.11 问题描述：以单链表表示集合，假设集合A用单链表LA表示， 集合B用单链表LB表示，设计算法求两个集合的差，即A-B。*/ #include<stdio.h> #include<string.h> #include<stdlib.h> #include<ctype.h> #include<math.h> #include<time.h> #def.
c语言（7.23）
最新发布
fhgfyrsg的博客
07-23 382
【代码】c语言（7.23）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值