一种奇特有效的新排序法__张仰彪第三排序法问世, 欢迎大家来评判

[zhangyangbiao513211]

张仰彪第三排序法

张仰彪第三排序法的原理：它将待排序数组内的数据以两个为一对进行处理，排序的过程可以分成两种不同的步骤：
a步骤是将各对数据进行比较和交换。
b步骤是在各对数据之间进行比较和交换。
a、b两种步骤交替进行，直到发现其中一个步骤完成后，接下来的另一个步骤没有交换数据，此时数组内各对数据自身都已有序，并且各对数据之间也已经有序，排序完毕。
这个排序法如果要遇到麻烦，那一定是在待排序数组内数据总数的奇偶上，因为如果数组内数据的总数是偶数，那就正好可以分成一对一对的，这种情况似乎比较好处理。但如果数组内数据的总数是奇数，那么按对划分数据时最后必然有一个数据是单个的，无法成对，这种情况似乎较难处理，或者需要多写很多行代码去单独处理这种情况，其实不然。
由于本排序法的独特原理，它的两个交替的排序步骤a和b其实是类似的两个处理过程，只是它们所处理的数据沿着数组的长度方向正好错开了一个数据的位置，这对于处理数据的总数是奇数的数组反而更有利，所以在for( )循环的循环上限上无论奇、偶数组都是i< =n-1，这一点至关重要，提请各位看官仔细体会这一点。

下面给出张仰彪第三排序法的C语言代码：
-----------------------------------------------------------------------------------------------------
# include < stdio.h >
void main ( )
{
int a [10]；
int i； /* 记录排序的当前位置，并用于输入输出 */
int j= -1 , t= -1； /* 记录一次排序循环中交换数据的次数 */
int temp； /* 数据交换时的存储中介 */

printf ( " Input 10 numbers：\n" )；
for ( i＝0；i < 10；i++ ) /* 输入任意10个整数 */
scanf ( " %d"，&a[i] )；
printf ( " \n" )；




while(j>0 || t>0) /* 如果数据对内部排序或数据对之间排序曾交换数据*/
{
j = 0; /* 先清零 */
for ( i = 0；i < =8；i +=2 ) /* 从头至尾，逐对排序 */
{
if ( a[i] > a[i+1] )
{
temp = a[i]；
a[i] = a[i+1]；
a[i+1] = temp；
j++; /* 记住有了一次数据交换 */
}
}
if(j= =0 && t!= -1) break; /* t= -1说明是头一个排序步骤，此时即使数
据对内部有序，还要检查数据对之间是否有序*/

t=0; /* 先清零 */
for ( i = 1；i < =8；i +=2 ) /* 从第二至尾，在各对数据之间排序 */
{
if ( a[i] > a[i+1] )
{
temp = a[i]；
a[i] = a[i+1]；
a[i+1] = temp；
t++; /* 记住有了一次交换 */
}
}
if(t= =0) break;
}

printf ( " The sorted numbers is：\n" )；
for ( i＝0；i < 10；i ++ ) /* 输出排好序的10个整数 */
printf ( " %d"，a[i] )；
printf ( " \n" )；
}
--------------------------------------------------------------------------------------------------
下面是本排序法的算法例子。

{ 4， 5， 2， 4， 1， 3，0，2， 2，0 }
第1步： 数据对之内排序，只有最后一对数据“2和 0”要进行交换，
数组现在变为：

{ 4， 5， 2， 4， 1， 3，0，2， 0，2 }
第2步： 数据对之间排序，各数据对之间都要进行交换，
数组现在变为：

{ 4， 2， 5， 1， 4， 0，3，0， 2，2 }
第3步： 数据对之内排序，前四对数据要进行交换，
数组现在变为：

{ 2， 4， 1， 5， 0， 4，0，3， 2，2 }
第4步： 数据对之间排序，各数据对之间都要进行交换，
数组现在仍为：

{ 2， 1， 4， 0， 5， 0，4，2， 3，2 }
第5步： 数据对之内排序，各对数据都要进行交换，
数组现在变为：

{ 1， 2， 0， 4， 0， 5，2，4， 2，3 }
第6步： 数据对之间排序，各数据对之间都要进行交换，
数组现在变为：

{ 1， 0， 2， 0， 4， 2，5，2， 4，3 }
第7步： 数据对之内排序，各数据对之间都要进行交换，
数组现在变为：

{ 0， 1， 0， 2， 2， 4，2，5， 3，4 }
第8步： 数据对之间排序，只有第二和第三数据对之间不需要进行交换，
数组现在变为：

{ 0， 0， 1， 2， 2， 2，4，3， 5，4 }
第9步： 数据对之内排序，第四、第五数据对内部要进行交换，
数组现在变为：

{ 0， 0， 1， 2， 2， 2，3，4， 4，5}
第10步： 数据对之间排序，所有数据对之间都不需要进行交换
数组现在仍为：

{ 0， 0， 1， 2， 2， 2，3，4， 4，5}
发现一个排序步骤没有进行数据交换，排序完毕。
-----------------------------------------------------------------------------------------------------

可以看出，此排序法的空间效率与冒泡排序法是相当的，至于时间效率经过计算，与冒泡排序法也是基本相同的，以待排序数组{6，5，4，3，2，1，0}为例：
这个数组对于冒泡排序法和本排序法都是最坏情况，冒泡排序法处理此数组需要六次排序大步骤，要比较数据6+5+4+3+2+1=21次，交换数据也是21次，本排序法同样如此。经过演算，本排序法处理上述完全倒置排序数组需要八次排序大步骤，要比较数据24次，交换数据21次。由此可见二者相差无几。
而且此排序法具有很高的智能，尤其对有序数组，两次循环后就可以发现所有数据对的内部和数据对之间都不需要交换，从而判定此待排序数组已经有序，而立即结束排序。
这一点尤其适合银行、社保等部门内用来处理海量的ID号等数据，这些数据在99.99%的概率下是有序的，但为了万无一失也要进行排序。此时本排序法将是最合适的，因为在99.99%的情况下它只循环两次就结束，比任何一种现有的排序法都快。
本排序法原理极其简单、独特，同时空间效率和时间效率都不低，并且具有一定的智能，是一种很好的新排序法，值得关注。

简单就是美。


< 完 >

[llg84]

算法简单来说就是：
步骤1：组对方式:01 | 23 | 45 | 67 | 89，对同组两个数据排序
步骤2：组对方式:0 | 12 | 34 | 56 | 78 | 9，对同组两个数据排序
步骤3：如果步骤1或步骤2中交换过数据，则返回步骤1，否则排序完毕
应该没弄错吧？

[llg84]

如果我上面的理解没错，这就是奇偶排序算法吧？

[stroustrupfans]

你这算法完全就是冒泡算法，只不过细节过程调整了，

把你的那组数为例

4， 5， 2， 4， 1， 3，0，2， 2，0

你的算法就是把他们先排成左右两队

4 5
2 4
1 3
0 2
2 0

注意数据次序是从左到右，到左斜下方，到右，到左斜下方，。。。对吧？第偶数个数据在左队，第奇数个数据在右队

你的算法就是，分偶数趟和奇数趟，偶数趟是左右两队的数据水平一组一组比较交换

至于楼主说的“此排序法具有很高的智能，尤其对有序数组，两次循环后就可以发现所有数据对的内部和数据对之间都不需要交换，从而判定此待排序数组已经有序，而立即结束排序。 ”，经典排序法同样如此，不信楼主你可以仔细验算一下。

结论：

楼主改变了经典冒泡法的冒泡顺序，作为初学者，这是很有趣的发现，但这个变体在性能上，无论平均还是最好情况都没有任何提高。

[stroustrupfans]

你这算法完全就是冒泡算法，只不过细节过程调整了，

把你的那组数为例

4， 5， 2， 4， 1， 3，0，2， 2，0

你的算法就是把他们先排成左右两队

4 5
2 4
1 3
0 2
2 0

注意数据次序是从左到右4->5，到左斜下方2，到右4，到左斜下方1，。。。对吧？第偶数个数据在左队，第奇数个数据在右队

你的算法就是，分偶数趟和奇数趟，偶数趟是左右两队的数据水平一组一组比较交换，就是右边轻的冒泡到左边，奇数趟是左边数据和斜上方右边数据一组一组地比较交换，就是左边轻的冒泡到右边斜上方，这两个过程结合起来，轻的就从右到左，到右斜上方，再到左，沿这样的路径冒泡到顶部。

4 5
2 4
1 3
0 2
2 <- 0

右边的一起向左边水平冒泡，只有0冒泡成为

4 5
2 4
1 3
0 2
0 2

左队的2，1，0，0一起向右队斜上方冒泡，

4 5
/
2 4
/
1 3
/
0 2
/
0 2


成为

4 2
5 1
4 0
3 0
2 2


而经典的冒泡算法是，

4 5
2 4
1 3
0 2
2 0
---

从最低端数据开始，水平一组冒泡，0冒泡到左边，再右斜上一对冒泡，0继续冒泡到右边倒数第二列，。。。一直到顶端水平一对数据也冒泡，最轻的就到了第一个位置，重复这个过程。。。

可见，楼主的算法和经典的算法都是冒泡过程，只是冒泡的具体顺序不同，经典算法是一个泡从最低端一路冒上来，而楼主算法是同时有很多泡冒泡，但整个算法在速度上是相同的。


至于楼主说的“此排序法具有很高的智能，尤其对有序数组，两次循环后就可以发现所有数据对的内部和数据对之间都不需要交换，从而判定此待排序数组已经有序，而立即结束排序。 ”，经典排序法同样如此，不信楼主你可以仔细验算一下。

结论：

楼主改变了经典冒泡法的冒泡顺序，作为初学者，这是很有趣的发现，但这个变体在性能上，无论平均还是最好情况都没有任何提高。

[zhangyangbiao513211]

确实与已有的奇偶排序法类似，很遗憾
不知道名字就搜索不到，知道了名子就搜到了。
不过，我看了我搜到的奇偶排序法程序，写得晦涩难懂。
而且，它的排序循环结束条件不对，
它是判断如果发现连续出现两次排序步骤没有交换数据就结束排序，
这虽然对，但会多进行一次循环，
因为有一次排序步骤没有交换数据就可以结束排序，
但必须判断这个没有交换数据的排序步骤是不是开始排序后的第一个步骤。
我开始也没注意到这个问题，后来才发现。
我的程序里解决了这个问题，
所以还是有一点进步，
所以不如改叫“张仰彪奇偶排序法”为宜。
人过留名，雁过留声。

[zhangyangbiao513211]

//这是我搜到的奇偶排序程序
//奇偶排序(课外)
int sort13(int num[],int n)
{
int k=0,t=1;
int low=0,high=n-1;
while(low<high&&t)
{
t=0;
for(int i=low;i<high;i++)
if(num[high]<num[i])
{
num[high]=num[high]+num[i];
num[i]=num[high]-num[i];
num[high]=num[high]-num[i];
k+=3;t=1;
}
high--;
for(i=high;i>low;i--)
if(num[low]>num[i])
{
num[low]=num[low]+num[i];
num[i]=num[low]-num[i];
num[low]=num[low]-num[i];
k+=3;t=1;
}
low++;
}
return k;
}

[zhangyangbiao513211]

//Java代码
class OETransSortAlgorithm extends SortAlgorithm {
void sort(int a[]) throws Exception {
pause(0,a.length-1);
for (int i = 0; i < a.length/2; i++ ) {
if (stopRequested) {
return;
}
for (int j = 0; j+1 < a.length; j += 2)
if (a[j] > a[j+1]) {
int T = a[j];
a[j] = a[j+1];
a[j+1] = T;
}
pause(); pause();
for (int j = 1; j+1 < a.length; j += 2)
if (a[j] > a[j+1]) {
int T = a[j];
a[j] = a[j+1];
a[j+1] = T;
}
pause(); pause();
}
pause(-1,-1);
}
}

[chenzhiyubuaa]

我觉得这样的帖子可以删了

[dext]

楼主 在基本有序的情况下，冒泡的效率也是O(n)
大家也都知道，对于有序情况和元素较少的情况冒泡是很有效率的。

我没有看你的算法，但我还是鼓励创新的。

[yaos]

楼主有时间买

国防工业出版社的
周建钦 超快速排序算法

读懂了里面的算法
再来发表你的心得

[abc130314]

鼓励创新~~~~
支持楼住~~~~
这样的创新精神，才是中国未来计算机事业的希望啊~~
就算这个算法以前有人想出来来了。
但是，你能自己想出这么一套算法，也是值得赞扬啊
继续努力，继续加油！！！
支持你，不过不要因为这点成绩就沾沾自喜哦~~

[yaos]

整数排序最好的是箱排序
同样的字符串排序也是

[yuhaoloen]

这个算法貌似2路归并排序....

[ahjoe]

有趣的想法。不过效率不会高。

[netbaronly]

目下只要知道
bubble(n)
heap(Nlog2N)
btree(Nlog2N-N)
三种排序就够了
怎么都高不过Nlog(N!)

[knowledge_Is_Life]

等待牛人来答.

[morilasi]

原来第三排序法在这儿，研究一下有啥改进

[hyram]

精神可嘉，楼主要继续努力.
要提出一种新的算法，楼主应该更加严谨一些，1，2楼的工作至少应该避免，个人的主观评价似乎也太多了一些。
技术上来说，对这样的数组：1，1，1，1，9，8，7，6，1，1，1，1。 9，8，7，6这些数会被首先无效的左移，这种无效操作在其他任何排序算法中都是很少见的。

[xsir317]

2b又出现了。。。。。。

[sdbradycn]

输入 1 2 3 4 5 6 7 8 99 4 排序的结果是： 1 2 3 4 5 6 7 8 99 4 怎么解释这个程序？？？？这是我的测试数据。