堆栈队列和数组-三元组稀疏矩阵

#include<iostream>
#include <iomanip>
#include"windows.h"
using namespace std;
struct Tripple
{
    int x,y,value;
};
struct TrippleMatrix
{
    int r,c,cnt;
    Tripple* tripples;
};

TrippleMatrix* createTrippleMatrix(int r,int c,int maxCnt)
{
    TrippleMatrix* p = (TrippleMatrix*)malloc(sizeof(TrippleMatrix));
    p->r=r;
    p->c=c;
    p->cnt=0;
    p->tripples=new Tripple[maxCnt];
    return p;
}
TrippleMatrix* transpose(TrippleMatrix*  src)
{
    TrippleMatrix* ans =createTrippleMatrix(src->c,src->r,src->cnt);
    for(int i=1;i<=ans->r;i++)
    {
        for(int j=0;j<src->cnt;j++)
        {
            if(src->tripples[j].y==i)
            {
                Tripple newTripple;
                newTripple.x=i;
                newTripple.y=src->tripples[j].x;
                newTripple.value=src->tripples[j].value;
                ans->tripples[ans->cnt++]=newTripple;
            }
        }
    }
    return ans;
}
void output(TrippleMatrix* src)
{
    int cur=0;
    for(int i=1;i<=src->r;i++)
    {
        for(int j=1;j<=src->c;j++)
        {
            if(src->tripples[cur].x==i && src->tripples[cur].y==j)
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_GREEN);//彰显非0元
                cout<<src->tripples[cur].value<<"   ";
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);//设置三色相加
                cur++;
            }
            else cout<<"0   ";
        }
        cout<<endl;
    }
}
void main()
{
     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY|FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE);//设置三色相加
     int r=12,c=17,maxCnt=40;
     TrippleMatrix* m= createTrippleMatrix(r,c,maxCnt);
     for(int i=1;i<=r;i++)
     {
         for(int j=1;j<=c;j++)
         {
             if(rand()%10==1 && m->cnt<maxCnt)
             {
                 m->tripples[m->cnt].x=i;
                 m->tripples[m->cnt].y=j;
                 m->tripples[m->cnt].value=rand()%10;
                 m->cnt++;
             }
         }
     }
     output(m);
     cout<<endl;
     output(transpose(m));
     cin>>r;
}
时间: 2024-10-02 01:02:55

堆栈队列和数组-三元组稀疏矩阵的相关文章

堆栈队列和数组-行逻辑链接稀疏矩阵

#include<iostream> #include <iomanip> #include"windows.h" using namespace std; struct Tripple { int x,y,value; }; struct RLSMatrix { int r,c,cnt; Tripple* tripples; int* rpos; }; RLSMatrix* createRLSMatrix(int r,int c,int maxCnt) { R

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

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

队列(数组模拟)

//队列(数组模拟) class Queue{ private int[] queue; //队列函数 int length; int head; //头指针 int tail; //尾指针 int num; //丢列中元素个数 public Queue(){ } public Queue(int s){ //构造队列函数 length=s; queue=new int[length]; //s为队列长度 head=0; tail=-1; num=0; } public void inQueue

队列的数组实现

#include <stdio.h> #define maxn 1000 //队列ADT---数组实现 struct queueRecord; typedef struct queueRecord *Queue; typedef int elementType; int isEmpty(Queue Q); int isFull(Queue Q); Queue creatQueue(int maxn); void disposeQueue(Queue Q); void makeEmpty(Que

队列的数组和链表实现

队列的单链表实现 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

队列(一)——队列的数组实现方式

1.队列的概念 队列是一种特殊的线性表,仅仅同意在队列的一端进行插入而在还有一端进行删除. 队列一般拥有队首(front指针)和队尾(rear指针).当一个队列并未存入数据的时候,front和rear指针均指向队首. 入队的操作:rear后移,存入数据在rear指向的单元,队满不可入队,这同一时候也表明front总是指向队首元素的前驱. 出队的操作:front后移,元素出队,队空不可出队. 注意:在这样的队列的实现方式下.浪费了一个单元,可是这样能够保证队满和队空是不同的条件来推断. 2.队列空

算法导论10:栈链表的简化、队列的数组实现 2016.1.10

新年的前十天做了比较有意义的事情就是坚持每天写博客,明天就开始期末考试了,所以等假期再继续学习. 把昨天提到的S.bottom简化之后又改了栈的链表.代码如下(已折叠): #include<stdio.h> #include<stdlib.h> typedef struct _node{ int num; struct _node *next; }node; node *s; void build(node *&S) { s=(node *)malloc(sizeof(no

013实现使用两个堆栈队列(keep it up)

实现使用两个堆栈队列 FIFO队列是一种数据结构(FIFO),后堆叠前进出的数据结构的(FILO). 两个栈实现的最简单的方法就是排队:队列中的第一个推栈, 队列将数据顺序的第一个堆栈推入第二堆叠,然后叠加. 两个规则: 1)进队列,则直接压入第一个栈 2)出队列,若果第二个栈不为空.直接pop(),如过第二个栈为空, 则把第一个栈中的数据所有压入第二个栈(第一个栈此时为空). 实际写代码时注意栈为空的情况. 代码: #include <iostream> #include <stack

数据结构和算法 (二)数据结构基础、线性表、栈和队列、数组和字符串

Java面试宝典之数据结构基础 —— 线性表篇 一.数据结构概念 用我的理解,数据结构包含数据和结构,通俗一点就是将数据按照一定的结构组合起来,不同的组合方式会有不同的效率,使用不同的场景,如此而已.比 如我们最常用的数组,就是一种数据结构,有独特的承载数据的方式,按顺序排列,其特点就是你可以根据下标快速查找元素,但是因为在数组中插入和删除元素会 有其它元素较大幅度的便宜,所以会带来较多的消耗,所以因为这种特点,使得数组适合:查询比较频繁,增.删比较少的情况,这就是数据结构的概念.数据结构 包括