考研王道数据结构-顺序表(综合应用1)

本节代码主要来自王道单科18页的综合应用题。

一、18页第1题。从顺序表中删除具有最小值的元素(假设唯一)并由函数返回被删元素的值。空出的位置由最后一个元素填补,若顺序表为空则显示出错信息并退出运行 。

核心代码:
 bool DeleteMinElem(Sqlist &L,ElemType &value){
// 18页第1题。从顺序表中删除具有最小值的元素(假设唯一)并由函数返回被删元素的值。
//空出的位置由最后一个元素填补,若顺序表为空则显示出错信息并退出运行
    if(L.length==0){
        printf("顺序表为空");
        return 0;
    }
    int pos=0;
    value=L.data[0];
    for(int i=1;i<L.length;i++){
        if(L.data[i]<value){
            value=L.data[i];
            pos=i;
        }
    }
    L.data[pos]=L.data[L.length-1];
    L.length--;
    return 1;
}
 

二、18页第2题。设计一个高效的算法,将顺序表的所有元素逆置,要求算法的空间复杂度为O(1)

核心代码:

可以有两种方式:

第一种:定义两个循环指针i,j,其中i向后遍历,j向前遍历,这种更好记忆。

void Reverse(Sqlist &L){
    int i,j;
    ElemType temp;
    for(i=0,j=L.length-1;i<j;i++,j--){
        temp=L.data[i];
        L.data[i]=L.data[j];
        L.data[j]=temp;
    }
}

第二种:j没有定义出来,用i和L.length(即L.length-i-1)的关系来表示其对称位置。

void Reverse2(Sqlist &L){
    int i;
    ElemType temp;
    for(i=0;i<L.length/2;i++){
        temp=L.data[i];
        L.data[i]=L.data[L.length-i-1];
        L.data[L.length-i-1]=temp;
    }
}

三、18页第3题。删除线性表中所有值为x的元素。要求时间复杂度O(n),空间复杂度O(1)。

核心代码:

可以有三种方式:

第一种:遍历时统计等于x的个数count,将不等于x的元素向前移动count个位置。 

void DeleteElemX1(Sqlist &L,ElemType x){
    int count=0;//计算元素等于x的个数
    for(int i=0;i<L.length;i++){
        if(L.data[i]==x)
            count++;
        else
            L.data[i-count]=L.data[i];
    }
    L.length-=count;
}

第二种:把不等于x的元素重新覆盖,个数为count。
此处count起到了统计不等于x的个数(即剩余元素的个数),也起到了覆盖元素时的遍历作用。

void DeleteElemX2(Sqlist &L,ElemType x){
    int count=0;//这次是计算不等于x的个数
    for(int i=0;i<L.length;i++){
        if(L.data[i]!=x){
            L.data[count]=L.data[i];
            count++; //注意这一句要在后面,因为覆盖元素位置从0开始。
        }
    }
    L.length=count;  //这句不要忘了。
} 

第三种:用头尾两个指针i,j从两端向中间移动,凡遇到左端值x的元素时,直接将最右端值非x的元素左移至值为x的数据元素位置,直到两指针相遇。

但这种方法会改变原表元素的相对位置。不推荐。就暂时不写了。

以下是以上三道题的全部测试代码(可直接运行):

#include<stdio.h>
#define true 1
#define false 0
#define MaxSize 100          //定义线性表的最大长度
#define ElemType int
#define Status int 

typedef struct{
    ElemType data[MaxSize];        //动态分配数组的指针
    int length;            //当前个数
}Sqlist;

//构造一个空的线性表L
void InitList(Sqlist &L){
    L.length=0;
}

bool ListInsert(Sqlist &L,int i,ElemType e){
//将元素e插到顺序表L中第i个位置
    if(i<1||i>L.length+1)
        return false;
    if(L.length>=MaxSize)
        return false;
    for(int j=L.length;j>=i;j--)
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;
    L.length++;
    return true;
}

void ListLoad(Sqlist L){
    if(L.length==0){
        printf("当前顺序表为空\n");
        return;
    }
    printf("当前顺序表元素为:");
    for(int i=0;i<L.length;i++)
        printf("%d ",L.data[i]);
    printf("\n");
    return;
}

// 18页第1题。从顺序表中删除具有最小值的元素(假设唯一)并由函数返回被删元素的值。
//空出的位置由最后一个元素填补,若顺序表为空则显示出错信息并退出运行
bool DeleteMinElem(Sqlist &L,ElemType &value){
    if(L.length==0){
        printf("顺序表为空");
        return 0;
    }
    int pos=0;
    value=L.data[0];
    for(int i=1;i<L.length;i++){
        if(L.data[i]<value){
            value=L.data[i];
            pos=i;
        }
    }
    L.data[pos]=L.data[L.length-1];
    L.length--;
    return 1;
}

void Reverse1(Sqlist &L){
//18页第2题。设计一个高效的算法,将顺序表的所有元素逆置,要求算法的空间复杂度为O(1)
    int i,j;
    ElemType temp;
    for(i=0,j=L.length-1;i<j;i++,j--){
        temp=L.data[i];
        L.data[i]=L.data[j];
        L.data[j]=temp;
    }
}

void Reverse2(Sqlist &L){
//18页第2题。设计一个高效的算法,将顺序表的所有元素逆置,要求算法的空间复杂度为O(1)
    int i;
    ElemType temp;
    for(i=0;i<L.length/2;i++){
        temp=L.data[i];
        L.data[i]=L.data[L.length-i-1];
        L.data[L.length-i-1]=temp;
    }
}

//遍历时统计等于x的个数count,将不等于x的元素向前移动count个位置。
void DeleteElemX1(Sqlist &L,ElemType x){
    int count=0;//计算元素等于x的个数
    for(int i=0;i<L.length;i++){
        if(L.data[i]==x)
            count++;
        else
            L.data[i-count]=L.data[i];
    }
    L.length-=count;
}

//把不等于x的元素重新覆盖,个数为count。
//此处count起到了统计不等于x的个数(即剩余元素的个数),也起到了覆盖元素时的遍历作用。
void DeleteElemX2(Sqlist &L,ElemType x){
    int count=0;//这次是计算不等于x的个数
    for(int i=0;i<L.length;i++){
        if(L.data[i]!=x){
            L.data[count]=L.data[i];
            count++; //注意这一句要在后面,因为覆盖元素位置从0开始。
        }
    }
    L.length=count;  //这句不要忘了。
} 

int main(){
    Sqlist T;
    ElemType min;
    ElemType e;
    int a;
    InitList(T);
    ListInsert(T,1,4);
    ListInsert(T,1,3);
    ListInsert(T,1,6);
    ListInsert(T,2,1);
    ListInsert(T,2,8);
    ListInsert(T,2,8);
    ListInsert(T,2,9);
    ListLoad(T);
    while(1){
        printf("1:删除最小元素\n");  //DeleteMinElem
        printf("2:所有元素逆置(方法1)\n");   //Reverse1
        printf("3:所有元素逆置(方法2)\n");  //Reverse2
        printf("4:删除值等于x的所有元素(方法1)\n");   //DeleteElemX1
        printf("5:删除值等于x的所有元素(方法2)\n");   //DeleteElemX2
        printf("请选择:");
        scanf("%d",&a);
        switch(a){
            case 1:if(DeleteMinElem(T,min)) printf("成功删除最小元素%d\n",min);
                    else printf("删除失败\n");
                    break;
            case 2:Reverse1(T);
                    break;
            case 3:Reverse2(T);
                    break;
            case 4:scanf("%d",&e);
                    DeleteElemX1(T,e);
                    break;
            case 5:scanf("%d",&e);
                    DeleteElemX2(T,e);
                    break;
            default:return 1;
        }
        ListLoad(T);
    }
}

删除最小元素:

顺序表逆置:

删除值等于x的所有元素:

原文地址:https://www.cnblogs.com/double891/p/9125242.html

时间: 2024-10-09 08:51:06

考研王道数据结构-顺序表(综合应用1)的相关文章

hrbust-1545-基础数据结构——顺序表(2)

http://acm.hrbust.edu.cn/index.php?m=ProblemSet&a=showProblem&problem_id=1545 基础数据结构——顺序表(2) Time Limit: 1000 MS Memory Limit: 10240 K Total Submit: 412(165 users) Total Accepted: 188(150 users) Rating:  Special Judge: No Description 在长度为n(n<10

考研数据结构-顺序表(综合应用3)-合并顺序表

本节代码主要来自王道单科18页的综合应用题. 七.将两个有序顺序表合并成一个新的有序顺序表,并由函数返回结果顺序表 易忘点:合并以前需要先判断一下是否大于C的最大长度. 核心代码: bool merge(Sqlist A,Sqlist B,Sqlist &C){ if(A.length+B.length>MaxSize) return false; //容易忘记 int i=0,j=0,k=0; while(i<=A.length-1&&j<=B.length-1

王道数据结构——线性表中顺序表的一些综合应用题

1.长度为n的顺序表中,编写一个时间复杂度为O(n),空间复杂度为O(1)的算法,用于删除线性表中所有值为x的数据元素.(满足要求的数放在第k位上) 1 #include <cstdio> 2 3 /*输出数组名为a.长度为n的数组*/ 4 void print(int *a, int n){ 5 for(int i = 0;i < n; i++){ 6 printf("%d ", a[i]); 7 } 8 puts(""); 9 } 10 11

数据结构顺序表思想以及完整代码实现

本文转载自趣学算法,方便个人学习参考使用 http://blog.csdn.net/rainchxy/article/details/77946835 数据结构 第3讲 顺序表 顺序表是最简单的一种线性结构,逻辑上相邻的数据在计算机内的存储位置也是相邻的,可以快速定位第几个元素,中间不允许有空,所以插入.删除时需要移动大量元素. 顺序表可以分配一段连续的存储空间Maxsize,用elem记录基地址,用length记录实际的元素个数,即顺序表的长度, 结构体的定义: 结构体定义后,如果要定义个顺序

数据结构----顺序表的增和遍历(2018/10/23)

数据结构包含顺序表和链表 顺序表方便改和查 链表便于增删 顺序表的增和遍历: 代码一: 1 using System; 2 namespace deaiWith 3 { 4 class MySeqList<T> 5 { 6 //实际的元素个数 7 private int _flag; 8 //存储的空间 9 private T[] _ints; 10 public void AddItem(T Item) //增加元素到末尾 ,追加 11 { 12 if (_flag >= _ints.

8.基本数据结构-顺序表和链表

一.内存 - 计算机的作用:对数据进行存储和运算.首先我们需要知道我们目前使用的计算机都是二进制的计算机,就以为着计算机只可以存储和运算二进制的数据.例如下载好的一部电影,该电影可以存储到计算机中,计算机中存储的是基于二进制的电影数据,然后我们可以通过相关的视频播放软件结合相关的硬件对电影的二进制数据进行相关的运算操作,所产生的结果就是我们可以看到电影的画面和听到音频的声音. - 问题:阐述计算机如何计算1+2的结果? - 阐述:简单理解为,首先可以将1和2输入到计算机中,然后计算机会将1和2转

数据结构----顺序表与单链表(JAVA)

下面为学习顺序表和单链表的一些基本操作函数: 1 public class SeqList<T> extends Object { 2 protected int n; 3 protected Object[] element; 4 5 public SeqList(int length) { 6 this.element = new Object[length]; 7 this.n = 0; 8 } 9 10 public SeqList() { 11 this(64); 12 } 13 1

数据结构——顺序表的实现

/* 线性结构的基本特征: 1. 集合中必存在唯一的一个"第一元素" 2. 集合中必存在唯一的一个"最后元素" 3. 除最后元素之外,均有唯一的后继 4. 除第一元素之外,均有唯一的前驱 对线性表的基本操作: {结构初始化} InitList(&L); //构造一个空的线性表L {结构的销毁} DestroyList(&L); //销毁线性表L {引用型操作} ListEmpty(L); //线性表判空 ListLength(L); //返回线性表长

数据结构顺序表的操作全集(创建,遍历,插入,删除,排序等等)

#include"stdio.h" #include"stdlib.h" #include"malloc.h" #define list_size 100 typedef struct Node { int data[list_size]; int len; }NODE,* PNODE; void creat_list(PNODE L) { int i; int val; int len; /* PNODE L=(PNODE)malloc(siz