Как найти сначала неповторяющийся символ от строки?

Это можно сделать в гораздо более читаемом коде, используя некоторые стандартные функции PHP:

// Count number of occurrences for every character
$counts = count_chars($string);

// Keep only unique ones (yes, we use this ugly pre-PHP-5.3 syntax here, but I can live with that)
$counts = array_filter($counts, create_function('$n', 'return $n == 1;'));

// Convert to a list, then to a string containing every unique character
$chars = array_map('chr', array_keys($counts));
$chars = implode($chars);

// Get a string starting from the any of the characters found
// This "strpbrk" is probably the most cryptic part of this code
$substring = strlen($chars) ? strpbrk($string, $chars) : '';

// Get the first character from the new string
$char = strlen($substring) ? $substring[0] : '';

// PROFIT!
echo $char;

Python:

def first_non_repeating(s):
 for i, c in enumerate(s):
  if s.find(c, i+1) < 0:
   return c
 return None

То же самое в PHP:

function find_first_non_repetitive($s)
{
 for($i = 0; i < strlen($s); i++) {
  if (strpos($s, $s[i], i+1) === FALSE)
   return $s[i];
 }
}

Это должно заменить ваш код ...

$array = str_split($string);
$array = array_count_values($array);
$array = array_filter($array, create_function('$key,$val', 'return($val == 1);'));
$first_non_repeated_letter = key(array_shift($array));

Изменить: заговорил слишком рано. Вынул array_unique, подумал, что на самом деле отбрасывает повторяющиеся значения. Но порядок символов должен быть сохранен, чтобы можно было найти первый символ.

1- используйте алгоритм сортировки, такой как сортировка слиянием (или быстрая сортировка имеет лучшую производительность с небольшими входными данными)
2- затем управляйте повторяющимися символами

• неповторяющиеся символы будут одиночными
  
• повторяющиеся символы будут сменять друг друга
  

Производительность: сортировка + сравнение
Производительность: O (n log n) + O (n) = O (n log n)
Например

    $string = "abbcabz"

    $string = mergesort ($string)
    // $string = "aabbbcz" 

Затем возьмите первую строку символьной формы, затем сравните со следующей, если совпадение повторяется
перейти к следующему другому символу и сравнить
первый несоответствующий символ не повторяется

Вот функция на Scala, которая это сделает:

def firstUnique(chars:List[Char]):Option[Char] = chars match { 
  case Nil => None
  case head::tail => {
    val filtered = tail filter (_!=head)
    if (tail.length == filtered.length) Some(head) else firstUnique(filtered)
  }
}

scala> firstUnique("abbcabz".toList)
res5: Option[Char] = Some(c)

А вот эквивалент на Haskell:

firstUnique :: [Char] -> Maybe Char
firstUnique [] = Nothing
firstUnique (head:tail) = let filtered = (filter (/= head) tail) in
            if (tail == filtered) then (Just head) else (firstUnique filtered)

*Main> firstUnique "abbcabz"

Just 'c'

Можно решить эту проблему более широко, абстрагируясь от списков вещей, которые можно сравнивать на равенство:

firstUnique :: Eq a => [a] -> Maybe a

Строки - всего лишь один из таких списков.

$str="abbcade";
$checked= array(); // we will store all checked characters in this array, so we do not have to check them again

for($i=0; $i<strlen($str); $i++)
{
    $c=0;
    if(in_array($str[$i],$checked)) continue;

    $checked[]=$str[$i];

    for($j=$i+1;$j<=strlen($str);$j++)
    {
        if($str[$i]==$str[$j]) 
        {
            $c=1;
            break;  
        }
    }
    if($c!=1) 
    {
        echo "First non repetive char is:".$str[$i]; 
        break;
    }
}

Псевдокод:

Array N;

For each letter in string
  if letter not exists in array N
    Add letter to array and set its count to 1
  else
    go to its position in array and increment its count
End for

for each position in array N
  if value at potition == 1
    return the letter at position and exit for loop
  else
    //do nothing (for clarity)
end for

В основном, вы находите все отдельные буквы в строке, и для каждой буквы вы связываете ее с подсчетом того, сколько таких букв существует в строке. затем вы возвращаете первую букву, у которой подсчет равен 1

Сложность этого метода составляет O(n^2) в худшем случае при использовании массивов. Для увеличения производительности можно использовать ассоциативный массив.