关于排序算法的折腾

最新推荐文章于 2024-07-09 23:19:55 发布
最新推荐文章于 2024-07-09 23:19:55 发布
阅读量48 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/interim/p/9928342.html
版权

 

折腾了许久了

主要是折腾 冒泡排序

 

抓个图说话吧

 

 

数据重复多,

组团冒泡比冒泡好些,

但是用完全的版本,用链表List,不行,需要自己做个链表试试,先这样吧

 

2018年11月8日

 

 

 

 

 

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;

public class Example
{

    public class 链
    {
        public 链()
        {

        }
        public 链(int a)
        {
            值 = a;
        }
        public int 值;
        public 链 下一元素 = null;
    }

    public static void Main()
    {


        var len = Convert.ToInt32(Console.ReadLine());
        var list = Console.ReadLine().Split(' ');


        list = System.IO.File.ReadAllText("h:\\a.txt").Split(' ');


        int K = 1;
        int[] data = new int[len * K];

        int i = 0;
        for (int k = 0; k < K; k++)
        {
            foreach (var item in list)
            {
                data[i++] = Convert.ToInt32(item);
            }
        }





        System.Diagnostics.Stopwatch s = new System.Diagnostics.Stopwatch();
        s.Start();
        Console.WriteLine(组团冒泡排序不完全(deapCopy(data)));
        Console.WriteLine(组团冒泡排序不完全List版(deapCopy(data)));
        Console.WriteLine(组团冒泡排序List(deapCopy(data)));
        Console.WriteLine(经典冒泡排序(deapCopy(data)));
        Console.WriteLine(经典冒泡List(deapCopy(data)));

        s.Stop();
        Console.WriteLine(s.ElapsedMilliseconds);
    }

    static int[] deapCopy(int[] data)
    {
        int[] mydata = new int[data.Length];
        int i = 0;
        foreach (var item in data)
        {
            mydata[i] = data[i];
            i++;
        }
        return mydata;
    }
    static string 链插入排序(int[] data)
    {

        StringBuilder sb = new StringBuilder();
        链 sll = new 链();
        for (int j = 0; j < data.Length; j++)
        {
            var item = data[j];

            var tempSll = sll;
            AAA:
            {
                if (tempSll.下一元素?.值 > item)
                {
                    var temp = tempSll.下一元素;

                    tempSll.下一元素 = new 链(item);

                    tempSll.下一元素.下一元素 = temp;
                }
                else
                {
                    if (tempSll.下一元素 == null)
                    {
                        tempSll.下一元素 = new 链(item);

                    }
                    else
                    {
                        tempSll = tempSll.下一元素;
                        goto AAA;
                    }
                }

            }


        }
        var temp2 = sll.下一元素;
        while (temp2 != null)
        {
            sb.Append(temp2.值 + " ");
            temp2 = temp2.下一元素;
        }
        return sb.ToString().Trim();
    }


    static string 数组插入排序(int[] data)
    {

        var len = data.Length;

        int[] myData = new int[len];
        myData[0] = data[0];

        int count = 1;
        for (int i = 1; i < len; i++)
        {
            for (int j = 0; j <= count && count < len; j++)
            {
                if (data[i] < myData[j])
                {
                    var tempC = count;
                    while (tempC > j)
                    {
                        myData[tempC] = myData[tempC - 1];
                        tempC--;
                    }

                    myData[j] = data[i];
                    count++;
                    break;
                }
                else
                {

                    if (j == count - 1)
                    {
                        j++;
                        myData[j] = data[i];
                        count++;
                        break;
                    }
                }

            }

        }
        StringBuilder sb = new StringBuilder();
        foreach (var item in myData)
        {
            sb.Append(item + " ");

        }
        return sb.ToString().Trim();

    }

    static string 组团冒泡排序List(int[] data)
    {
        //数据准备阶段
        List<List<int>> myData = new List<List<int>>();

        List<List<int>> myData2 = new List<List<int>>();

        foreach (var item in data)
        {
            myData2.Add(new List<int> { item });
            myData.Add(new List<int> { item });


        }
        //数据准备完成,计划用 List.Sort的 速度,与我的这个算法相比.

        System.Diagnostics.Stopwatch a = new System.Diagnostics.Stopwatch();
        a.Start();

        myData2.Sort((c, b) => { if (c[0] < b[0]) return 1; return 0; });

        a.Stop();
        Console.WriteLine(a.ElapsedMilliseconds);

        a.Restart();
        StringBuilder sb = new StringBuilder();
        var len = myData.Count;

        for (int i = 0; i < len - 1; i++)
        {

            bool haveSW = false;
            for (int j = len - 1; j > i; j--)
            {
                if (myData[j][0] < myData[j - 1][0])
                {
                    var temp = myData[j - 1];
                    myData[j - 1] = myData[j];
                    myData[j] = temp;
                    haveSW = true;

                }
                else if (myData[j] == myData[j - 1])
                {
                    myData[j - 1].AddRange(myData[j]);
                    myData.RemoveAt(j);
                }
            }
            if (haveSW == false)
            {
                break;
            }
        }
        a.Stop();

        Console.WriteLine(a.ElapsedMilliseconds);



        foreach (var d in myData)
        {
            foreach (var item in d)
            {
                sb.Append(item + " ");
            }



        }
        return "";// sb.ToString().Trim();
    }
    static string 组团冒泡排序不完全List版(int[] data)
    {  //数据准备阶段
        List<List<int>> myData = new List<List<int>>();


        foreach (var item in data)
        {
            myData.Add(new List<int> { item });


        }
        //数据准备完成
        System.Diagnostics.Stopwatch a = new System.Diagnostics.Stopwatch();
        a.Start();


        StringBuilder sb = new StringBuilder();
        var len = data.Length;



        for (int i = 0; i < len - 1; i++)
        {
            var X = 0;
            bool haveSW = false;

            for (int j = len - 1; j > i; j--)
            {
                if (myData[j][0] < myData[j - 1][0])
                {
                    var temp = myData[j - 1];
                    myData[j - 1] = myData[j + X];
                    myData[j + X] = temp;
                    haveSW = true;
                    X = 0;
                }
                else if (myData[j][0] == myData[j - 1][0])
                {
                    X++;
                }
                else
                {
                    X = 0;
                }
            }
            if (haveSW == false)
            {
                break;
            }
        }


        a.Stop();
        Console.WriteLine(a.ElapsedMilliseconds);

        foreach (var item in myData)
        {
            sb.Append(item + " ");

        }
        return "";// sb.ToString().Trim();

    }
    static string 经典冒泡List(int[] data)
    { //数据准备阶段
        List<List<int>> myData = new List<List<int>>();


        foreach (var item in data)
        {
            myData.Add(new List<int> { item });


        }
        //数据准备完成
        System.Diagnostics.Stopwatch a = new System.Diagnostics.Stopwatch();
        a.Start();


        StringBuilder sb = new StringBuilder();
        var len = data.Length;



        for (int i = 0; i < len - 1; i++)
        {

            bool haveSW = false;

            for (int j = len - 1; j > i; j--)
            {
                if (myData[j][0] < myData[j - 1][0])
                {
                    var temp = myData[j - 1];
                    myData[j - 1] = myData[j];
                    myData[j] = temp;
                    haveSW = true;

                }
            }
            if (haveSW == false)
            {
                break;
            }
        }


        a.Stop();
        Console.WriteLine(a.ElapsedMilliseconds);

        foreach (var item in myData)
        {
            sb.Append(item + " ");

        }
        return "";// sb.ToString().Trim();

    }

    static string 组团冒泡排序不完全(int[] data)
    {
        System.Diagnostics.Stopwatch a = new System.Diagnostics.Stopwatch();
        a.Start();


        StringBuilder sb = new StringBuilder();
        var len = data.Length;
        var myData = data;


        for (int i = 0; i < len - 1; i++)
        {
            var X = 0;
            bool haveSW = false;

            for (int j = len - 1; j > i; j--)
            {
                if (myData[j] < myData[j - 1])
                {
                    var temp = myData[j - 1];
                    myData[j - 1] = myData[j + X];
                    myData[j + X] = temp;
                    haveSW = true;
                    X = 0;
                }
                else if (myData[j] == myData[j - 1])
                {
                    X++;
                }
                else
                {
                    X = 0;
                }
            }
            if (haveSW == false)
            {
                break;
            }
        }


        a.Stop();
        Console.WriteLine(a.ElapsedMilliseconds);

        foreach (var item in myData)
        {
            sb.Append(item + " ");

        }
        return "";// sb.ToString().Trim();

    }
    static string 经典冒泡排序(int[] data)
    {
        System.Diagnostics.Stopwatch a = new System.Diagnostics.Stopwatch();
        a.Start();

        StringBuilder sb = new StringBuilder();
        var len = data.Length;
        var myData = data;
        for (int i = 0; i < len - 1; i++)
        {

            bool haveSW = false;
            for (int j = len - 1; j > i; j--)
            {
                if (myData[j] < myData[j - 1])
                {
                    var temp = myData[j - 1];
                    myData[j - 1] = myData[j];
                    myData[j] = temp;
                    haveSW = true;
                }
            }
            if (haveSW == false)
            {
                break;
            }
        }


        a.Stop();
        Console.WriteLine(a.ElapsedMilliseconds);
        foreach (var item in myData)
        {
            sb.Append(item + " ");

        }


        return "";//  sb.ToString().Trim();

    }

}

 

转载于:https://www.cnblogs.com/interim/p/9928342.html

weixin_30666753
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法与数据结构考研试题精析-第１０章算法设计题３７
weixin_43213382的博客
04-26 328
数据结构ＤＥＡＰ的定义如下：ＤＥＡＰ是一棵完全二叉树，…… #include <stdio.h> #include <stdlib.h> #include <math.h> #define MAXSIZE 30 typedef struct { int r[MAXSIZE]; int length; }SqList; void DEAPInsert(SqLi...
python用冒泡法对10个数排序_Python——关于排序算法（冒泡法）
weixin_39619270的博客
11-28 1618
这是奔跑的键盘侠的第96篇文章前一阵发的一篇《关于多线程的应用》，本来要去某站爬取几个T的资源，爬了几百G以后重感冒，就休息了一周。未料再次开动时，网站已然设置了反爬机制可能是我的多线程开的太猛了吧（峰值时大概50个线程，一分钟能下载1G）这个周末本想安心写一下关于编程常见的一个排序算法，发现无法爬取自然不甘心，于是折腾了两天还是没搞定收拾一下心情，讲一下关于排序算法吧，排序问题是编程入门里老生常...
算法小题大析（2）
weixin_45479215的博客
12-22 90
算法小题大析——股票买卖的最佳时机II 题目：给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）.注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 代码如下： // code（java) class Solution { public int maxProfit(int...
排序算法 - 折腾基础
SmallJerry2015的博客
01-12 89
前几天 看到JS高级教程里面的排序 看了一下W3C 发现JS的里面的排序很简单嘛 array.sort(arr) 传入值数组的值就好了 w3c上也写了默认的排序就这样是不能实现 例如 var arr = [1,2,3,5,12,17,15,12] arr.sort() console.log(arr)//得到结果[1, 12, 12, 15, 17, 2, 3, 5]要写...
排序算法
CZHLNN的博客
01-28 2455
排序算法1 什么是排序以及排序算法的分类1.1 排序的概念1.1 排序的分类2 都有哪些排序算法2.1 插入排序2.1.1 直接插入排序2.1.2 希尔排序2.2 选择排序2.2.1 直接选择排序2.2.2 堆排序2.3 交换排序2.3.1 冒泡排序2.3.2 快速排序2.4 归并排序2.5 计数排序3 排序算法的性能评价和小结3.1 都有哪些性能评价指标3.2 总结 1 什么是排序以及排序算法的分类 1.1 排序的概念 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作
各种排序算法
weixin_39182190的博客
11-09 259
【代码】各种排序算法。
算法：鸡尾酒排序
OceanStar的博客
06-22 1123
鸡尾酒排序，是冒泡排序的改良
【数据结构】内部排序算法
dongrixinyu的专栏
11-25 428
我总结了一下常见的排序算法。直接写成了类，对于每一种算法的说明都写在了注释里，在调用某个类或者某个排序算法的方法之后，使用python内置的 __doc__方法即可查看具体的某种算法的说明。class SortingAlgorithms(object): ''' 冒泡法：对比模型，原数组上排序，稳定，慢o(n^2) 插入法：对比模型，原数组上排序，稳定，慢，最优的方法是希尔排
VBA数组的排序
qq_39660799的博客
09-13 6953
我们平时用的表格排序，只相对来说是在在表格中的升序降序。今天就好奇如果系统中实现排序 他是怎么实现的呢。 经过一番折腾查找，真是一看吓一跳，真是感觉蚂蚁看大象，发现排序分为： 今天仅整理了最简单的两种排序。。。 先来看下定义和实现的方法吧。 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据
zxing.java源码解析-tools-favorite:各种优秀资料、神器及框架整理在此，毕竟好记性不如烂键盘，此项目可以作为自己的不时之
06-06
本人喜欢折腾，记录的东西也比较杂，各方面都会有一些，内容按重要等级排序，大家各取所需。 [#本文地址转自github] 整理的GitBook版本，阅读体验更佳： 目录 资料篇 技术站点 在线学习：、、、、、 ：非常棒的针对...
zxing.java源码解析-be-a-professional-programmer:成为一名专业的程序员
06-06
本人喜欢折腾，记录的东西也比较杂，各方面都会有一些，内容按重要等级排序，大家各取所需。 这里的东西会持续积累下去，欢迎Star，也欢迎发PR给我。 整理的GitBook版本，阅读体验更佳： 目录 资料篇 技术站点 在线...
zxing.java源码解析-Be-a-Professional-Programmer:成为专业程序员路上用到的各种优秀资料、神器及框架htt
06-06
本人喜欢折腾，记录的东西也比较杂，各方面都会有一些，内容按重要等级排序，大家各取所需。 这里的东西会持续积累下去，欢迎Star，也欢迎发PR给我。 整理的GitBook版本，阅读体验更佳： 目录 资料篇 技术站点 在线...
LCR 155. 将二叉搜索树转化为排序的双向链表
weixin_61067952的博客
07-09 197
中序遍历可以得到排序的序列，遍历时维护当前节点和前一个节点，改变左右指针。头节点设为null，遍历开始判断一下然后初始化。尾节点中序遍历时一直更新。
算法力扣刷题 三十一【150. 逆波兰表达式求值】
danaaaa的博客
07-04 690
后缀表示法。
IODD简介（1）
了不起的小白君的博客
07-04 490
XML文件通常是以纯文本形式存储的，通过标签、元素、属性等概念来组织和表达数据结构及其内容。这些标签可以是用户自定义的，允许创建符合特定数据结构的标签，XML相比HTML更加灵活，可以通过用户自定义的标签来描述更复杂的结构。IODD文件内容由XML（Extensible Markup Language）可扩展标记语言实现，用于描述文档的结构和数据的含义，其设计目的是用于数据传输和存储，以及在不同系统和应用之间进行数据交换。生成IODD文件，需要先熟悉协议栈所规定的数据类型（用于自定义各种参数的数据类型）。
leetcode--验证二叉搜索树
最新发布
liulanba的博客
07-09 335
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
数据结构笔记之时间复杂度
weixin_67855163的博客
07-06 115
数据结构笔记之时间复杂度
文章检查敏感词速度提升10倍+
陈海龙的格物之路
07-09 415
如何对文章进行高效的敏感词检查？
Lecture+3-2+List结构的排序编程1
08-04
"本次讲座主要讲解了排序算法的编程实现，特别是针对List结构的排序，包括插入排序(InsertionSort)和归并排序(Mergesort)。讲座还涉及到了函数式编程的一些概念，如整数比较函数compare和判断列表是否有序的函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值