线性表练习之Example008-移动顺序表中小于和大于表头的元素

最新推荐文章于 2023-08-12 17:26:54 发布
最新推荐文章于 2023-08-12 17:26:54 发布
阅读量481 收藏 5
点赞数
分类专栏： 数据结构 文章标签： java c 数据结构 顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123784554
版权

Example008

原文链接：Example008

题目

有一个顺序表 L，其元素为整型数据，设计一个算法，将 L 中所有小于表头元素的整数放在前半部分，大于表头元素的整数放在后半部分。

分析

本题考查的知识点：

  • 顺序表
  • 双指针
  • 交换两个变量的值

分析：

  • 定义一个局部变量 head 保存表头元素，再定义两根指针 i 和 j 指向顺序表中的第一个元素和最后一个元素。
  • 当 i 不等于 j 时进行循环，然后进行逻辑处理。
  • 在循环中当指针 i 所指向的顺序表元素小于表头元素 head 时则不断移动 i 指针，从前往后移动。直到遇到大于或等于表头元素 head 时结束移动。
  • 在循环中当指针 j 所指向的顺序表元素大于表头元素 head 时则不断移动 j指针，从后往前移动。直到遇到小于或等于表头元素 head 时结束移动。
  • 此时，指针 i 所指向的顺序表元素大于或等于表头元素，指针 j 所指向的顺序表元素小于或等于表头元素，那么交换它们所对应的值。
  • 交换完成后，继续下一轮循环移动，直到 i 不等于 j结束外层循环。

注意：

  • 指针 i 和指针 j 所表示的循环，以及交换它们的值，都要求 i<j，因为在移动过程中 i 和 j 都很可能移动过界（大于顺序表长度或小于 0），所以必须进行限制。
  • 外层循环结束的条件是 i>=j，即当 i==j 时就会结束循环，因为此时顺序表中小于表头的元素已经被放到了前半部分，而大于表头的元素已经被放到了后半部分，因此结束循环。

图解

以 [2, 1, -7, -3, 5, 6, -1]为例：
请添加图片描述

C实现

核心代码：

/**
 * 移动顺序表中的元素，将小于表头的元素放到前半部分，将大于表头的元素放到后半部分
 * @param list 顺序表
 */
void move(SeqList *list) {
    // 顺序表的表头元素
    int head = list->data[0];
    // 定义两根指针，分别指向顺序表中的第一个元素和最后一个元素
    int i = 0;// 指针 i 从前往后移动
    int j = list->length - 1;// 指针 j 从后往前移动

    // 当 i==j 时结束循环
    while (i < j) {
        // 从前往后移动，遇到第一个比你表头元素大的整数停止，注意 i<j 是必须的，因为指针 i 在不断增加过程中可能会大于 j 甚至超出顺序表的边界范围，导致出错
        while (i < j && list->data[i] < head) {
            // 如果遇到比表头元素小的整数，则 i 指针不断前进，直到遇到第一个比你表头元素大的整数停止
            i++;
        }
        // 从后往前移动，遇到第一个比表头元素小的整数停止
        while (i < j && list->data[j] > head) {
            // 如果遇到比表头元素大的整数，则 j 指针不断前进，直到遇到第一个比你表头元素小的整数停止
            j--;
        }
        // 当 i 遇到第一个比表头元素大的整数，j 遇到第一个比表头元素小的整数，则交换 i 和 j所表示的元素值
        if (i < j) {
            // 交换 data[i] 和 data[j] 的值
            int temp = list->data[i];
            list->data[i] = list->data[j];
            list->data[j] = temp;
        }
    }
}

完整代码：

#include <stdio.h>

#define MAXSIZE 20

/**
 * 顺序表的结构体
 */
typedef struct {
    /**
     * 顺序表，实际上一个长度为 MAXSIZE 的数组，存储的数据类型为整型，当然可以设置为其他类型，但推荐使用宏定义类型，方便替换
     */
    int data[MAXSIZE];
    /**
     * 顺序表长度，即数组中实际元素个数
     */
    int length;
} SeqList;

/**
 * 初始化顺序表，仅需要将 length 置为 0 即可
 * @param list 待初始化的顺序表
 */
void init(SeqList *list) {
    // 仅需要将 length 置为 0 即可
    (*list).length = 0;
    // 或者可以用下面的语法
    // list->length=0;
}

/**
 * 直接添加新元素到顺序表的尾部
 * @param list 顺序表
 * @param ele 待添加的新元素
 * @return 如果插入成功则返回 1，否则返回 0
 */
int add(SeqList *list, int ele) {
    // 0.校验
    // 0.1 向顺序表中插入元素要检查顺序表是否已经满了，如果已经满了则不能再插入新元素则添加失败
    if (list->length == MAXSIZE) {
        return 0;
    }
    // 1.插入新元素
    // 1.1 直接获取顺序表的 length，然后将新元素的值赋予到 length 位置即可
    list->data[list->length] = ele;
    // 1.2 注意修改 length
    list->length++;
    return 1;
}

/**
 * 移动顺序表中的元素，将小于表头的元素放到前半部分，将大于表头的元素放到后半部分
 * @param list 顺序表
 */
void move(SeqList *list) {
    // 顺序表的表头元素
    int head = list->data[0];
    // 定义两根指针，分别指向顺序表中的第一个元素和最后一个元素
    int i = 0;// 指针 i 从前往后移动
    int j = list->length - 1;// 指针 j 从后往前移动

    // 当 i==j 时结束循环
    while (i < j) {
        // 从前往后移动，遇到第一个比你表头元素大的整数停止，注意 i<j 是必须的，因为指针 i 在不断增加过程中可能会大于 j 甚至超出顺序表的边界范围，导致出错
        while (i < j && list->data[i] < head) {
            // 如果遇到比表头元素小的整数，则 i 指针不断前进，直到遇到第一个比你表头元素大的整数停止
            i++;
        }
        // 从后往前移动，遇到第一个比表头元素小的整数停止
        while (i < j && list->data[j] > head) {
            // 如果遇到比表头元素大的整数，则 j 指针不断前进，直到遇到第一个比你表头元素小的整数停止
            j--;
        }
        // 当 i 遇到第一个比表头元素大的整数，j 遇到第一个比表头元素小的整数，则交换 i 和 j所表示的元素值
        if (i < j) {
            // 交换 data[i] 和 data[j] 的值
            int temp = list->data[i];
            list->data[i] = list->data[j];
            list->data[j] = temp;
        }
    }
}

/**
 * 打印顺序表
 * @param list 待打印的顺序表
 */
void print(SeqList list) {
    printf("[");
    for (int i = 0; i < list.length; i++) {
        printf("%d", list.data[i]);
        if (i != list.length - 1) {
            printf(", ");
        }
    }
    printf("]\n");
}

int main() {
    // 声明顺序表并初始化
    SeqList list;
    init(&list);

    // 为顺序表添加一些测试数据
    add(&list, 2);
    add(&list, 1);
    add(&list, -7);
    add(&list, -3);
    add(&list, 5);
    add(&list, 6);
    add(&list, -1);
    print(list);

    // 移动顺序表中的元素，将小于表头的元素放到前半部分，将小于表头的元素放到后半部分
    move(&list);
    print(list);
}

执行结果：

[2, 1, -7, -3, 5, 6, -1]
[-1, 1, -7, -3, 2, 6, 5]

Java实现

核心代码：

    /**
     * 移动顺序表中的元素，将小于表头的元素放到前半部分，将大于表头的元素放到后半部分
     */
    public void move() {
        // 存储表头元素
        int head = list.data[0];
        // 定义两根指针，分别指向顺序表中的第一个元素和最后一个元素
        int i = 0;// 指针 i 从前往后移动
        int j = list.length - 1;// 指针 j 从后往前移动

        // 当 i==j 时结束循环
        while (i < j) {
            // 从前往后移动，遇到第一个比你表头元素大的整数停止，注意 i<j 是必须的，因为指针 i 在不断增加过程中可能会大于 j 甚至超出顺序表的边界范围，导致出错
            while (i < j && list.data[i] < head) {
                // 如果遇到比表头元素小的整数，则 i 指针不断前进，直到遇到第一个比你表头元素大的整数停止
                i++;
            }
            // 从后往前移动，遇到第一个比表头元素小的整数停止
            while (i < j && list.data[j] > head) {
                // 如果遇到比表头元素大的整数，则 j 指针不断前进，直到遇到第一个比你表头元素小的整数停止
                j--;
            }
            // 当 i 遇到第一个比表头元素大的整数，j 遇到第一个比表头元素小的整数，则交换 i 和 j所表示的元素值
            if (i < j) {
                // 交换 data[i] 和 data[j] 的值
                int temp = list.data[i];
                list.data[i] = list.data[j];
                list.data[j] = temp;
            }
        }
    }

完整代码：

/**
 * @author lcl100
 * @desc 线性表
 * @create 2022-02-28 20:16
 */
public class SeqList {
    /**
     * 顺序表最大能存放元素个数
     */
    private final int MAXSIZE = 20;

    /**
     * 声明的顺序表，未初始化
     */
    private List list;

    /**
     * 初始化顺序表
     */
    public void init() {
        list = new List();
        // 指定数据数组长度为 MAXSIZE
        list.data = new int[MAXSIZE];
        // 但指定顺序表实际元素个数为 0
        list.length = 0;
    }

    /**
     * 直接添加新元素到顺序表的尾部
     *
     * @param ele 待插入的新元素
     */
    public void add(int ele) throws Exception {
        // 0.校验
        // 0.1 向顺序表中插入元素要检查顺序表是否已经满了，如果已经满了则不能再插入新元素则抛出异常
        if (list.length == MAXSIZE) {
            throw new Exception("顺序表已满，不能再插入了！");
        }
        // 1.插入新元素
        // 1.1 直接获取顺序表的 length，然后将新元素的值赋予到 length 位置即可
        list.data[list.length] = ele;
        // 1.2 注意修改 length
        list.length++;
    }

    /**
     * 移动顺序表中的元素，将小于表头的元素放到前半部分，将大于表头的元素放到后半部分
     */
    public void move() {
        // 存储表头元素
        int head = list.data[0];
        // 定义两根指针，分别指向顺序表中的第一个元素和最后一个元素
        int i = 0;// 指针 i 从前往后移动
        int j = list.length - 1;// 指针 j 从后往前移动

        // 当 i==j 时结束循环
        while (i < j) {
            // 从前往后移动，遇到第一个比你表头元素大的整数停止，注意 i<j 是必须的，因为指针 i 在不断增加过程中可能会大于 j 甚至超出顺序表的边界范围，导致出错
            while (i < j && list.data[i] < head) {
                // 如果遇到比表头元素小的整数，则 i 指针不断前进，直到遇到第一个比你表头元素大的整数停止
                i++;
            }
            // 从后往前移动，遇到第一个比表头元素小的整数停止
            while (i < j && list.data[j] > head) {
                // 如果遇到比表头元素大的整数，则 j 指针不断前进，直到遇到第一个比你表头元素小的整数停止
                j--;
            }
            // 当 i 遇到第一个比表头元素大的整数，j 遇到第一个比表头元素小的整数，则交换 i 和 j所表示的元素值
            if (i < j) {
                // 交换 data[i] 和 data[j] 的值
                int temp = list.data[i];
                list.data[i] = list.data[j];
                list.data[j] = temp;
            }
        }
    }

    /**
     * 打印顺序表
     */
    public void print() {
        String str = "[";
        for (int i = 0; i < list.length; i++) {
            str += list.data[i];
            if (i != list.length - 1) {
                str += ", ";
            }
        }
        str += "]";
        System.out.println(str);
    }
}

/**
 * 顺序表
 */
class List {
    /**
     * 数据域，保存数据的数组
     */
    int[] data;
    /**
     * 数组中实际元素个数
     */
    int length;
}

测试代码：

/**
 * @author lcl100
 * @desc 顺序表测试类
 * @create 2022-02-28 20:18
 */
public class SeqListTest {
    public static void main(String[] args) throws Exception {
        // 创建顺序表并初始化
        SeqList list = new SeqList();
        list.init();

        // 添加一些测试数据
        list.add(2);
        list.add(1);
        list.add(-7);
        list.add(-3);
        list.add(5);
        list.add(6);
        list.add(-1);
        list.print();

        // 移动顺序表中的元素，将小于表头的元素放到前半部分，将小于表头的元素放到后半部分
        list.move();
        list.print();
    }
}

执行结果：

[2, 1, -7, -3, 5, 6, -1]
[-1, 1, -7, -3, 2, 6, 5]
二木成林
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021-09-23
liusir_M的博客
09-24 585
顺序表按分界线排列 设顺序表L有10个整数。设计一个算法，以第一个元素为分界线（基准），将所有小于等于它的元素移到该元素的前面，将所有大于它的元素移到该元素的后面。 一.前后同时交换法 输入样例： 10 3 8 2 7 1 5 3 4 6 0 输出样例： 1 0 2 3 3 5 7 4 6 8 #include <stdio.h> #include <malloc.h> struct Ming { int data[10000]; int last; }; struct Min
数据结构学习--线性表及其应用--顺序表
06-25
线性表按存储结构分，可 分为顺序表和链表，它们各有特色。本程序主要目的在于帮助同学熟练掌握线性表的基本 操作在顺序存储结构上的实现，顺序表的优点是可以实现随机存取，用数组对其进行定义， 主要操作时针对...
顺序表--以第一个元素为分界线（基准）， 将所有小于等于它的元素移到该元素的前面,将所有大于它的元素移到该元素的后面
weixin_43486985的博客
07-27 6648
/* 设顺序表L有10个整数。 设计一个算法，以第一个元素为分界线（基准）， 将所有小于等于它的元素移到该元素的前面,将所有大于它的元素移到该元素的后面 */ #include<stdio.h> #include <time.h> #include<stdlib.h> typedef struct { int data[100]; int lengt...
考研数据结构之线性表（1.7）——练习题之将顺序表中所有小于表头元素的整数放在前半部分所有大于表头元素的整数放在后半部分（C表示）
二木成林
05-25 1476
题目 有一个顺序表L，其元素为整型数据，设计一个算法，将L中所有小于表头元素的整数放在前半部分，大于表头元素的整数放在后半部分。 分析 遍历顺序表L中的所有元素，将其与表头元素比较，如果小于表头元素，则从该元素位置开始，将其之前的所有元素向后移动一个位置，并将该元素放入移动后的空位（也可以说是表头位置）。 核心代码： /* 移动元素将L中所有小于表头元素的整数放在前半部分，大于表头元素的放在后半部分（注意：没有考虑与表头元素相等的元素） */ /* L[]指的是要移动的顺序表；m指的是顺
数据结构|以第一个元素为分界线（基准），将所有小于等于它的元素移到该基准的前面，将大于它的移到该基准的后面
jingling555的博客
01-13 1347
可以从顺序表的两端开始扫描，左边扫描到小于等于基准则跳过不移动，大于基准的则与当前右边下标为j的交换，右边扫描到大于基准则跳过不移动，小于等于基准的则与当前左边下标为i的交换。有一个顺序表L，假设元素类型ElemType为整型，以第一个元素为分界线（基准），将所有小于等于它的元素移到该基准的前面，将大于它的移到该基准的后面。以下用了两种方法来做这题，这两种方法的时间复杂度都是O(n),空间复杂度是O(1),但使用方法二会更好，因为第2个算法中移动元素的次数更少。
第三周实践项目8 以第一个元素为分界线，将所有小于它的元素移到该元素的前面，将所有大于它的元素移到该元素的后面。
sxy201658506207的博客
10-27 2462
设顺序表有10个元素，其元素类型为整型。设计一个算法，以第一个元素为分界线，将所有小于它的元素移到该元素的前面，将所有大于它的元素移到该元素的后面。  　　设计出的算法是： #include #include #define MaxSize 100 typedef int ElemType; typedef struct { ElemType data[MaxSize];
有一个顺序表L，其元素为整形数据，设计一个算法，将L中的所有小于表头元素的整数放在前半部分，大于表头元素的整数放在后半部分
W25679的博客
07-30 4232
题目 有一个顺序表L，其元素为整形数据，设计一个算法，将L中的所有小于表头元素的整数放在前半部分，大于表头元素的整数放在后半部分 解答（天勤） /****************************************************************************** Online C++ Compiler. Code, Compile, Run and Debug ..
线性表--顺序表中将所有小小于0的整数移到大于0的前面
编码日常
03-23 7060
将所有小小于0的元素移到大于0的前面 #include #include using namespace std; #define MaxSize 10 typedef int ElemType; typedef struct { ElemType data[MaxSize]; int length; }SqList; void InitiList(SqList *&L,E
数据结构与算法c++实现 删除顺序表中大于x的元素
06-04
数据结构与算法c++实现 删除顺序表中大于x的元素 可直接运行 适合初学数据结构与算法大二学生
线性表--顺序表操作
12-12
这有线性表的操作:顺序存储,链存储结构, 单链表,顺序表,循环链表,双向链表
MyBatis example
12-09
基于MyBatis3.0.3操作mySql数据库的简单示例。综合了各种xml文件的配置。和以往的ibatis配置有所不同。非常适合初学者入门。
数据结构2-线性表之顺序储存（顺序表）C语言版
10-21
代码对应的博客：https://blog.csdn.net/u011017694/article/details/109196934
C语言_线性表之顺序表
01-16
C语言实现顺序表，代码约200行，附赠测试案例(带菜单选择功能) 实现的操作： 1，头插、尾插、指定位置插 2，头删、尾删、指定位置和元素删除 3，求大小、判断是否为NULL 4，排序、查找、翻转
MyBatis逆向工程教程（含Example讲解）
辛聪明的博客
09-18 1331
插件方式构建逆向工程 1.搭建 MyBatis Generator插件环境 1. 添加插件依赖 pom.xml <!--mybatis 逆向生成插件--> <plugin> <groupId>org.mybatis.generator</groupId> ...
对顺序表L中所有小于表头元素的整数放在前半部分，大于表头元素的整数放在后半部分
qq_43648337的博客
07-21 642
要求：对顺序表L中所有小于表头元素的整数放在前半部分，大于表头元素的整数放在后半部分 算法思想：快速排序*/ void quicksort(SqList &L) { int i,j; i = 0,j = L.length-1;//分别指向表头和表尾 int temp = L.data[0]; while(i<j) { while(i<j && L.data[j]>=temp)//从右往左走，遇到比temp小的元素时
Spring Data JPA进阶（四）：Example查询
热门推荐
程铭程铭你快成名的博客
06-24 1万+
Example查询翻译过来叫“按例查询（QBE）”。是一种用户界面友好的查询技术。 它允许动态创建查询，并且不需要编写包含字段名称的查询。 而且按示例查询不需要使用特定的数据库的查询语言来编写查询语句。 官方文档有一个优劣势的说明： 优势： 可以使用动态或者静态的限制去查询 在重构你的实体的时候，不用担心影响到已有的查询 可以独立地工作在数据查询API之外 劣势： 不支持组合查询，比如：fi...
Example 对象可以设置的查询条件
最难不过坚持，与你共同进步
08-12 943
andCondition(String condition)：根据自定义的条件表达式添加条件。这些示例涵盖了 tk.mybatis.mapper.entity.Example 对象的常见查询条件设置。你可以根据具体需求，选择适合的方法和组合来构建查询条件，从而更轻松地执行数据库查询操作。
mybatis的逆向工程中创建的Example类的作用 在代码中用于添加条件 大于小于转义
CHANGJIATENG的博客
08-06 691
在平常的开发中，有时会使用mybatis的逆向工程，来快速的创建类，其中在创建实例的过程中有一个以Example结尾的类， 这个类是专门用来对这个单表来查询的类，就相当于，对该单表的增删改查是脱离sql性质的，直接在service 层就可以完成（当然这个sql是逆向已经生过的） ------------------------------------------------------------------------------------ Mybatis逆向工程会生成实例及实例对应的exampl
考研数据结构之查找（9.8）——练习题之将关键字序列{7,8,30,11,18,9,14}散列存储到散列表中（C表示）
二木成林
06-09 1万+
题目 将关键字序列{7,8,30,11,18,9,14}散列存储到散列表中,散列表的存储空间是一个下标从0开始的一维数组，散列函数为H(key)=(key*3) Mod 7，处理冲突采用线性探测再散列法，要求装填因子为0.7. （1）请画出所构造的散列表。 （2）分别计算等概率情况下，查找成功和查找不成功时的平均查找长度。 分析 ...
线性表插入一个元素 - 顺序存储
最新发布
09-06
线性表插入一个元素的顺序存储实现可以通过以下步骤完成： 1. 首先，判断线性表是否已满。因为顺序存储需要预先分配一定大小的内存空间来存储元素，如果线性表已满，则无法插入新元素。 2. 如果线性表未满，则需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值