100分，谁先做出来全给谁！算法

Question

是个老题目了，只是想不到怎么做。求数组中大于左边，小于右边的元素，除了首元素和尾元素，如{4，1，2，5，8，6，9} 则输出5；数组中可能不止一个符合条件的元素；
要求用一重for循环做

Answer 1

static void SearchMid(ref int[] a)    
{    
    int Cou=a.Length-1;     
    int Maxflag=a[0];           
    for(int i=1;i<Cou;i++)    
    {    
        for(;a[i]<=Maxflag&&i<Cou;i++){}        //在前i元素中找最大元素    
        if(i<Cou)    
        {       
                  for(int j=i+1;a[i]<a[j]&&i<Cou;j++)  //向后排查    
                  {    
                       Maxflag=a[j];    
                       if(j==Cou)    
                        {        
                           Console.WriteLine("{0}", a[i]);  //输出元素    
                           break;    
                         }    
                  }    
                  if(i<Cou) Maxflag=a[i];            //如果for条件不成立且,  
                     
        }    
        
    }       
} 
这是我做的，代码太多了

Answer 2

int[] arr ={4，1，2，5，8，6，9};int ln = arr.length;
for(int i=1;i<ln-1;i++){
   if( arr[i-1]<arr[i] && arr[i]<arr[i+1]){
     Console.Write(arr[i]);
   }}

Answer 3

int[] arr ={4，1，2，5，8，6，9};int ln = arr.length;
for(int i=1;i<ln-1;i++){
   if( arr[i-1]<arr[i] && arr[i]<arr[i+1]){
     Console.Write(arr[i]);
   }}

Answer 4

int[] a = {4,1,2,5,8,6,9};
        List<int> b = new List<int>();        for (int i = 0; i < a.Length; i++)
        {
            if (i != 0 && i != a.Length - 1)
            {
                if (a[i] > a[i - 1] && a[i] < a[i + 1])
                {
                    b.Add(a[i]);
                }
            }
        }

Answer 5

            int[] arr = { 4, 1, 2, 5, 8, 6, 9 };
            List<int> lst;            for (int i = 1; i < arr.Length - 1; i++)
            {
                if (arr[i] > arr[i - 1] && arr[i] < arr[i + 1])
                {
                    lst.Add(arr[i]);
                }
            }
就要这个？

Answer 6

忘记构造List了
        static void Main(string[] args)
        {
            int[] arr = { 4, 1, 2, 5, 8, 6, 9 };
            List<int> lst = new List<int>();            for (int i = 1; i < arr.Length - 1; i++)
            {
                if (arr[i] > arr[i - 1] && arr[i] < arr[i + 1])
                {
                    lst.Add(arr[i]);
                }
            }
        }

Answer 7

没做，有个思路
做个嵌套，就可以用一重for循环做
（其实也不算一重for循环了，而且数组大了伤内存）

Answer 8

 int[] arr = { 4, 1, 2, 5, 8, 6, 9 };
对应的index = {0,1,2,3,4,5,6}//生成一个数组，存着从左到右最大数的index
int[] arrMax = {0,0,0,3,4,4,6}
//生成一个数组 存着从右到左最小数的index
int[] arrMin = {1,1,2,3,5,5,6}只有index=3 时，他是左边过来最大，右边过来最小思路有点乱，不过要吃饭了，呵呵

Answer 9

1。排序；
2。判断数组%2==0, 则取中间位置两个， 否则， 取中间位置一个。需要for么？

Answer 10

楼主的意思是 只大于左边的一个 小于右边的一个 而不是所有。
当是所有的时候 有特别大的几率不存在这个数。
当然了 即便是楼主说的这个 也未必有解。
比如全部都是相同的数 或者一个降序的组合 这样的情况是没解的。
namespace test
{
    class Program
    {
        static void Main(string[] args)
        {
            int [] arr = new int[]{4,1,2,5,8,6,9} ;
            int max = arr.Length - 1, count = 0;
            for (int i = 1; i < max; i++)
            {
                if (arr[i] > arr[i - 1] && arr[i] < arr[i + 1])
                {
                    count++;
                    System.Console.WriteLine(arr[i]);
                }
            }
            if(count == 0)
            {
                 System.Console.WriteLine("没有符合条件的");
            }
        }
    }
}输出：
2
5楼主给分吧

Answer 11

囧，LZ你真想复杂了，害我和3L做的一样都觉得有问题

Answer 12

只要求用一重for循环做，我也暂时还没想出来如何实现。
不过ls还没有正确方法啊。

Answer 13

int[] str = new int[] { 4, 1, 2, 5, 8, 6, 9};List<int> list = str.ToList<int>();IEnumerable<int> e = list.Where<int>(delegate(int de) {
    int index = list.FindIndex(delegate(int d) { return de == d; });
    if (index > 0 && index < list.Count - 1) return de > list[index - 1] && de < list[index + 1];
    return false;
});集合 e 包含了符合条件的数据。(2, 5)不过没用For.

Answer 14

如果是大于所有左边，和大于所有右边IEnumerable<int> e = list.Where<int>(delegate(int de)
{
    int index = list.FindIndex(delegate(int d) { return de == d; });    if (index > 0 && index < list.Count - 1)
    {
        return (            list.Take<int>(index).Where<int>(delegate(int tmp) { return tmp >= de; }).Count<int>() == 0 &&
            list.Skip<int>(index + 1).Where<int>(delegate(int tmp) { return tmp <= de; }).Count<int>() == 0
            );
    }
    return false;
});结果（5）也没用FOR

Answer 15

    static void SearchMid(int[] a)
    {
        int[] b = (int[])a.Clone();
        for (int i = 0; i < a.Length - 1; i++)
        {
            for (int j = i + 1; j < a.Length; j++)
            {
                int temp;
                if (a[j] < a[i])
                {
                    temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
        for (int k = 1; k < a.Length-1; k++)
        {
            if (a[k] == b[k])
                Console.WriteLine(a[k]);
        }    
    }  

Answer 16

这题简单得, 按到题要求写个 循环加条件 不就OK了..尝试下:void float[] Search(params float[] os){
   float[] fs;
   List<float> ls=new List<float>();
   //
   for(int i=0;i<os.Length;i++){
      for(int j=0;j<i;j++){
         if(os[i]>os[j]) continue;
         else break;
         
         for(int k=i;k<os.Length;k++){
            if(os[i]<os[k]) continue;
            else break;
            ls.Add(os[i]);
         }
      }
   }
   //
   ls.CopyTo(fs);
   return fs;
}

Answer 17

没对.. . 以后再说, 而且 也不合楼主 一重for的要求, 一重for的话,有两种可能代替,要么 递归,要么 goto,都可以 是一回事

Answer 18

void float[] Search(params float[] os){ 
  float[] fs; 
  List <float> ls=new List <float>(); 
  // 
  for(int i=0;i <os.Length;i++){ 
      for(int j=0;j <i;j++){ 
        if(os[i]>os[j]&&j<i-1) continue; 
        else (os[i]<=os[j]) break; 
        
        for(int k=i+1;k <os.Length;k++){ 
            if(os[i] <os[k]&&k<os.Length-2) continue; 
            else if(os[i]>=os[k]) break; 
            ls.Add(os[i]); 
        } 
      } 
  } 
  // 
  ls.CopyTo(fs); 
  return fs; 
}这样修改一下,楼主觉得如何, 本人到是似乎觉得好象可以了,SORRY,没测试过..

Answer 19

lz, 动态规划的经典模式, 就是有一张表, 保存了我们需要的信息. 使用时可以查表, 不需要每次都得递归/循环. 所以, 经典的动态规划有两个过程: 
1. 产生动态规划表.
2. 利用表解决问题.而你的问题, 需要这样两张表:假设数组arr长度为n, i为索引.
max[i]返回0 ~ i这前半截数组中最大元素.
min[i]返回i+1 ~ n这后半截数组中的最小元素.然后解决问题: if arr[i] > max[i-1] && arr[i] < min[i], 则arr[i]为一个解.
如何构造max和min表?max和min表的构造也很简单, 动态规划, 你要利用已保存的表值, 不需要每次全部循环.
min[i] = arr[i] < min[i]? arr[i]:min[i];构造这两张表, 只需要循环一次.
很多动态规划算法中, 你可能看不到"构造表" 这个过程, 那是因为有各种各样的优化措施. 可以优化掉, 但"表"还是存在的.你的这个算法, 动态规划做, 时间复杂度可以是O(n), 你目前的解法是O(n^3).算法关键是思想, 不在于"用了几个for", 而是时间复杂度, 空间复杂度.

Answer 20

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace ConsoleApplication6 {
    class Program {
        static void Main( string[] args ) {
            float[] os = new float[] { 4, 1, 2, 5, 8, 6, 9 };
            var v = Search(os);
            foreach (var item in v) {
                Console.WriteLine(item);
                Console.Read();
            }
        }
        static float[] Search( params float[] os ) {
            float[] fs = default(float[]);
            List<float> ls = new List<float>();
            // 
            for (int i = 0; i < os.Length; i++) {
                for (int j = 0; j < i; j++) {
                    if (os[i] > os[j] && j < i - 1) continue;
                    else if (os[i] <= os[j]) break;                    for (int k = i + 1; k < os.Length; k++) {
                        if (os[i] < os[k] && k < os.Length - 2) continue;
                        else if (os[i] >= os[k]) break;
                        ls.Add(os[i]);
                    }
                }
            }
            // 
            fs = new float[ls.Count];
            ls.CopyTo(fs);
            return fs;
        }
    }
}
//已经通过测试 输出为 5

Answer 21

#include<stdio.h>
#define N 7
void main()
{
   int a[N],i;
   for(i=0;i<N;i++)
   scanf("%d",&a[i]);//初始化数组//
   for(i=1;i<N-1;i++)
   if(a[i]>a[i-1]&&a[i]<a[i+1])//找符合要求的元素并输出//
    printf("%d\t",a[i]);
}
呵呵 不知道楼主是不是这个意思 见笑了。

Answer 22

不懂数组,也不懂C#,我试着写了个免循环的.VB.NET代码网页转换来的.呵呵.
private List<int> Lst = new List<int>(); 
private void Button1_Click(System.Object sender, System.EventArgs e) 
{ 
    Interaction.MsgBox(GetN); 
} 
private int GetN() 
{ 
    Lst.Clear(); 
    Lst.AddRange(Ints); 
    Lst.Sort(); 
    if (Lst.Count % 2 != 0) { 
//当数组数量为偶数时
        return Lst((Lst.Count - 1) / 2); 
    } 
    else { 
//当数组数量为奇数时
        return (Lst(Lst.Count / 2) < Lst(Lst.Count / 2 + 1) ? Lst(Lst.Count / 2) : Lst(Lst.Count / 2 + 1)); 
    } 
} 

Answer 23

private List<int> Lst=new List<int>();privatevoid Button1_Click(System.Object sender, System.EventArgs e) 
{ 
    Interaction.MsgBox(GetN); 
}privateint GetN() 
{ 
    Lst.Clear(); 
    Lst.AddRange(Ints); 
    Lst.Sort();if (Lst.Count%2!=0) {//当数组数量为<奇数>时return Lst((Lst.Count-1)/2); 
    }else {//当数组数量为<偶数>时return (Lst(Lst.Count/2)< Lst(Lst.Count/2+1)? Lst(Lst.Count/2) : Lst(Lst.Count/2+1)); 
    } 
}

Answer 24

//这个方法返回的是数组的下标 想得到具体数字 就 return arr[i]
     public static int getIndex(int[] arr)
     {
             int len=arr.length;
             for(int i=1;i<len-1;i++)
             {//最后一个运算下标为len-1
                     int left=0,right=i+1;
                     for(;left<i;left++){
                         //当前值任意一个左边的值大于它时则提前结束
                             if(arr[left]>arr[i])
                             break;
                     }
                     if(left<i)continue; //提前结束外层循环
                         for(;right<len;right++){
                         //当前值任意一个右边的值小于它时则提前结束
                             if(arr[right]<arr[i])
                             break;
                     }
                     if(right==len) //此时已经隐含了 left==i
                         return i;
             }
             return -1;
     }

Answer 25

a[i]>a[i-1]&&a[i] <a[i+1])//对于这个方法，7，8，9，4，9，11，13，12，10
这个数组你能解出来吗

Answer 26

11楼的思路应该没问题.
我再实现一下,你看下:            int[] arr = {4,1,2,5,8,6,9};            int[] arrMax = {-1,-1,-1,-1,-1,-1,-1};
            int[] arrMin = { -1, -1, -1, -1, -1, -1, -1 };            int iMax = arr[0];
            for (int i = 0; i < arr.Length; i++) 
            {
                if (arr[i] > iMax)
                {
                    iMax = arr[i];
                }
                arrMax[i] = iMax;
            }            int iMin = arr[arr.Length-1];
            for (int i = arr.Length - 1; i >= 0;i-- )
            {
                if (arr[i] < iMin)
                {
                    iMin = arr[i];
                }
                arrMin[i] = iMin;
            }            for (int i = 1; i < arr.Length-1; i++)
            {
                if (arr[i] == arrMax[i] && arr[i] == arrMin[i]) 
                {
                    MessageBox.Show(arr[i].ToString());
                }
            }

Answer 27

这是必要条件，不是充分条件。
比如，下面无解，但满足条件的有12345678
位置：0123456789
数值：912345678048楼正解...
也是整体操作的思路，赞一个，
只可惜仍然不符合LZ一重for的要求一重的复杂度是O(n),容易实现的是O(n*n)
着实比较困难啊...

Answer 28

设置一个标志在左边和右边之间的搜索切换就行了。
        static void Main(string[] args)
        {
            int[] arr = new int[] { 1,2,9,8,7,6,5,4,3 };
            List<int> results = new List<int>();            bool isFindingLeft = true;            int index = 1;
            int max = index;            for (int i = 0; i < max; i++)
            {
                if (isFindingLeft)
                {
                    if (arr[index] > arr[i])
                    {
                        if (i == index - 1)
                        {
                            //重新设置索引
                            max = arr.Length;
                            i = index;                            isFindingLeft = false;
                        }
                    }
                    else
                    {
                        System.Console.WriteLine("不符合条件的数{0}：\n", arr[index]);                        //找下一个数
                        index++;
                        if (index == arr.Length - 1)
                            break;                        //重新设置索引
                        max = index;
                        i = -1;
                        
                    }
                }
                else
                {
                    if (arr[index] < arr[i])
                    {
                        if (i == max - 1)
                        {
                            System.Console.WriteLine("符合条件的数{0}：\n", arr[index]);
                            results.Add(arr[index]);
                            
                            //找下一个数
                            index++;
                            if (index == arr.Length - 1)
                                break;                            //重新设置索引
                            max = index;
                            i = -1;                            isFindingLeft = true;
                        }
                    }
                    else
                    {
                        System.Console.WriteLine("不符合条件的数{0}：\n", arr[index]);                        //找下一个数
                        index++;
                        if (index == arr.Length - 1)
                            break;                        //重新设置索引
                        max = index;
                        i = -1;                        isFindingLeft = true;                        
                    }
                }
            }
        }

Answer 29

你把代码COPY了，运行嘛。:Dint[] str = new int[] { 4, 1, 2, 5, 8, 6, 9};List<int> list = str.ToList<int>();IEnumerable <int> e = list.Where <int>(delegate(int de){
    //查找当前数据索引值
    int index = list.FindIndex(delegate(int d) { return de == d; });
    if (index > 0 && index < list.Count - 1)
    {
//返回符合条件的数据
        return (
//从0到当前索引值的集合中没有大于等于当前值的数据
            list.Take <int>(index).Where <int>(delegate(int tmp) { return tmp >= de; }).Count <int>() == 0
&&
//从当前索引值到末尾的集合中没有小于等于当前值的数据
            list.Skip <int>(index + 1).Where <int>(delegate(int tmp) { return tmp <= de; }).Count <int>() == 0
            );
    }
    return false;
}); e集合返回： 5;

Answer 30

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace middle_large
{
    class Program
    {      
        static void  Main(string[] args)
        {  
           int n=10;
           int[] arr = { 1, 6, 3, 4, 5, 7, 10,9,8,9 };
           int[] smaller = new int[n];
           int[] bigger = new int[n];
            int [] middle_members=new int [n];
           int bigger_min;
           int smaller_max;
           int a;
           int i, j, k;           for ( i = 1; i < arr.Length; i++)
           {
              a = -1;
               for ( j = i - 1; j >= 0; j--)
               {
                   smaller[j] = arr[j];
 
               }
               for ( j = i + 1; j < arr.Length; j++)
               {
                   bigger[j] = arr[j];
               }
               for (j = 0; j <= i; j++)
               { bigger[j] = arr[i]; }
                   smaller_max = smaller.Max();
               bigger_min = bigger.Min();
               for (k = 0; k < smaller.Length; k++)
               {
                   smaller[k] = 0;
               }
               for (k = 0; k < bigger.Length ; k++)
               {
                   bigger[k] = 0;
               }
                   if (arr[i] >= smaller_max && arr[i] <= bigger_min)
                       a = arr[i];                   Console.WriteLine(a.ToString());
           }
           // Console.WriteLine(a.ToString ());        }
    }
}

Answer 31

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;namespace middle_large
{
    class Program
    {      
        static void  Main(string[] args)
        {  
           int n=10;
           int[] arr = { 1, 6, 3, 4, 5, 7, 10,9,8,9 };
           int[] smaller = new int[n];
           int[] bigger = new int[n];
            int [] middle_members=new int [n];
           int bigger_min;
           int smaller_max;
           int a;
           int i, j, k;            
           for ( i = 1; i < arr.Length; i++)
           {
              a = -1;
               // put all members before the relevent member in smaller array
               for ( j = i - 1; j >= 0; j--)
               {
                   smaller[j] = arr[j];
 
               }
               // put all members after the relevent member in bigger array
               for ( j = i + 1; j < arr.Length; j++)
               {
                   bigger[j] = arr[j];
               }
               // hlep to get correct answer when finding min .. thats mean to get rid of zeros .
               for (j = 0; j <= i; j++)
               { bigger[j] = arr[i]; }                smaller_max = smaller.Max();
               bigger_min = bigger.Min();
                // clear the smaller and bigger array for the next loop 
               for (k = 0; k < smaller.Length; k++)
               {
                   smaller[k] = 0;
               }
               for (k = 0; k < bigger.Length ; k++)
               {
                   bigger[k] = 0;
               }
               // if the arr[i] larger(bigger) then all members befor it (smaller.max) 
                // and smaller then all members after it (bigger.Min) so take it and its the middle number 
               // and print it out and go to look for the next one.
                   if (arr[i] >= smaller_max && arr[i] <= bigger_min)
                       a = arr[i];                   Console.WriteLine(a.ToString());
           }
           // Console.WriteLine(a.ToString ());        }
    }
}

Answer 32

List<int> arrAdd = new List();
for(int i =1;i<arrExample.Length-1;i++){
    if(arrExample[i]>arrExample[i-1]&&arrExample[i]<arrExample[i+1]){
        arrAdd.Add(arrExample[i]);
    }
}
return arrAdd.ToArray();

Answer 33

结贴，我认为 tangsong78，简单明了，50分
XXChen2的也非常好，30分
xie_yanke的虽然我不懂这个原理，20分

Answer 34

这种考算法的题目，特别是考时间复杂度或者空间复杂度的题目，用这种list等中的方法不好，其实他里面很多方法本身就带有一重或者多种for循环，这种题关键是考自己的算法。当然项目中那就另说了

Answer 35

免循环？？？？哎，算法中说一重for循环更多的是指遍历一次吧。哎