学习记录——顺序表（noj01-03）

已于 2023-04-08 10:43:16 修改
阅读量64 收藏
点赞数
文章标签： 链表 数据结构
于 2023-04-08 10:38:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75741073/article/details/129797629
版权

T1：顺序表的插入运算

Q1：顺序表的创建 

step1. 类型定义         (12条消息) typedef介绍_liitdar的博客-CSDN博客

step2.创建线性表+初始化——元素设置默认值，长度设置为0 

        type1：

#include <stdio.h>
#include <stdlib.h>
#define MAXNUM 100;//最大存储个数
typedef struct//类型定义顺序表
{
    int element[MAXNUM];//存放数据元素
    int length;//当前长度
}SeqList;

SeqList CreatNullList(){
    SeqList L;//声明一个顺序表
    int i;
    for(i=0;i<MAXNUM;i++){
        L.element[i]=0;//将所有数据元素设置默认初始值；
//若不初始化顺序表，设置默认值，内存中将遗留脏数据。
    }
    L.length=0;//顺序表初始长度设置为0；
}//初始化顺序表
int main()
{
    SeqList L=CreatNullList();//初始化顺序表；
    ......
    return 0;
}

        type2：可变长 

#define SIZE 10
typedef struct List//定义一个不定长顺序表
{
    int *head;  //声明了一个名为head的长度不确定的数组，也叫“动态数组”
    int length; //当前表中元素个数
    int size;   //表的大小，类于MAXNUM；
}SqList，*PSeqList;

SqList InitList()//初始化
{
    SqList L;

    L.head = (int *)malloc(SIZE * sizeof(int));  //构造一个空的顺序表，动态申请存储空间
    
    if(!(L.head))   //如果申请失败，作出提示并直接退出程序
    {
        printf("初始化失败");
        exit(0);//ps.见下
    }

    L.size = SIZE; //空表的初始存储空间为SIZE
    L.length = 0;   //空表的长度初始化为0

    return L;
}
/*exit()是一个标准 C 库函数，包含在头文件<stdlib.h>里，是用来终止进程的，
        exit(0)表示程序正常退出，非0表示非正常退出。exit(1) 和exit(-1) 是分别返回1和-1到主调程序。
        return是语言级别的，它表示了调用堆栈的返回；exit是系统调用级别的，它表示了一个进程的结束。*/

Q2：顺序表的插入运算——按顺序插入元素x

引用1：在下标p处插入元素x

        思路：p位置元素及以后元素均向后移动一位，从后往前

        特况：     ①p非法：p<0|| ( p>palist->length)

                        ②移动后溢出：palist->length==MAXNUM

引用2：按值查找x的位置

#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define MaxSize 10
typedef struct
{
	int elem[MaxSize];
	int length;
}SeqList;
void InitList(SeqList* L){
    int i;
    for(i=0;i<MaxSize;i++){
        L->elem[i]=0;
    }
    L->length=0;
}
int insert_seq(SeqList* L,int i,int x)//在下标为i处插入元素x
{
        if(L->length==MaxSize){
            printf("Overflow!\n");
            return (ERROR);
        }
        if(i<0||(i>L->length)){
            printf("Not exist!\n");
            return (ERROR);
        }
        int p;
        for(p=L->length-1;p>=i;p--){
            L->elem[p+1]=L->elem[p];
        }
        L->elem[i]=x;
        L->length++;

        return (OK);
}
int locate_seq(SeqList* L,int x){
    int p=0;
    while(L->elem[p]<x){
        p++;
    }
    return p;
}

int main()
{
    SeqList L;
    SeqList* p;
    p=&L;
    InitList(p);

    scanf("%d",&L.length);
    int i;
    for(i=0;i<L.length;i++){
        scanf("%d",&L.elem[i]);
    }
    int x;
    scanf("%d",&x);

    i=locate_seq(p,x);
    insert_seq(p,i,x);
    for(i=0;i<L.length;i++){
        printf("%d ",L.elem[i]);
    }

    return 0;
}

T2：线性表的就地逆置

ps：noj BUG：可以用以下代码

#include<stdio.h>
int main()
{
    int n,i;
    int a[100];
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    for(i=n-1;i>=0;i--)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
    for(i=n-1;i>=0;i--)
    {
        printf("%d ",a[i]);
    }
    return 0;
}

【W1】顺序表的就地逆置

易错点1：数组起始为0，末为n-1

易错点2：顺序表的建立

思考点1：顺序表的逆置

#include <stdio.h>
#include <stdlib.h>
#define MAXNUM 1000
typedef struct{
    int element[MAXNUM];
    int length;
}SeqList,*PSeqList;

void CreatNullSeqList(PSeqList p){
    int i;
    for(i=0;i<MAXNUM;i++){
        p->element[i]=0;
        p->length++;
    }
    p->length=0;
}
PSeqList inputSeqList(PSeqList p){
    scanf("%d",&p->length);
    int i;
    for(i=0;i<p->length;i++){
        scanf("%d",&p->element[i]);
    }
    return p;
}
PSeqList reverseSeqList(PSeqList p){
    int x,i,l=p->length;
    for(i=0;i<=(l/2);i++){
        x=p->element[i];
        p->element[i]=p->element[l-i-1];//注意开始元素下标为0，最后为n-

        p->element[l-i-1]=x;
    }
    return p;
}
void outputSeqList(PSeqList p){
    int i;
    for(i=0;i<p->length;i++){
        printf("%d ",p->element[i]);
    }
    printf("\n");
}


int main()
{
    SeqList L;
    PSeqList p=&L;//必需先定义一个L，再定义p

    CreatNullSeqList(p);
    inputSeqList(p);
    reverseSeqList(p);
    outputSeqList(p);

    return 0;
}

【W2】链表的就地逆置

Q1：链表的创建

参考文章：一口气搞懂「链表」，就靠这20+张图了 - 知乎 (zhihu.com)

step1：定义结点——数据域&指针域

step2：链表初始化——>创建头结点——>分配内存空间（注意需强制类型转换，malloc返回指向被分配内存的指针）&&初始化头结点： 

step3：建立链表（尾插法）

                        step3.1.1：已知 结点总数 n，

                        step3.1.2：创建过渡结点p（用于辅助记忆指向后继结点地址，类于尾结点）

                        step3.1.3：循环创建——创建结点s1、s2、......，

                                ①分配空间 ②输入数据 ③地址传递 ④地址移动 

typedef struct Node{//定义结点
    int data;
    struct Node* next;
}Node,*LinkList;
LinkList Creat_LinkList(){
    Node* head=(Node*)malloc(sizeof(Node));//创建头结点
    if(head==NULL){
        printf("Fail!");
        exit(0);
    }
    head->next=NULL;//Initial_LinkList

    Node* p;//中间过渡节点，相当于尾节点
	p=head;

	int n;//链表长度
	scanf("%d", &n);
	int i;
	for(i=0;i<n;i++)//循环创建结点，输入具体数据
	{
		Node* s=(Node*)malloc(sizeof(Node));
		scanf("%d", &s->data);
        p->next = s;
//因为插完第一个结点后用p保存了上一个结点，所以再插结点时应该插在p节点后面，这就是尾插。
        s->next = NULL;//别忘了让插在尾部的s结点的指针指向NULL。
        p = s;//p结点保存刚才的s结点；以保证p始终为链表的最后一个节点
	}
    free(p);
    return head;
}

Q2:就地逆置

参考文章：(13条消息) C语言 链表逆置四种方法 超详细_qascetic的博客-CSDN博客

思路： 

 链表逆置就地逆置法步骤解析图

 链表逆置就地逆置法步骤解析图

链表逆置就地逆置法步骤解析图

T3：顺序表的删除

#include <stdio.h>
#include <stdlib.h>
#define MAXNUM 100
#define FALSE 0
#define OK 1
typedef struct{
    int element[MAXNUM];
    int length;
}SeqList,*PSeqList;
void initializer_Seqlist(PSeqList p){
    p->length=0;
    int i;
    for(i=0;i<MAXNUM;i++){
        p->element[i]=0;
    }
}
int input_SeqList(PSeqList p,int l){
    p->length=l;
    if(l>=MAXNUM){
        printf("Overflow!");
        return FALSE;
    }
    int i;
    for(i=0;i<l;i++){
        scanf("%d",&p->element[i]);
    }
    return OK;
}
int delete_SeqList(PSeqList a,int x,int t){
    int i=t,m,n;
    while(a->element[i]!=x&&i<a->length) i++;
    if(i==a->length){
        return t;
    }
    t=i;
    i=a->length-1;
    for(m=a->element[i];i>t;i--){
        n=a->element[i-1];
        a->element[i-1]=m;
        m=n;
    }
    a->length--;
    return t;
}
void fun_sameBC(PSeqList b,PSeqList c,PSeqList a){
    int i=0,j=0,t=0;
    int x,y;
    while(i<b->length&&j<c->length){
        x=b->element[i];
        y=c->element[j];
        if(x>y){
            j++;
        }
        if(x==y){
            i++;
            j++;
            t=delete_SeqList(a,x,t);
        }
        if(x<y){
            i++;
        }
    }
}
int output_Seqlist(PSeqList a){
    int i=0;
    int l=a->length;
    if(!l){
        printf("NULL!");
        return FALSE;
    }
    for(i=0;i<l;i++){
        printf("%d ",a->element[i]);
    }
    return OK;
}
int main()
{
    int m,n,p;
    scanf("%d %d %d",&m,&n,&p);
    SeqList A,B,C;
    PSeqList a=&A,b=&B,c=&C;
    initializer_Seqlist(a);
    initializer_Seqlist(b);
    initializer_Seqlist(c);
    input_SeqList(a,m);
    input_SeqList(b,n);
    input_SeqList(c,p);
    fun_sameBC(b,c,a);
    output_Seqlist(a);
    return 0;
}

2201_75741073
关注
【数据结构】NOJ002 线性表的就地逆置
夏至是个程序媛
04-02 741
#include <iostream> #include <stdlib.h> using namespace std; //一维数组存储 int LArray[1001]; //链式存储 typedef struct node { int val; struct node *next; }*LNode; int main() { //初始化 ...
『西工大-数据结构-NOJ』 002-线性表的就地逆置(耿2.9) 『西北工业大学』
LanXiu_的博客
07-02 2748
解题思路： 这道题要求用数组和单链表两种储存形式完成线性表就地逆置的算法，即只能有常数量级的空间开销。 数组的拟制很简单，就从中间分开前后交换，注意元素个数为奇偶时中间位置的计算。 单链表采用头插法，将原链表顺序插入即的到其逆序结果，画图可使链表算法更好理解。 具体操作见代码，代码中有部分注释。 题解代码： #include <stdio.h> #include <stdlib.h> //以数组作为储存结构 void CreatArray(int n, int A[]){//创..
西工大NOJ数据结构理论——002.线性表的就地逆置（耿2.9）
a15735748145a的博客
03-08 1242
西工大NOJ数据结构理论——002.线性表的就地逆置（耿2.9）
【数据结构】NOJ002—线性表的就地逆置
杨的博客
09-26 1403
题目简述： 解析： （1）数组的就地逆置使用一个临时变量两两进行交换即可； （2）链表的就地逆置可以直接使用头插法建立链表； 重点： （1）链表的头插法和尾插法； （2）链表的前插入和后插入方法（上篇博客）； 代码： 其实此处逆置数组和链表时，可以在输入数字的时候直接输入一个令其等于a[n-i]就可以原地逆置数组，但我还是单独写出来逆置，并且将链表逆置也单独写了一个函数。 #include <iostream> using namespace std; stru.
数据结构noj02线性表的就地逆置
m0_61609731的博客
04-05 71
【代码】数据结构noj02线性表的就地逆置。
笔记 顺序表（3）
weixin_52134279的博客
10-25 66
分析 insertItem的返回值，两个false无法判断错误原因，所以修改，添加宏定义，增强可读性。#define NFEASIBLE -1//不能实行。#define OVERFLOW -2//内存溢出。顺序表删除数据（删除pos位置的值）删除顺序表最后一个值。
顺序表小记
m0_73488514的博客
10-13 311
顺序表小记
数据结构NOJ——03顺序表的删除
m0_56046092的博客
08-10 318
#include<iostream> using namespace std; typedef int ElemType; #define MAXSIZE 10 typedef struct { ElemType* data; int length; }SqList; void Create_Sq(SqList& L) { cin >> L.length; L.data = (ElemType*)malloc(L.length * sizeof(ElemTyp.
『西工大-数据结构-NOJ』 003-顺序表的删除(严2.29) 『西北工业大学』
LanXiu_的博客
07-02 3848
解题思路： 这道题要求对三个非递减有序的线性表（其实就是广义递增）中的A表进行删除操作，需删除的元素为B、C表中均出现的元素。 我们比较好想到的一种方法，使用一个数组去储存重复元素，再进行去重操作，这种方式在重复率比较理想的情况下也不会造成太多的储存花销。 具体操作见代码，代码中有部分注释。 题解代码： #include <stdio.h> #include <stdlib.h> typedef struct node{ int data; struct nod..
noj-c语言大作业超市管理系统
04-28
【知识点详解】 本文将介绍如何使用C语言编写一个超市管理系统程序。这个系统包含了建立库存信息、显示所有信息、管理购物车以及结算等基本功能。...通过学习和理解这个程序，可以进一步提升C语言编程和软件设计能力。
西北工业大学数据结构noj_1-6题
04-27
在“西北工业大学数据结构noj_1-6题”中，我们可以推测这是一系列与数据结构相关的编程练习题目，旨在帮助学生理解和应用各种数据结构。以下是基于这些题目可能涵盖的一些关键知识点的详细解释： 1. **线性数据结构...
NOJ--宠物小精灵之收服（01背包，二维费用背包问题）
with_wine的博客
11-01 168
宠物小精灵之收服 1000ms65536K Description: 宠物小精灵是一部讲述小智和他的搭档皮卡丘一起冒险的故事。 一天，小智和皮卡丘来到了小精灵狩猎场，里面有很多珍贵的野生宠物小精灵。小智也想收服其中的一些小精灵。然而，野生的小精灵并不那么容易被收服。对于每一个野生小精灵而言，小智可能需要使用很多个精灵球才能收服它，而在收服过程中，野生小精灵也会对皮卡丘造成一定的伤害（从而减少皮卡丘的体力）。当皮卡丘的体力小于等于0时，小智就必须结束狩猎（因为他需要给皮卡丘疗伤），而使得皮...
【数据结构】NOJ002 线性表的就地逆置（耿2.9）
weixin_45932570的博客
03-25 386
1. 题目 2. 代码 #include <iostream> #include <malloc.h> using namespace std; typedef struct node{ int data; node* next; }Node; void readnum(int n, int* a, Node* head); void reverseArray(int* a, int n); void reverseList(Node* head); void outpu
西工大数据结构NOJ002：线性表的就地逆置
weixin_46050731的博客
06-16 698
西工大数据结构NOJ002：线性表的就地逆置 一个顺序表类和一个链表类，顺序表中使用一个Reverse函数，作用是完成顺序表的逆序 而在链表中，在main函数里面输入数据的过程中，我直接使用了头插法创建链表，所以得到的链表就是逆序的 #include <iostream> using namespace std; #define MAXSIZE 200 struct SqList{ int elem[MAXSIZE]; int length; SqList(int len
数据结构noj002线性表的就地逆置
qq_32787973的博客
03-21 277
数据结构noj002线性表的就地逆置
从头开始嵌入式第三十八天（数据结构 双向链表）
qq_64792908的博客
09-11 673
2. 相比单向链表，双向链表在某些操作上更加灵活，比如在删除节点时，可以快速找到前驱节点进行调整，而单向链表需要从头开始遍历才能找到前驱节点。1. 每个节点包含两个指针，分别指向直接前驱节点和直接后继节点。这使得在双向链表中可以双向遍历，既可以向前也可以向后查找节点。1. 插入操作：可以快速确定插入位置的前后节点，进行指针调整，实现高效的插入操作。1. 需要频繁进行前后遍历的场景，如文本编辑器中对字符的双向移动和操作。2. 删除操作：由于能够直接访问前驱节点，删除操作也更加方便快捷。
【华为OD】2024D卷——生成哈夫曼树
weixin_45653183的博客
09-12 1377
这是通过构建一种特殊的二叉树来实现的，其中每个字符都位于树的一个叶节点上，且该叶节点到根节点的路径上的边所代表的字符（在哈夫曼编码中通常使用0和1表示）共同构成了该字符的编码。·新节点作为这两个子节点的父节点，而原来的两个节点则成为新节点的左右子节点（通常约定左子节点频率小于等于右子节点）。2、不断从堆中取出两个最小的节点作为左右子树，构造一个新的父节点，其权值为两个节点权值之和，并将新节点插入堆中。·然后，算法反复地选择两个频率最小的节点，将它们合并为一个新的节点，新节点的频率是两个子节点频率之和。
【JavaScript】数据结构之字典 & 哈希表
票票的博客
09-14 576
数据结构之字典和哈希表
数据结构—队列
最新发布
2301_80151359的博客
09-17 300
QueueNode;int size;//保存队列有效数据个数}Queue;初始化队列。
西工大NOJ数据结构实验——3.1哈夫曼
05-24
然后，对于每个字符，从根节点出发，沿着对应的路径到达该字符所在的叶子节点，记录下路径，作为该字符的编码。 哈夫曼编码的具体实现步骤如下： 1. 统计每个字符在原始数据中出现的频率。 2. 根据字符的频率构建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值