已知几种元素大小关系，求排序（图形结构遍历）

最新推荐文章于 2022-04-02 10:20:26 发布
最新推荐文章于 2022-04-02 10:20:26 发布
阅读量344 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/u/3986494/blog/2222450
版权 
import java.util.*;

public class Testsort {
    /**
     * 已知几种元素大小关系，求排序
     * a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19
     * 已知a1>a2,a2>a3,a1>a4,a2>a5,a5>a8,a6>a7,a4>a11,a9>a10等
     * 求其中的随便一种排序
     */
    private static final List<EntrySort> alist=new ArrayList();//关系集合
    private static final List<EntryA> aAlist=new ArrayList();//元素集合
    private static final Set<EntryA> maxA=new HashSet<>();//顶点元素
    private static int ItopY;
    private static EntryA [][] As;
    private static  int asize;
    private static final EntryA a1=new EntryA("a1");
    private static final EntryA a2=new EntryA("a2");
    private static final EntryA a3=new EntryA("a3");
    private static final EntryA a4=new EntryA("a4");
    private static final EntryA a5=new EntryA("a5");
    private static final EntryA a6=new EntryA("a6");
    private static final EntryA a7=new EntryA("a7");
    private static final EntryA a8=new EntryA("a8");
    private static final EntryA a9=new EntryA("a9");
    private static final EntryA a10=new EntryA("a10");
    private static final EntryA a11=new EntryA("a11");
    private static final EntryA a12=new EntryA("a12");
    private static final EntryA a13=new EntryA("a13");
    private static final EntryA a14=new EntryA("a14");
    private static final EntryA a15=new EntryA("a15");
    private static final EntryA a16=new EntryA("a16");
    private static final EntryA a17=new EntryA("a17");
    private static final EntryA a18=new EntryA("a18");
    private static final EntryA a19=new EntryA("a19");
    static{
        alist.add(new EntrySort(a1,a2));
        alist.add(new EntrySort(a2,a3));
        alist.add(new EntrySort(a2,a4));
        alist.add(new EntrySort(a3,a5));
        alist.add(new EntrySort(a1,a4));
        alist.add(new EntrySort(a4,a5));
        alist.add(new EntrySort(a2,a5));
        alist.add(new EntrySort(a5,a8));
        alist.add(new EntrySort(a6,a7));
        alist.add(new EntrySort(a4,a11));
        alist.add(new EntrySort(a9,a10));
        alist.add(new EntrySort(a4,a7));
        alist.add(new EntrySort(a5,a9));
        alist.add(new EntrySort(a7,a12));
        alist.add(new EntrySort(a13,a12));
        alist.add(new EntrySort(a12,a14));
        alist.add(new EntrySort(a12,a15));
        alist.add(new EntrySort(a17,a16));
        alist.add(new EntrySort(a17,a18));

        aAlist.add(a1);aAlist.add(a2);aAlist.add(a3);
        aAlist.add(a4);aAlist.add(a5);aAlist.add(a6);
        aAlist.add(a7);aAlist.add(a8);aAlist.add(a9);
        aAlist.add(a10);aAlist.add(a11);aAlist.add(a12);
        aAlist.add(a13);aAlist.add(a14);aAlist.add(a15);
        aAlist.add(a16);aAlist.add(a17);aAlist.add(a18);
        aAlist.add(a19);
        asize=aAlist.size();
        As=new EntryA[asize][asize];
        //建立图形结构
        for (EntrySort en: alist) {
            EntryA au=null;
            EntryA ad=null;
            for (EntryA ennext: aAlist) {
                if(ennext.key.equals(en.key.key)){
                    au=ennext;
                }else if(ennext.key.equals(en.value.key)){
                    ad=ennext;
                }
            }
            if(au!=null&&ad!=null) {
                au.addNext(ad);
                ad.addUpA(au);
            }

        }
        //优化图形结构并判断关系合法性
        for (EntryA en:aAlist) {
            Set<EntryA> aset = new HashSet<>();
            Set<EntryA> anset = new HashSet<>();
            if(en.upA !=null) {
                for (EntryA enup : en.upA) {
                    if(enup.upA!=null&&!enup.upA.isEmpty())
                        aset.addAll(enup.upA);
                }
                en.upA.removeAll(aset);
            }
            if(en.next!=null) {
                for (EntryA enup : en.next) {
                    if(enup.next!=null&&!enup.next.isEmpty())
                        anset.addAll(enup.next);
                }
                en.next.removeAll(anset);
            }

            for (EntryA en1:aset) {
                for (EntryA enn:anset) {
                    if(en1.equals(enn)){
                        System.out.println("关系不合法");
                        throw new RuntimeException("关系不合法");
                    }
                }

            }
        }

        for (EntryA en:aAlist) {
            maxA.add(getMaxA(en));
        }

    }

    public static  void main(String [] args){

        printAll(aAlist);
        for (EntryA en:aAlist) {
            System.out.print(en.key+": ");
            printAEnd(en,true);
            System.out.println();
            System.out.print(en.key+": ");
            printA(en,true);
            System.out.println();
        }
        for (EntryA en:aAlist) {
            System.out.println(en);
        }
    }

    public static void printAll(List<EntryA> aAlist){
        if(!maxA.isEmpty()){
            Iterator it=maxA.iterator();
            while(it.hasNext()){
               EntryA en= (EntryA) it.next();
                System.out.print("顶点元素："+en.key+" :");
                printA(en,true);
                System.out.println();
                printXY(As);
                System.out.println();
            }
        }

    }
    //设置元素坐标
    public static void setEntryAXY(EntryA a){
       int  x= getUpAXX(a);
       int y= getUpAYY(a);
       int i=0;
       while(As[x][y+i]!=null){
            i++;
       }
       As[x][y+i]=a;
       a.x=x;
       a.y=y+i;
       //顶点修正
        if(a.upA!=null&&!a.upA.isEmpty())
       for(EntryA en:a.upA){
         if(en.upA==null||en.upA.size()<=0) {
             As[en.x][en.y] = null;
             i = 0;
             while (As[en.x][a.y + i] != null||(As[a.x][a.y+i]!=null&&i>0)) {
                 i++;
             }
             As[en.x][a.y + i] = en;
             en.y = a.y + i;
             if(i>0){
                 As[a.x][a.y] = null;
                 As[a.x][a.y + i] = a;
                 a.y = a.y + i;
             }
         }
        }
    }

    public static void printXY(EntryA[][] As){
              System.out.println("图结构：");
              for (int y=0;y<asize;y++){
                  boolean isp=false;
                  for (int x=0;x<asize;x++){
                    if(As[x][y]!=null)  isp=true;
                  }
                   if(!isp)  continue;
                  for (int x=0;x<asize;x++){
                      if(As[x][y]!=null) {
                          if(x>0) System.out.print("->");
                          System.out.print(As[x][y].key+(As[x][y].key.length()==2?" ":""));
                      }else {
                          if(x>0) System.out.print("  ");
                          System.out.print("   ");
                      }
                  }
                  System.out.println();
              }
    }
    public static EntryA getMaxA(EntryA a){
        if(a==null||a.upA==null||a.upA.size()<=0) return a;
        if(a.upA!=null){
            for (EntryA en :a.upA) {
                return getMaxA(en);
            }
        }
        return a;
    }

    public static void printA(EntryA a,boolean isClean){
        if(isClean)
            cleanAPrint();
        printA(a);
    }
    public static void cleanAPrint(){
        ItopY=0;
        As=new EntryA[asize][asize];
        for (EntryA en:aAlist) {
            en.isPrint=false;//是否打印过
            en.isquery=false;//是否检索过
        }
    }
    //获取横坐标
    public static int getUpAXX(EntryA a) {
        int re=0;
        if (a.upA != null && !a.upA.isEmpty()){
               for (EntryA en :a.upA) {
                   re =re>=en.x+1?re:en.x+1;
               }
        }
        return  re;
    }
    //获取竖坐标
    public static int getUpAYY(EntryA a) {
        int re=0;
        int rup=0;
        if (a.upA != null && !a.upA.isEmpty()){
              for (EntryA en :a.upA) {
                  if(rup==0) rup=en.y;
                  rup =en.y<rup?en.y:rup;
              }
            re=  rup;
        }else{
            re=  ItopY++;
        }

         return re;
    }
    //正向
    public  static void printA(EntryA a){
        if(a.isPrint) return;
        if(isPrint(a)) {
            System.out.print(a.key + ",");
            setEntryAXY(a);
            a.isPrint=true;
        }
        else if(!isPrint(a)){
            printAEnd(a);
        }
        if(!a.isquery&&a.next!=null){
            a.isquery=true;
            for (EntryA aa: a.next) {
                printA(aa);
            }
        }
    }
    //逆向
    public  static void printAEnd(EntryA a,boolean isClean){
        if(isClean) cleanAPrint();
        printAEnd(a);
    }
    public  static void printAEnd(EntryA a){
        if(a.isPrint) return;
        if(a.upA!=null&&!a.upA.isEmpty()){
            for (EntryA aa: a.upA) {
                printAEnd(aa);
            }
        }
        if(!a.isPrint&&isPrint(a)) {
            System.out.print(a.key + ",");
            setEntryAXY(a);
            a.isPrint=true;
        }
        if(!a.isquery&&a.next!=null){
            a.isquery=true;
            for (EntryA aa: a.next) {
                    printA(aa);
            }
        }

    }
    //判断其上级节点是否打印过
    public static boolean isPrint(EntryA a){
        if(a.upA==null||a.upA.size()==0) return true;
        if(!a.upA.isEmpty()){
            for ( EntryA en: a.upA) {
                if(!en.isPrint) return false;
            }
        }
        return true;
    }

    /**
     * 大小关系保存对象 key>value
     */
    static class EntrySort{
        EntryA key;
        EntryA value;
        public EntrySort(EntryA a,EntryA b){
            this.key=a;
            this.value=b;
        }
        @Override
        public String toString() {
            return "["+key.key+","+value.key+"]";
        }

    }

    /**
     *  元素实体类
     */
    static class EntryA{
        Set<EntryA> next;   //上级节点
        Set<EntryA> upA;    //下级节点
        String key;         //元素值
        boolean isPrint=false;//是否打印过
        boolean isquery=false;//是否检索过
        int x;      // 数组x坐标
        int y;      // 数组y坐标
        public EntryA(String a){
            this.key=a;
        }
        public void addNext(EntryA a){
            if(next==null){
                next=new HashSet<EntryA>();
            }
            if(a!=null)
                next.add(a);
        }
        public void addUpA(EntryA a){
            if(upA==null){
                upA=new HashSet<EntryA>();
            }
            if(a!=null)
                upA.add(a);
        }
        public void delNext(EntryA a){
            if(next!=null&&a!=null){
                Iterator it=next.iterator();
                while(it.hasNext()){
                    EntryA en=(EntryA)it.next();
                    if(en.equals(a)) it.remove();
                }

                if(next.isEmpty()) next=null;
            }
        }

        public boolean equals(EntryA a){
            if(a!=null&&key.equals(a.key))
                return true;
            return false;
        }

        @Override
        public String toString() {
            String re="Key="+key+" 坐标["+x+","+y+"]";
            if(upA!=null&&!upA.isEmpty()){
                re+="上级[";
                for (EntryA en:upA) {
                    re+=en.key;
                }
                re+="]";
            }
            if(next!=null&&!next.isEmpty()){
                re+="下级[";
                for (EntryA en:next) {
                    re+=en.key;
                }
                re+="]";
            }
            return re;
        }
    }

}

转载于:https://my.oschina.net/u/3986494/blog/2222450

chouga1556
关注
根据已知顶点求构成凸包的顶点集合
07-24
在计算机图形学和算法设计中，"根据已知顶点求构成凸包的顶点集合" 是一个重要的问题。凸包是一组点中最大的多边形，它包含所有点并且边界上的点都与内部的点相连。对于二维空间中的点集，解决这个问题可以帮助我们...
蓝桥杯练习【排序】——插入排序*
weixin_44441299的博客
03-19 912
题目描述： 排序，顾名思义，是将若干个元素按其大小关系排出一个顺序。形式化描述如下：有n个元素a[1]，a[2]，…，a[n]，从小到大排序就是将它们排成一个新顺序a[i[1]]< a[i[2]]< …< a[i[n]] i[k]为这个新顺序。 插入排序，顾名思义，是通过插入操作完成排序。其直觉和方法来源于打牌时安排牌的方法。每次摸起一张牌，你都会将其插入到现在手牌中它按顺序应在的那个位置。插入排序每一步都类似这个摸牌过程。比如现在有整数数组：{3, 1, 5, 4, 2} 第一...
POJ 1094-Sorting It All Out(元素大小关系-拓扑排序)
Some.
07-30 793
Sorting It All Out Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 32635   Accepted: 11345 Description An ascending sorted sequence of distinct values is one
大小关系
u014610380的专栏
04-15 1237
题目描述 当我们知道一组大小关系之后，可判断所有关系是否都能成立，即关系间没有矛盾。  例如：A通过这组关系我们可以得到A，所有关系都成立，没有矛盾。  若 A通过前两个关系我们得到 A，这个关系与C矛盾，所有关系不能同时成立。  现在我们知道m个关系,请判断这m个关系是否能成立，成立输出“YES”，否则输出“NO”。 输入 多组数据，每组数据如下： 第一行有两个字母
排序算法--两个数组元素之间关系(两个数组交集，分发饼干)
m0_53328239的博客
04-02 488
排序算法–两个数组交集 归并排序：其原理就相当于把数组分成左右两等份数组，让数组左右两边先各自排好序，然后再让数组整体有序。 文章：八大排序算法 在一部分的排序算法中求两数组元素的关系中都会用到归并排序算法的原理思想。 题目一 给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。 思路：运用归并排序中不同数组中的双指针思想，首先把要求交集的两个数组进行排序，然后创建两个双指针变量，运用双指针来对两数组中的元素一一比较。
Python 列表包含字典的列表按字典值排序的方法及字典按值排序
Great_Zhou的博客
09-04 729
#-*- encoding=utf-8 -*- import operator #按字典值排序（默认为升序） x = {1:2, 3:4, 4:3, 2:1, 0:0} sorted_x = sorted(x.iteritems(), key=operator.itemgetter(1)) print sorted_x #[(0, 0), (2, 1), (1, 2), (4, 3), (3, 4)] #如果要降序排序,可以指定reverse=True sorted_x...
8个简单的汇编程序，数组排序、计算最大数，字符串比较，打印图形
07-20
它利用循环结构遍历输入，通过CMP指令比较当前值与已知最大值，更新最大值。这个程序展示了如何处理动态输入和存储中间结果。 4. **字符串比较**：给定两个字符串，程序检查串2的后5个字符是否与串1相同。它利用...
数据结构应用题.docx
07-11
在上述题目中，我们遇到了几种不同的数据结构及其操作，包括顺序表、链表和二叉树。 1. 直接选择排序是一种简单的排序算法。在给定的序列（12，4，17，10，7，30）中，直接选择排序通过每趟选择最小元素并放到前面...
【图论】【poj 1094】Sorting It All Out
weixin_30325071的博客
03-06 62
问题 给定多组数据，每组数据中有多个大小关系，让你判断是否能产生一个拓扑序列，如果可以，输出在第几个关系之后得到，并输出这个序列。如果不可以，输出在第几个关系之后无解；如果存在多解，按题目要求输出。 分析 就是拓扑排序，加队列优化，再加一点改进。每次读入关系之后进行拓扑排序。我们知道，如果一个序列能得到拓扑排序的序列，那么在每步有且仅有一个节点的入度为0，如果不存在入度为零的点，则无解。如果...
五种排序算法比较java图形实现
04-06
通过java图形用户界面实现五中排序算法的直管时间比较，运用到了多线程，可同时进行，并可重复多次，个人认为比较完善，Version 3.0
【vj】给定一些先后约束，求原序列（拓扑排序）
芒果街上的小屋（此博客暂时停用）
01-21 568
糟糕的事情发生啦，现在大家都忙着逃命。但是逃命的通道很窄，大家只能排成一行。  现在有n个人，从1标号到n。同时有一些奇怪的约束条件，每个都形如：a必须在b之前。  同时，社会是不平等的，这些人有的穷有的富。1号最富，2号第二富，以此类推。有钱人就贿赂负责人，所以他们有一些好处。  负责人现在可以安排大家排队的顺序，由于收了好处，所以他要让1号尽量靠前，如果此时还有多种情况，就再让2
python中对列表元素大小排序（冒泡排序法，选择排序法和插入排序法）—排序算法
zeruns
02-04 8685
前言 排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列。本文主要讲述python中经常用的三种排序算法，选择排序法，冒泡排序法和插入排序法及其区别。通过对列表里的元素大小排序进行阐述。 原文地址：https://blog.zeruns.tech/index.php/archives/297/ 一、选择排序法 选择...
对顺序表中元素从小到大排序的算法
DX奥特曼的博客
12-29 1万+
）编写一个对顺序表中元素从小到大排序的算法，函数接口如下： //初始条件：线性表L已经存在，且元素个数大于1 //操作结果：将L中的元素从小到大排序 Status ListSort_Sq(SqList &L); 然后，在main函数中调用ListSort_Sq函数，对之前创建的顺序表进行排序。 实现两个有序顺序表的合并操作。然后在主函数中再创建一个顺序表实例，输入5个元素，并
2021-07-31 算法笔记Visualgo
weixin_46689011的博客
08-01 337
给定一个N个元素的数组，冒泡排序将： 1.如果元素大小关系不正确，交换这两个数（在本例中为a> b）， 2.比较一对相邻元素（a，b）， 3.重复步骤1和2，直到我们到达数组的末尾（最后一对是第（N-2）和（N-1）项，因为我们的数组从零开始） 4.到目前为止，最大的元素将在最后的位置。 然后我们将N减少1，并重复步骤1，直到N = 1。 不用多说，让我们在小例子阵列[29,10,14,37,14]上尝试Bubble Sort。 如果您想象较大的项目“起泡”（也就是“浮动到数组的右侧”），则应该能想象
大小排序算法
SYK_PRO的博客
09-20 2201
10种排序算法总结（冒泡、选择、插入、希尔、归并、快速、堆、拓扑、锦标赛、基数） 2011年01月20日 星期四 08:24 P.M.    排序算法有很多，所以在特定情景中使用哪一种算法很重要。为了选择合适的算法，可以按照建议的顺序考虑以下标准： （1）执行时间 （2）存储空间 （3）编程工作    对于数据量较小的情形，（1）（2）差别不大，主要考虑（3
多种方法实现数组元素从大到小排序；冒泡排序
热门推荐
qq_40443457的博客
05-07 2万+
冒泡排序 数组由大到小排列 实现一、数组 #include<stdio.h> int sort(int a[],int n) { int i,j,temp; for(i=0;i<n-1;i++) { for(j=i+1;j<n;j++) { ...
2个数比大小排序 java_java实现经典排序算法
weixin_34666478的博客
02-28 859
代码太多，就只显示了最关键的部分1. 冒泡排序实现思路：(1)比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换。(2)这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第 N-1个位置。(3)N=N-1，如果N不为 0就重复前面二步，否则排序完成。public static voidbubbleSort1(){inti, j;for(i=0; ...
已知前序遍历和中序遍历求后序遍历
最新发布
12-31
已知前序遍历序列为A-B-D-E-G-C-F，中序遍历序列为D-B-G-E-A-C-F，我们可以通过递归的方式来求解后序遍历序列。 首先，我们可以观察到前序遍历序列的第一个元素A就是整个树的根节点。然后，在中序遍历序列中找到根...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值