关闭

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

1068人阅读 评论(0) 收藏 举报

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;
            }


        }
 

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:67324次
    • 积分:864
    • 等级:
    • 排名:千里之外
    • 原创:18篇
    • 转载:4篇
    • 译文:0篇
    • 评论:26条
    最新评论