C：二维数组常用操作

/*
说明:程序实现二维数组中插入列、插入行、交换两个指定位置的元素，并输出指定
位置元素的变化轨迹
作者:socrates
日期:2014-08-17
*/

#include "stdafx.h"
#include <stdlib.h>
#include <assert.h>

/*二维数组最大行数和列数*/
#define MAX_ROW_NUM (9)
#define MAX_COL_NUM (9)

/*二维数组中各元素位置信息*/
typedef struct _PathNode
{
    int x;  /*行*/
    int y;  /*列*/
}Node;

/*各元素内容(表示位置轨迹的链表)*/
typedef struct _PathNodeList
{
    Node node;
    _PathNodeList *pNext;
}PathNodeList;

/*表示二维数组有效的行列数*/
typedef struct _CurRowColNum
{
    int iArrayRow;
    int iArrayCol;
}CurRowColNum;

/*二维数组行列数*/
static CurRowColNum g_stRowColNum = {0};

/*二维数组定义*/
PathNodeList* g_pGrid[MAX_ROW_NUM][MAX_COL_NUM];

/*错误码*/
enum _RetCode
{
    ERR = -1, /*失败*/
    OK = 0    /*成功*/
}RETCODE;

/*设置当前数组行列数*/
void SetRowAndColNum(int iRow, int iCol)
{
    g_stRowColNum.iArrayRow = iRow;
    g_stRowColNum.iArrayCol = iCol;
}

/*获取数组行列数*/
CurRowColNum getRowAndColNum()
{
    return g_stRowColNum;
}

/*创建轨迹链表，不带头结点*/
int CreatePathNodelist(PathNodeList *&pList, Node *pPathNode)
{
    if (NULL == pPathNode)
    {
        return ERR;
    }

    pList = (PathNodeList *)malloc(sizeof(PathNodeList));
    if (NULL == pList)
    {
        return ERR;
    }
    pList->node.x = pPathNode->x;
    pList->node.y = pPathNode->y;
    pList->pNext = NULL;

    return OK;
}

/*销毁轨迹链表*/
int DestoryPathNodelist(PathNodeList *pList)
{
    if (NULL == pList)
    {
        return ERR;
    }

    PathNodeList *p = pList;
    while (NULL != p->pNext)
    {
        p = p->pNext;
        free(pList);
        pList = p;
    }
    free(pList);
    pList = NULL;

    return OK;
}

/*向轨迹链表中插入当前结点所在位置*/
int InsertPathNodeList(PathNodeList *pPathNodeList, Node *pPathNode)
{
    if ((NULL == pPathNodeList)
        || (NULL == pPathNode))
    {
        return ERR;
    }

    PathNodeList *pNewPathNode = (PathNodeList *)malloc(sizeof(PathNodeList));
    if (NULL == pPathNode)
    {
        return ERR;
    }

    pNewPathNode->node.x = pPathNode->x;
    pNewPathNode->node.y = pPathNode->y;
    pNewPathNode->pNext = NULL;

    PathNodeList *p = pPathNodeList;
    while (NULL != p->pNext)
    {
        p = p->pNext;
    }

    p->pNext = pNewPathNode;

    return OK;
}

/*初始化二维数组*/
int InitGrid(int iXNum, int iYNum)
{
    if ((iXNum < 0) || (iXNum > MAX_ROW_NUM))
    {
        return ERR;
    }

    if ((iYNum < 0) || (iYNum > MAX_COL_NUM))
    {
        return ERR;
    }

    /*存储数组行列个数*/
    SetRowAndColNum(iXNum, iYNum);

    /*数组中的每个元素均建立一个以应的链表存放其运行轨迹，
    没有初始化元素默认为NULL*/
    for (int i = 0; i < iXNum; i++)
    {
        for (int j = 0; j < iYNum; j++)
        {
            Node node = {0};
            node.x = i;
            node.y = j;

            if (OK != CreatePathNodelist(g_pGrid[i][j], &node))
            {
                return ERR;
            }
        }
    }

    return OK;
}

/*销毁二维数组*/
int DestoryGrid()
{
    CurRowColNum stcurRowColNum = getRowAndColNum();
    for (int i = 0; i < stcurRowColNum.iArrayRow; i++)
    {
        for (int j = 0; j < stcurRowColNum.iArrayCol; j++)
        {
            if (OK != DestoryPathNodelist(g_pGrid[i][j]))
            {
                continue;
            }
        }
    }

    return OK;
}

/*获取元素当前所在位置*/
Node *GetCurPostion(PathNodeList *pPathList)
{
    if (NULL == pPathList)
    {
        return NULL;
    }

    PathNodeList *p = pPathList;

    /*链表的最后一个结点表示当前位置*/
    while(NULL != p->pNext)
    {
        p = p->pNext;
    }

    return &(p->node);
}

/*交换两个结点的位置*/
int SwapNode(Node aNode, Node bNode)
{   

    Node *paNode = GetCurPostion(g_pGrid[aNode.x][aNode.y]);
    Node *pbNode = GetCurPostion(g_pGrid[bNode.x][bNode.y]);

    /*将b结点的当前位置插入到a结点链表中*/
    if (OK != InsertPathNodeList(g_pGrid[aNode.x][aNode.y], pbNode))
    {
        return ERR;
    }

    /*将a结点的当前位置插入到b结点链表中*/
    if (OK != InsertPathNodeList(g_pGrid[bNode.x][bNode.y], paNode))
    {
        return ERR;
    }

    /*交换a、b两个结点*/
    PathNodeList *pTmp = NULL;
    pTmp = g_pGrid[aNode.x][aNode.y];
    g_pGrid[aNode.x][aNode.y] = g_pGrid[bNode.x][bNode.y];
    g_pGrid[bNode.x][bNode.y] = pTmp;

    return OK;
}

/*向数组中没有使用的行插入元素*/
int insertToEmptyRow(int iRow)
{
    CurRowColNum stcurRowColNum = getRowAndColNum();

    for (int j = 0; j < stcurRowColNum.iArrayCol; j++)
    {
        Node node = {0};
        node.x = iRow;
        node.y = j;

        if (OK != CreatePathNodelist(g_pGrid[iRow][j], &node))
        {
            return ERR;
        }
    }  

    return OK;
}

/*向二维数组插入一行*/
int insertRowtoGrid(int iInsertRow)
{
    if (MAX_ROW_NUM <= iInsertRow)
    {
        return ERR;
    }

    CurRowColNum stcurRowColNum = getRowAndColNum();

    /*插入数组中的无效行，直接插入，而向已有行中间插入，需要从前
    向后两两交换行元素的位置*/
    if (iInsertRow >= stcurRowColNum.iArrayRow)
    {
        if (OK != insertToEmptyRow(iInsertRow))
        {
            return ERR;
        }
    }
    else
    {
        /*先将新行插入第一个无效行中*/
        if (OK != insertToEmptyRow(stcurRowColNum.iArrayRow))
        {
            return ERR;
        }  

        /*从刚插入的新行开始，按行两两交换，直到把插入的行
        置换到参数指定的位置*/
        for (int i = stcurRowColNum.iArrayRow; i > iInsertRow; i--)
        {
            for (int j = 0; j < stcurRowColNum.iArrayCol; j++)
            {
                Node curNode;
                Node nextNode;

                curNode.x = i - 1;
                curNode.y = j;

                nextNode.x = i;
                nextNode.y = j;

                if (OK != SwapNode(curNode, nextNode))
                {
                    return ERR;
                }
            }
        }

    }

    /*数组有效行数加1*/
    SetRowAndColNum(stcurRowColNum.iArrayRow + 1, stcurRowColNum.iArrayCol);

    return OK;
}

/*获取二维数组中指定结点的运动轨迹*/
int GetNodePath(Node pathNode, PathNodeList **pPathList)
{
    CurRowColNum stcurRowColNum = getRowAndColNum();
    if ((pathNode.x < 0)
        || (pathNode.x >= stcurRowColNum.iArrayRow))
    {
        *pPathList = NULL;
        return ERR;
    }

    if ((pathNode.y < 0)
        || (pathNode.y >= stcurRowColNum.iArrayCol))
    {
        *pPathList = NULL;
        return ERR;
    }

    *pPathList = g_pGrid[pathNode.x][pathNode.y];
    return OK;

}

/*向数组中没有使用的列插入元素*/
int insertToEmptyCol(int iCol)
{
    CurRowColNum stcurRowColNum = getRowAndColNum();

    for (int i = 0; i < stcurRowColNum.iArrayRow; i++)
    {
        Node node = {0};
        node.x = i;
        node.y = iCol;

        if (OK != CreatePathNodelist(g_pGrid[i][iCol], &node))
        {
            return ERR;
        }
    } 

    return OK;
}

/*向二维数组插入一列*/
int insertColtoGrid(int iInsertCol)
{
    if (MAX_COL_NUM <= iInsertCol)
    {
        return ERR;
    }

    CurRowColNum stcurRowColNum = getRowAndColNum();

    /*插入数组中的无效列，直接插入，而向已有列中间插入，需要从前
    向后两两交换列元素的位置*/
    if (iInsertCol >= stcurRowColNum.iArrayCol)
    {
        if (OK != insertToEmptyCol(iInsertCol))
        {
            return ERR;
        }
    }
    else
    {
        /*先将新行插入第一个无效列中*/
        if (OK != insertToEmptyCol(stcurRowColNum.iArrayCol))
        {
            return ERR;
        }  

        /*从刚插入的新列开始，按列两两交换，直到把插入的列
        置换到参数指定的位置*/
        for (int j = stcurRowColNum.iArrayCol; j > iInsertCol; j--)
        {
            for (int i = 0; i < stcurRowColNum.iArrayRow; i++)
            {
                Node curNode;
                Node nextNode;

                curNode.x = i;
                curNode.y = j - 1;

                nextNode.x = i;
                nextNode.y = j;

                if (OK != SwapNode(curNode, nextNode))
                {
                    return ERR;
                }
            }
        }

    }

    /*数组有效列数加1*/
    SetRowAndColNum(stcurRowColNum.iArrayRow, stcurRowColNum.iArrayCol + 1);

    return OK;
}

/*测试代码*/
int main(int argc, char* argv[])
{
    assert(OK == InitGrid(5, 5));

    PathNodeList *pList = NULL;
    Node node;
    node.x = 3;
    node.y = 4;

    Node node1;
    node1.x = 1;
    node1.y = 1;

    Node node2;
    node2.x = 4;
    node2.y = 4;

    assert(OK == SwapNode(node, node1));
    assert(OK == insertRowtoGrid(1));
    assert(OK == insertColtoGrid(3));

    assert(OK == GetNodePath(node2, &pList));

    PathNodeList *p = pList;
    while (NULL != p)
    {
        printf("(%d\t%d)\n", p->node.x, p->node.y);
        p = p->pNext;
    }

    assert(OK == DestoryGrid());
    return 0;
}

C：二维数组常用操作

时间： 2024-08-24 03:28:57

C：二维数组常用操作的相关文章

C++程序设计实践指导1.2二维数组的操作运算改写要求实现

改写要求1:改写为以单链表表示二维数组 #include <cstdlib> #include <iostream> using namespace std; struct LinkNode { int Row; int Column; int Data; LinkNode *next; }; class MATRIX { int m; int sum; public: struct LinkNode* creat(int x[][40],int k) { m=k; LinkNod

对二维数组使用指针进行操作的探索（C语言）

1 /* 2 Name: 对二维数组使用指针进行操作的探索 3 Copyright: 4 Author: lingr7 5 Date: 01/12/18 11:55 6 Description: 7 */ 8 #include<stdio.h> 9 int main() { 10 11 int a[2][3] = {{1,2,3},{4,5,6}}; 12 int **p = a;/*这一步,将a存放的地址赋值给了p,这一步是的p与a完全等价*/ 13 int *p2 = p;/*这一步就将a

nRF51800 蓝牙学习 进程记录 2：关于二维数组 执念执战

前天在玩OLED时想完成一直想弄得一个东西,就是简单的单片机游戏.因为STM32和nRF51822的内存足够,所以就用缓存数组的方法来显示图像(我也不知道术语是啥,反正就是在内存中建立一个128X64的二维数组,更新显示时将整个数组刷新到屏幕上),而且这两个OLED是串口的(还有一个128X32的OLED,一样串口的,连驱动时序和驱动函数都一样,两个都太小了,还那么贵......),四个IO口就能驱动(两个还是供电的VCC和GND),所以不像之前的那个mini 12864屏幕,它是8位并口的,带

第14周项目1-折腾二维数组

/* * Copyright (c) 2014, 烟台大学计算机学院 * All rights reserved. * 文件名称:test.cpp * 作 者:刘畅 * 完成日期:2014 年 11 月 26 日 * 版 本 号:v1.0 * * 问题描述:创建一个5行4列的二维整型数组,通过初始化,为数组中的前两列的10个元素赋初值,然后满足 题目要求输出: * 输入描述:输入后两列10个元素的值: * 程序输出:按要求输出. #include <iostream> #include <

java 数据结构 图中使用的一些常用算法 图的存储结构 邻接矩阵：图的邻接矩阵存储方式是用两个数组来标示图。一个一位数组存储图顶点的信息，一个二维数组（称为邻接矩阵）存储图中边或者弧的信息。 设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为： 实例如下，左图是一个无向图。右图是邻接矩阵表示：

以下内容主要来自大话数据结构之中,部分内容参考互联网中其他前辈的博客. 图的定义 图是由顶点的有穷非空集合和顶点之间边的集合组成,通过表示为G(V,E),其中,G标示一个图,V是图G中顶点的集合,E是图G中边的集合. 无边图:若顶点Vi到Vj之间的边没有方向,则称这条边为无项边(Edge),用序偶对(Vi,Vj)标示. 对于下图无向图G1来说,G1=(V1, {E1}),其中顶点集合V1={A,B,C,D}:边集合E1={(A,B),(B,C),(C,D),(D,A),(A,C)}: 有向图:若

[java学习笔记]java语言基础概述之数组的定义&amp;常见操作(遍历、排序、查找)&amp;二维数组

1.数组基础 1.什么是数组:           同一类型数据的集合,就是一个容器. 2.数组的好处:           可以自动为数组中的元素从零开始编号,方便操作这些数据. 3.格式:  (一旦创建,必须明确长度)          格式1:              元素类型   [ ]  数组名  =  new  元素类型  [元素个数即数组的长度]:              示例:int[] array = new int[5];          格式2:           

python的二维数组操作

需要在程序中使用二维数组,网上找到一种这样的用法: 1 2 3 4 5 6 #创建一个宽度为3,高度为4的数组 #[[0,0,0], # [0,0,0], # [0,0,0], # [0,0,0]] myList = [[0] * 3] * 4 但是当操作myList[0][1] = 1时,发现整个第二列都被赋值,变成 [[0,1,0], [0,1,0], [0,1,0], [0,1,0]] 为什么...一时搞不懂,后面翻阅The Python Standard Library 找到答案 lis

php对二维数组进行相关操作（排序、转换、去空白等）

php对二维数组进行相关操作(排序.转换.去空白等) 投稿:lijiao 字体:[增加 减小] 类型:转载 时间:2015-11-04 这篇文章主要介绍了php对二维数组进行相关操作,包括php对二维数组排序.转换.去空白,以及去重复值等,感兴趣的小伙伴们可以参考一下 技巧提示: ? 1 2 3 4 5 6 7 8 9 array_keys($array) //返回所有键名   array_values($array) //返回所有键值    $result=array_reverse($inp

c语言中如何通过二级指针来操作二维数组

通过二级指针去访问二维数组需要先给二级指针分配等同于二维数组行数的一维数组指针,然后把二维数组的每行首地址赋值给对应位置的一维指针上.之后就可以通过二维指针直接访问了. 参考代码如下,可以看具体注释辅助理解. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 #include <stdio.h>//输入输出头文件. #include <stdlib.h>//本程序需要用到malloc/free函数,引