队列堆栈和数组-十字链表矩阵

#include<iostream>
#include <iomanip>
#include"windows.h"
using namespace std;
struct OLinMatrixkNode
{
    int data;
    int x,y;
    OLinMatrixkNode* right;
    OLinMatrixkNode* down;
};
struct OLinMatrix
{
    OLinMatrixkNode** RowHead;
    OLinMatrixkNode** ColHead;
    int r,c,cnt;
};
OLinMatrix* createOLinMatrix(int r,int c)
{
    OLinMatrix* ans=(OLinMatrix*)malloc(sizeof(OLinMatrix));
    ans->RowHead=new OLinMatrixkNode*[r+1];
    ans->ColHead=new OLinMatrixkNode*[c+1];
    for(int i=1;i<=r;i++)
        ans->RowHead[i]=NULL;
    for(int i=1;i<=c;i++)
        ans->ColHead[i]=NULL;
    ans->cnt=0;
    ans->r=r;
    ans->c=c;
    return ans;
}

OLinMatrixkNode* createOLinMatrixNonde(int r,int c,int v)
{
    OLinMatrixkNode* ans=(OLinMatrixkNode*)malloc(sizeof(OLinMatrixkNode));
    ans->x=r;
    ans->y=c;
    ans->data=v;
    return ans;
}
void addElement(OLinMatrix* p,int r,int c,int v)
{
    if(v==0)
        return;

    OLinMatrixkNode* newNode = createOLinMatrixNonde(r,c,v);
    if(p->RowHead[r]==NULL || p->RowHead[r]->y > c)
    {
        newNode->right=p->RowHead[r];
        p->RowHead[r]=newNode;
    }
    else
    {
        OLinMatrixkNode* temp = p->RowHead[r];
        while( temp->right!=NULL && temp->right->y <= c)
            temp=temp->right;
        newNode->right=temp->right;
        temp->right=newNode;
        if(p->ColHead[c]==NULL || p->ColHead[c]->x > r)
        {
            newNode->down=p->ColHead[c];
            p->ColHead[c]=newNode;
        }
        else
        {
            OLinMatrixkNode* temp = p->ColHead[c];
            while( temp->down!=NULL && temp->down->x <= c)
                temp=temp->down;
            newNode->down=temp->down;
            temp->down=newNode;
        }
    }
    p->cnt++;
}

void output(OLinMatrix* p)
{
    for(int i=1;i<=p->r;i++)
    {
        OLinMatrixkNode* temp = p->RowHead[i];
        for(int j=1;j<=p->c;j++)
        {
            if(temp!=NULL && temp->y==j)
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN);//彰显非0元
                cout<<std::left<<setw(3)<<temp->data;
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);//设置三色相加
                temp=temp->right;
            }
            else
            {
                cout<<std::left<<setw(3)<<0;
            }
        }
        cout<<endl;
    }
}

void main()
{
    int r=7,c=12,cnt=15;
    OLinMatrix*  m= createOLinMatrix(r,c);
    bool v[100][100];
    memset(v,false,sizeof(100));
    for(int i=1;i<=cnt;i++)
    {
        int x=rand()%r+1,y=rand()%c+1,value=rand()%99+1;
        if(v[x][y])
        {
            addElement(m,x,y,value);
            cout<<x<<" "<<y<<" "<<value<<endl;
            v[x][y]=0;
        }
        else
        {
            i--;
        }
    }
    output(m);
    cin>>r;
}
时间: 2024-08-06 23:46:57

队列堆栈和数组-十字链表矩阵的相关文章

队列堆栈和数组-三角矩阵

#include<iostream> #include <iomanip> using namespace std; enum TriangleTye{leftBottom,leftUp,rightBottom,rightUp}; struct TriangleMatrix { int* nums; int scale; TriangleTye triangleTye; int size; }; TriangleMatrix* createTriangleMatrix(int sc

海港(队列)(数组模拟链表)

海港 题目描述: 小K是一个海港的海关工作人员,每天都有许多船只到达海港,船上通常有很多来自不同国家的乘客. 小K对这些到达海港的船只非常感兴趣,他按照时间记录下了到达海港的每一艘船只情况:对于第i艘到达的船,他记录了这艘船到达的时间ti (单位:秒),船上的乘 客数星ki,以及每名乘客的国籍 x(i,1), x(i,2),-,x(i,k);. 小K统计了n艘船的信息,希望你帮忙计算出以每一艘船到达时间为止的24小时(24小时=86400秒)内所有乘船到达的乘客来自多少个不同的国家. 形式化地讲

数据存储的常用结构 堆栈、队列、数组、链表

数据存储的常用结构有:堆栈.队列.数组.链表.我们分别来了解一下: 堆栈,采用该结构的集合,对元素的存取有如下的特点: 先进后出(即,存进去的元素,要在后它后面的元素依次取出后,才能取出该元素).例如,子弹压进弹夹,先压进去的子弹在下面,后压进去的子弹在上面,当开枪时,先弹出上面的子弹,然后才能弹出下面的子弹. 栈的入口.出口的都是栈的顶端位置 压栈:就是存元素.即,把元素存储到栈的顶端位置,栈中已有元素依次向栈底方向移动一个位置. 弹栈:就是取元素.即,把栈的顶端位置元素取出,栈中已有元素依次

队列的数组和链表实现

队列的单链表实现 queue.h #ifndef QUEUE_H_ #define QUEUE_H_ typedef int ElementType; #ifndef _QUEUE_LIST_ #define _QUEUE_LIST_ struct QNode; typedef struct QNode * QNodePtr; struct QNode { ElementType Element; QNodePtr Next; }QNode; typedef struct Node { QNod

数据结构 数组,链表,栈,队列理解

数据结构 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合.再简单描述一下:数据结构就是描述对象间逻辑关系的学科. 数据存储结构 常用的数据存储方式有两种:顺序存储,非顺序存储.顺序存储就是把数据存储在一块联系的存储介质(硬盘或内存等)中.反之则是非顺序存储. Java中的数组就是典型的顺序存储,链表就是非顺序存储.数组存储数据时会开辟出一块联系内存,按顺序存储.链表先不会开辟出一块内存来,而是只需要知道下一个节点存储的位置,就能把所以的数据连起来了.所以单向链表的最后一个节点是指向N

稀疏矩阵的十字链表存储表示

/* Name: 稀疏矩阵的十字链表存储表示 Copyright: Author: 巧若拙 Date: 29-10-14 21:25 Description: //------------------------------------------------------------------------- 除了用三元组顺序表来存储压缩矩阵,我们还可以用链表结构来存储,实际上后者应用更广泛, 因为当非零元素的数目较大时,三元组的时间复杂度实在太高.链表结构中最常见的是十字链表, 在十字链表中,

有向图的十字链表存储形式

十字链表是有向图的另一种链式存储结构.可以看成是将有向图的邻接表和逆邻接表(只考虑入度)结合起来得到的一种链表.在十字链表中,对应于有向图中每一个顶点有一个节点,每一条弧也有一个结点. 顶点之间是数组顺序存储,而弧是链式存储. 弧结点结构: 顶点结点结构: 十字链表形态: 实现: /*********************************************** 有向图的存储形式--十字链表 by Rowandjj 2014/6/27 ***********************

基于十字链表的两个稀疏矩阵相乘

#include <stdio.h> #include <stdlib.h> #include <string.h> typedef int DataType;// 稀疏矩阵的十字链表存储表示 typedef struct LNode { int i,j; // 该非零元的行和列下标 DataType e; // 非零元素值 struct LNode *right,*down; // 该非零元所在行表和列表的后继链域 }LNode, *Link; typedef str

_DataStructure_C_Impl:稀疏矩阵十字链表存储

#include<stdio.h> #include<stdlib.h> typedef int DataType; typedef struct OLNode{ int i,j; DataType e; struct OLNode *right,*down; }OLNode,*OLink; typedef struct{ OLink *rowhead,*colhead; int m,n,len; }CrossList; //初始化稀疏矩阵 void InitMatrix(Cros