作业:递归实现插入排序和在o(nlgn)时间复杂度内寻找和为定值的两个元素

原创 2007年09月13日 08:11:00

1、递归实现插入排序

基本思想:

可以把插入排序看作递归 地排序A[1..n-1]然后插入a[n]到已经排好序的序列a[1..n-1]中。

一下是实现算法(C#描述,VS205中调试通过)

 

class InsertSort
    
{
        
static void Main(string[] args)
        
int[] array1={15,1,2333,4,5,67,24,645,253,8,9,34,22,100,22,23,45,67};
        ISort(array1, array1.Length);
        
for (int i = 0; i < array1.Length; i++)
        
{
            Console.WriteLine(array1[i]);
        }

        Console.Read();
        }

        
//递归实现插入排序
        static void ISort(int[] a,int n) 
        
{
            
if (n > 2)
                ISort(a, n 
- 1);
            InsertToArray(a[n 
- 1], a, n - 2);
            
        }

        
private static void InsertToArray(int data, int[] a, int last)
        
{
            
while (last>=0 && data < a[last])
            
{
                a[last 
+ 1= a[last];
                last
--;
            }

            a[last 
+ 1= data;
        }


    }

 

2、描述一个时间复杂度为o(nlgn)的算法找到在集合S中和为x的两个元素

基本思想:对集合s进行排序,时间复杂度为o(nlgn)的排序算法有快速排序,堆排序和归并排序。然后对已经排好序的序列进行一遍扫描找到两个元素。使得整个算法的时间复杂度为O(nlogn)。

实现算法(C#描述,VS205中调试通过,采用快速排序)

 

class ElementsInS
    
{
        
static void Main(string[] args)
        
{

           Console.WriteLine(
"请输入数组S中的元素,以","分开");//输入数组S
           string s =Console.ReadLine();  //生成数组S
           string[]   a   =   s.Split(',');   
           List
<int>   ls   =   new   List<int>() ;  
           
foreach(string   t   in   a)   
            
{   
                
int   i;   
                
if(int.TryParse(t,out i))  
                    ls.Add(i);   
            }

                Console.WriteLine(
"请输入数字S:");
                
int x =int.Parse(Console.ReadLine());       //输入和x
                int[] aa = new int[ls.Count];               //从List copy数组s
                ls.CopyTo(aa,0);

                myQuickSort(aa, 
0, ls.Count-1); //先对其进行快速排序时间复杂度为O(nlgn)
            
//以下循环一遍寻找两个元素
                int f = 0;
                
int l = aa.Length-1
                     
while(f<l)   
                        
{   
                             
if(aa[f]+aa[l]   ==   x)   
       
                                 
{
                                    Console.WriteLine(
"已经找到S的俩元素:" + aa[f].ToString() + "" + aa[l].ToString());
                                    
break;   //找到元素 
                                  }

                              
else   if(aa[f]+aa[l]>x)   //两数和大数已知数时,移动尾游标   
                                                --l;   
                              
else   //两数和小于已知数时,   移动头游标   
                                                ++f;   
                         }

                         
if (f >= l)
                         
{
                             Console.WriteLine(
"数组s中没有和为" + x.ToString() + "的俩元素");
                         }


            Console.ReadLine();


        }

   
        
//以下为快速排序

            
private static void Swap(ref int i, ref int j)
            
//swap two integer 
            {
                
int t;
                t 
= i;
                i 
= j;
                j 
= t;
            }


            
public static void Sort(int[] list, int low, int high)
            
{
                
if (high <= low)
                
{
                    
//only one element in array list 
                    
//so it do not need sort 
                    return;
                }

                
else if (high == low + 1)
                
{
                    
//means two elements in array list 
                    
//so we just compare them 
                    if (list[low] > list[high])
                    
{
                        
//exchange them 
                        Swap(ref list[low], ref list[high]);
                        
return;
                    }

                }

                
//more than 3 elements in the arrary list 
                
//begin QuickSort 
                myQuickSort(list, low, high);
            }


            
public static void myQuickSort(int[] list, int low, int high)
            
{
                
if (low < high)
                
{
                    
int pivot = Partition(list, low, high);
                    myQuickSort(list, low, pivot 
- 1);
                    myQuickSort(list, pivot 
+ 1, high);
                }

            }


            
private static int Partition(int[] list, int low, int high)
            
{
                
//get the pivot of the arrary list 
                int pivot;
                pivot 
= list[low];
                
while (low < high)
                
{
                    
while (low < high && list[high] >= pivot)
                    
{
                        high
--;
                    }

                    
if (low != high)
                    
{
                        Swap(
ref list[low], ref list[high]);
                        low
++;
                    }

                    
while (low < high && list[low] <= pivot)
                    
{
                        low
++;
                    }

                    
if (low != high)
                    
{
                        Swap(
ref list[low], ref list[high]);
                        high
--;
                    }

                }

                
return low;
            }


        }
 

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

判断序列中是否存在两个元素之和为x,时间复杂度O(nlgn),算法导论练习2.3,linux纯C实现

#include #include bool binarySearch(int* a, int L, int N) { int fI = 0, lI = L-1, mI = 0; while(...

2011-11-16 ( 从KMP算法体现的思想 和 快排平均时间复杂度为什么是O(nlgn) )

1.从KMP算法体现出的思想 一句话总结:不要去做重复的事情。(或不去做已经做过的事情) 见下图 较长的字符串为文本串,较短的字符串为模式串。 黄色的区域表示对应字符匹配,灰色区域...

逆序数 时间复杂度O(nlgn)

逆序数的定义,摘自百度百科:在一个排列中,如果一对数的前后位置与大小顺序相反,即前面的数大于后面的数,那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。逆序数为偶数的排列称为偶排列;...

java版排序算法简介及冒泡排序以及优化,选择排序,直接插入排序,希尔排序,堆排序,快速排序及其优化前言 2 分类 2 稳定性 3 时间复杂度 4 Java实现版本 5 1、冒泡排序 6 2、选择排序

写在前边滴~~学习小甲鱼视频笔记,链接:http://bbs.fishc.com/portal.php 然后图文并茂,这是我自己的笔记so~~发表出来是为了更快的找到我自己的总结,所以想看官方解释的,...

最长递增子序列优化算法(时间复杂度为nlgn)C++实现

最长递增子序列优化算法(时间复杂度为nlgn) // 最长递增子序列优化算法.cpp : Defines the entry point for the console application. ...

插入排序和时间复杂度下界

1. 核心思想: 将待排序的一组序列分为已排好序的和未排序的两部分;初始状态时,已排序序列仅包含第一个元素,未排序序列中的元素为除第一个元素以外的N - 1个元素,伺候将未排序序列中的元素逐一插入到已...

【学习笔记】python版选择排序和插入排序及时间复杂度分析

选择排序原理:从N个未排序的数据项中选出最小数(这里假设我们按照升序排列),再从剩下的N-1个未排序的数据项中选出最小数,不断重复此过程,直到所有数被拍好序为止。 以下为实现代码: #!/usr/...

删除无序数组中跳跃重复值并排序(时间复杂度为O(n))

问题描述:现you

空间换时间,把递归的时间复杂度降低到O(2n)

递归算法的时间复杂度除非只有前两项,否则都不是线性的,并且相当耗费内存。我们用最常见的的fibonacci数列来说明: function fibonacci(n){ if( n ==...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)