JAVA-排序处理

YHH学JAVA

已于 2023-01-15 19:55:49 修改

阅读量142

点赞数

分类专栏： # 数据结构和算法文章标签： java 算法排序算法

于 2022-07-03 14:48:46 首次发布

本文链接：https://blog.csdn.net/qq_39542597/article/details/125584480

版权

数据结构和算法专栏收录该内容

11 篇文章 0 订阅

订阅专栏

排序处理

list比较器

      // 输入list=[0.0.0.0, 1.4.5.6, 8.8.8.8]
        //输出 list=[8.8.8.8, 1.4.5.6, 0.0.0.0]
   Collections.sort(list, new Comparator<String>()
    {
        @Override
        public int compare(String next, String prev) {
        //ip转数字和
            String[] nextarray = next.split("\\.");
            String[] prevarray = prev.split("\\.");

            int nextsum = 0;
            int prevsum = 0;
            for (int i = 0; i < nextarray.length; i++) {
                nextsum += Integer.parseInt(nextarray[i]);
                prevsum += Integer.parseInt(prevarray[i]);
            }

            // 降序-后面的大于前面的
            if (prevsum < nextsum) {
                // 返回-1，需要调整
                return -1;
            }
            else {
                return 0;
            }
        }
    });

    System.out.println(list.toString());

list冒泡排序

       int len = list.size();

        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                String[] prevarray = list.get(j).split("\\.");
                String[] nextarray = list.get(j + 1).split("\\.");
                int prevsum = 0;
                int nextsum = 0;
                for (int k = 0; k < nextarray.length; k++) {
                    prevsum += Integer.parseInt(prevarray[k]);
                    nextsum += Integer.parseInt(nextarray[k]);
                }
                // 降序
                if (prevsum < nextsum) {
                    String temp = list.get(j);
                    list.set(j, list.get(j + 1));
                    list.set(j + 1, temp);
                }
            }
        }

        System.out.println(list.toString());

插入排序

// 插入排序
        for (int i = 1; i < len; i++) {
            String data = list.get(i);
            int dataNum = getSum(data);
            int j = i - 1;
            for (; j >= 0; j--) {
                if (getSum(list.get(j)) < dataNum) {
                    list.set(j + 1, list.get(j));
                }
                else {
                    break;
                }
            }
            list.set(j + 1, data);
        }
        System.out.println(list.toString());

优先级队列排序

   Comparator Comparator = new Comparator<String>()
        {
            @Override
            public int compare(String next, String prev) {
                // 降序-后面的大于前面的
                if (getSum(next) > getSum(prev)) {
                    // 返回-1，需要调整
                    return -1;
                }
                else {
                    return 0;
                }
            }
        };

        Queue<String> ipQueue = new PriorityQueue<String>(10, Comparator);

        List<String> list = new ArrayList<>();
        for (String string2 : strArray) {
            if (check(string2) && !list.contains(string2)) {
                // list.add(string2);
                ipQueue.offer(string2);
            }
        }
        
        System.out.println(Arrays.toString(ipQueue.toArray()));

TreeMap排序

public class MyTreeMap {
 
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Map<String, Integer> map = new TreeMap<String, Integer>();
		map.put("c", 2);
		map.put("ad", 1);
		map.put("bc", 1);
		map.put("abc", 3);
 
 
		List<Map.Entry<String, Integer>> treeMapList =
		    new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
 
 
		//排序前
		System.out.println("排序前------------------");
		for (int i = 0; i < treeMapList.size(); i++) {
		    String id = treeMapList.get(i).toString();
		    System.out.println(id);
		}
 
 
		//通过key倒序排序
		Collections.sort(treeMapList, new Comparator<Map.Entry<String, Integer>>() {   
		    public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {      
		        return (o2.getKey()).toString().compareTo(o1.getKey());
		    }
		}); 	
 
 
		System.out.println("key倒序排列------------------");
		for (int i = 0; i < treeMapList.size(); i++) {
		    String id = treeMapList.get(i).toString();
		    System.out.println(id);
		}
		
		//通过value倒序排序
		Collections.sort(treeMapList, new Comparator<Map.Entry<String, Integer>>() {   
		    public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {      
		        return (o2.getValue() - o1.getValue()); 
		    }
		}); 
 
 
		System.out.println("value倒序排列------------------");
		for (int i = 0; i < treeMapList.size(); i++) {
		    String id = treeMapList.get(i).toString();
		    System.out.println(id);
		}
 
 
	}

实例

package com.epoint.ga.a20220407;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.regex.Pattern;

/**
 /**
 * 给定字符串，每个IP地址用"，"号隔开，地址里面有合法的与非法的：
 * 需要把合法的地址挑选出来X.X.X.X，并且排序，需要去重，输出合法IP的数组。
 *
 * 校验规则：
 * 1.采用 "." 分隔成四个字段，每个字段采用十进制记录。
 * 2.每个字段的值范围为：[0,255]
 *
 * 排序规则：
 * 按照点分十进制之和比如，从大到小排序。
 * 例如：3.1.1.1（3+1+1+1= 6） 比1.10.1.1（1 + 10 + 1 + 1 = 13）小。
 *
 * 例子：
 * 输入：1.4.5.6,4.5.6.56.3,8.8.8.8,0.0.0.0,0.0.0.0
 * 输出：[8.8.8.8, 1.4.5.6, 0.0.0.0]
 */

public class Test
{

    static String valid = "[0-9\\.,]*";

    public static void main(String[] args) {

        String str = "1.4.5.6,6.5.6.56.3,8.8.8.8,0.0.0.0,0.0.0.0";
        if (!checkValid(str)) {
            System.out.println("no pass....");
            return;
        }
        String[] ipArray = str.split(",");
        //冒泡排序
        //        maaoPaoSort(ipArray);

        //插入排序
        //        chaRuSort(ipArray);

        //list排序
        //                listSort(ipArray);

        //set排序
        //                setSort(ipArray);

        //treeMap排序
        //                mapSort(ipArray);

        //优先级队列排序
        //                queueSort(ipArray);

        //map，collection比较
        mapToListSort(ipArray);

    }

    /**
     * map迭代
     * @param ipArray
     */
    public static void mapToListSort(String[] ipArray) {
        Map<String, String> map = new HashMap<>();
        for (String ip : ipArray) {
            if (checkIP(ip)) {
                map.put(ip, ip);
            }
        }

        List<Map.Entry<String, String>> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<String, String>>()
        {
            @Override
            public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
                if (getSum(o1.getKey()) > getSum(o2.getKey())) {
                    return -1;
                }
                else if (getSum(o1.getKey()) < getSum(o2.getKey())) {
                    return 1;
                }
                return 0;
            }
        });

        System.out.println(list.toString());
    }

    /**
     * 队列比较器-注意取数据要poll
     * @param ipArray
     */
    public static void queueSort(String[] ipArray) {
        PriorityQueue<String> queue = new PriorityQueue<>(new Comparator<String>()
        {
            @Override
            public int compare(String o1, String o2) {
                if (getSum(o1) > getSum(o2)) {
                    return -1;
                }
                else if (getSum(o1) < getSum(o2)) {
                    return 1;
                }
                return 0;
            }
        });

        for (String ip : ipArray) {
            if (checkIP(ip) && !queue.contains(ip)) {
                queue.offer(ip);
            }
        }

        while (!queue.isEmpty()) {
            System.out.println(queue.poll());
        }
    }

    public static void mapSort(String[] ipArray) {
        TreeMap<String, String> treeMap = new TreeMap<String, String>(new Comparator<String>()
        {
            @Override
            public int compare(String o1, String o2) {
                if (getSum(o1) > getSum(o2)) {
                    return -1;
                }
                else if (getSum(o1) < getSum(o2)) {
                    return 1;
                }
                return 0;
            }
        });

        for (String ip : ipArray) {
            if (checkIP(ip)) {
                treeMap.put(ip, ip);
            }
        }

        System.out.println(Arrays.toString(treeMap.keySet().toArray()));
        ;

        //        for (String s : treeMap.keySet()) {
        //        }

        //        for (Map.Entry<String, String> stringStringEntry : treeMap.entrySet()) {
        //            stringStringEntry.getKey();
        //            stringStringEntry.getValue();
        //        }

    }

    /**
     * set排序
     * @param ipArray
     */
    public static void setSort(String[] ipArray) {
        TreeSet<String> set = new TreeSet<>(new Comparator<String>()
        {
            @Override
            public int compare(String o1, String o2) {
                if (getSum(o1) > getSum(o2)) {
                    return -1;
                }
                else if (getSum(o1) < getSum(o2)) {
                    return 1;
                }
                return 0;
            }
        });

        for (String ip : ipArray) {
            if (checkIP(ip)) {
                set.add(ip);
            }
        }

        System.out.println(Arrays.toString(set.toArray()));
        StringBuilder builder = new StringBuilder();
        builder.append("[");
        for (String s : set) {
            builder.append(s + ",");
        }
        String str = builder.toString();
        str = str.substring(0, str.length() - 1) + "]";
        System.out.println(str);

        System.out.println();

        System.out.print("[");
        for (int i = 0, len = set.size(); i < len; i++) {
            System.out.print(set.pollFirst());
            if (i != len - 1) {
                System.out.print(",");
            }
        }

        System.out.print("]");

    }

    /**
     * list排序
     * @param ipArray
     */
    private static void listSort(String[] ipArray) {
        List<String> ipList = new ArrayList<>();
        //判断是否符合
        for (String ip : ipArray) {
            if (checkIP(ip) && !ipList.contains(ip)) {
                ipList.add(ip);
            }
        }

        Collections.sort(ipList, new Comparator<String>()
        {
            @Override
            public int compare(String o1, String o2) {
                if (getSum(o1) > getSum(o2)) {
                    return -1;
                }
                else if (getSum(o1) < getSum(o2)) {
                    return 1;
                }
                return 0;
            }
        });

        System.out.println(ipList.toString());

    }

    /**
     * 插入排序
     * @param ipArray
     */
    private static void chaRuSort(String[] ipArray) {
        List<String> ipList = new ArrayList<>();
        //判断是否符合
        for (String ip : ipArray) {
            if (checkIP(ip) && !ipList.contains(ip)) {
                ipList.add(ip);
            }
        }

        int len = ipList.size();
        for (int i = 0; i < len; i++) {
            int data = getSum(ipList.get(i));
            String dataStr = ipList.get(i);
            int j = i - 1;
            for (; j >= 0; j--) {
                if (getSum(ipList.get(j)) < data) {
                    ipList.set(j + 1, ipList.get(j));
                }
                else {
                    break;
                }
            }
            ipList.set(j + 1, dataStr);
        }
        System.out.println(ipList.toString());
    }

    private static void maaoPaoSort(String[] ipArray) {
        List<String> ipList = new ArrayList<>();
        //判断是否符合
        for (String ip : ipArray) {
            if (checkIP(ip) && !ipList.contains(ip)) {
                ipList.add(ip);
            }
        }

        int listLen = ipList.size();
        boolean hasSort = false;
        for (int i = 0; i < listLen - 1; i++) {
            for (int j = 0; j < listLen - 1 - i; j++) {
                String temp;
                if (getSum(ipList.get(j)) < getSum(ipList.get(j + 1))) {
                    temp = ipList.get(j);
                    ipList.set(j, ipList.get(j + 1));
                    ipList.set(j + 1, temp);
                    hasSort = true;
                }
            }
            if (!hasSort) {
                break;
            }
        }
        System.out.println(ipList.toString());
    }

    /**
     * 求和
     * @param str
     * @return
     */
    public static int getSum(String str) {
        String[] split = str.split("\\.");
        int sum = 0;
        for (String s : split) {
            sum += Integer.parseInt(s);
        }
        return sum;
    }

    /**
     * 验证ip
     * @param ip
     * @return
     */
    public static boolean checkIP(String ip) {
        String[] ipnum = ip.split("\\.");

        int len = ipnum.length;
        if (len == 4) {
            for (int i = 0; i < len; i++) {
                if (!validNum(ipnum[i])) {
                    System.out.println("存在非数字");
                    return false;
                }

                int num = Integer.parseInt(ipnum[i]);
                if (num < 0 && num > 255) {
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean checkValid(String s) {
        Pattern compile = Pattern.compile("[0-9,\\.]*");
        if (compile.matcher(s).matches()) {
            System.out.println("pattern 验证");
            return true;
        }

        if (s.matches(valid)) {
            System.out.println("String 验证");
            return true;
        }
        return false;
    }

    /**
     * 验证每个数字
     * @param s
     * @return
     */
    public static boolean validNum(String s) {
        if ("".equals(s) || !Character.isDigit(s.charAt(0))) {
            System.out.println("非数字校验");
            return false;
        }
        return true;
    }
}