[PHP] pobierz, plaintext 
$tablica = 
Array
(
    [http://serwer1.pl] => Array
        (
            [server] => [url="http://serwer1.pl"]http://serwer1.pl[/url]
            [load] => 0.20
            [memory_free] => 1893
            [memory_usage] => 154
            [cpu%_usage] => 2
        )
 
    [http://serwer2.pl] => Array
        (
            [server] => [url="http://serwer2.pl"]http://serwer2.pl[/url]
            [load] => 0.44
            [memory_free] => 1925
            [memory_usage] => 122
            [cpu%_usage] => 0
        )
 
    [http://serwer3.pl] => Array
        (
            [server] => [url="http://serwer3.pl"]http://serwer3.pl[/url]
            [load] => 0.00
            [memory_free] => 1444
            [memory_usage] => 180
            [cpu%_usage] => 43
        )
 
)
[PHP] pobierz, plaintext 

Podaję przykładową tablice, którą chce posortować.
Chodzi o to że musze wybrać serwer, który jest w danej chwili najmniej obciążony i wyświetlić jego dane na ekran.

Najpierw wybieramy serwer, który ma najmniej obciążone wszystkie elementy i który nie przekracza load < 1.50, memory_free < 1700, cpu%_usage < 80
Jeśli jest kilka takich serwerów, które nie przekraczają tych granic wybieramy z nich serwer (klucz tablicy), który ma najmniej obciążony ram (memory_free), a nastepnie load.
Jeśli wszystkie serwery przekroczyły load < 1.50, memory_free < 1700, cpu%_usage < 80 to również sprawdzamy który ma najmniej obciążony ram oraz load i ten serwer wybieramy.

Dodam, że nie wiem ile będzie tych serwerów w danej chwili. Dlatego trzeba liczyć ile ich jest, a nie na sztywno wypisać bo tak to można później zrobić funkcja min();

Zaczynam w php i nie wiem jak to posortować wszystko aby dobrze działało.

Musiałbyś napisać własny komparator (funkcja sortująca) i użyć uasort (przykład w manualu). Poza tym pojawia się pewien niewielki problem, mianowicie mamy 3 kryteria sortowania, musiałbyś najlepiej określić priorytety (i/lub) proporcje ważności każdego kryterium.

coś na kształt
$index = 0;

for( tu wiadomo... ) {
if( $array[$i]['load'] < $array[$index]['load'] )
$index = $i;
else if( $array[$i]['memory_usage'] < $array[$index]['memory_usage'] )
$index = $i;
...
}

jeśli głównie kryterium (tu: load) jest takie same to leci po następnym (tu: memory_usage)

--- edit

lub jak wyżej - sortowanie z funkcją (usort)

Sprawa jest banalna .
Moja propozycja to sortowanie przez "wstawianie". poszukaj w google.
Odradzam sortowanie rekurencyjne chyba że tablica będzie nieduży.

~-jarek- problem nie leży w doborze algorytmu sortowania, a w doborze klucza, a właściwie wag dla poszczególnych kryteriów sortowania, a tych jest kilka:
- ogólne obciążenie
- zużycie pamięci
- zużycie procesora

Autorowi wątku doradzam jednak skorzystanie z gotowych mechanizmów load balancingu dla serwerów.
http://content.websitegear.com/article/load_balance.htm
http://www.javaworld.com/javaworld/jw-10-2...alancing-1.html

Właściwie, jaki jest cel tego projektu?

Na aktualny poziom, na którym się znajduje w php to zrobiłem taki skrypt, który wybiera najbardziej obciążony serwer. Wykorzystałem znane mi funkcje.
Byłbym wdzięczny za jakaś lepszą wersje tego.

[PHP] pobierz, plaintext 
		// testowe tablice
		$servers2[] = array('server' => 'http://jakistestowy2.pl', 'load' => '1.66', 'upload' => '60.31', 'download' => '90.50', 'memory_free' => '1300', 'memory_usage' => '700', 'cpu%_usage' => '40');
		$servers2[] = array('server' => 'http://jakistestowy.pl', 'load' => '0.44', 'upload' => '20.01', 'download' => '30.00', 'memory_free' => '1700', 'memory_usage' => '300', 'cpu%_usage' => '16');
 
		$servers2[] = array('server' => 'http://jakistestowy3.pl', 'load' => '0.78', 'upload' => '100.00', 'download' => '70.65', 'memory_free' => '1000', 'memory_usage' => '1000', 'cpu%_usage' => '60');
 
		$servers = $servers2;
 
		echo '<b>Przykładowe serwery:</b> <br />';
		print_r($servers);
 
		echo '<br /><br />';
 
		// liczymy ile jest serwerów
		$ile_serwerow = count(array_keys($servers));
 
		// definiujemy tablice
		$tablica_load = array();
		$tablica_upload = array();
		$tablica_download = array();
		$tablica_memory_free = array();
		$tablica_memory_usage = array();
		$tablica_cpu_usage = array();
 
		// tworzymy tablice parametrów
		for ($i=0; $i<$ile_serwerow;$i++) 
		{
			$tablica_load[$servers[$i]['server']] = $servers[$i]['load'];
			$tablica_upload[$servers[$i]['server']] = $servers[$i]['upload'];
			$tablica_download[$servers[$i]['server']] = $servers[$i]['download'];
			$tablica_memory_free[$servers[$i]['server']] = $servers[$i]['memory_free'];
			$tablica_memory_usage[$servers[$i]['server']] = $servers[$i]['memory_usage'];
			$tablica_cpu_usage[$servers[$i]['server']] = $servers[$i]['cpu%_usage'];
		}
		echo '<b>Wyświetlamy tablice parametrów:</b> <br />';
		print_r($tablica_load);
		echo '<br />';
		print_r($tablica_upload);
		echo '<br />';
		print_r($tablica_download);
		echo '<br />';
		print_r($tablica_memory_free);
		echo '<br />';
		print_r($tablica_memory_usage);
		echo '<br />';
		print_r($tablica_cpu_usage);
		echo '<br /><br /><br /><br />';
 
 
		// wybieramy serwery, które nie przekraczają określonych wartości
		$tablica_load2= array();
		foreach($tablica_load as $klucz_load => $wartosc_load) 
		{
			if($wartosc_load < '1.50')
			{
				$tablica_load2[$klucz_load] = $wartosc_load;
			}
		}
 
		$tablica_upload2= array();
		foreach($tablica_upload as $klucz_upload => $wartosc_upload) 
		{
			if($wartosc_upload < '95.00')
			{
				$tablica_upload2[$klucz_upload] = $wartosc_upload;
			}
		}
 
		$tablica_download2= array();
		foreach($tablica_download as $klucz_download => $wartosc_download) 
		{
			if($wartosc_download < '90.00')
			{
				$tablica_download2[$klucz_download] = $wartosc_download;
			}
		}
 
		$tablica_memory_free2= array();
		foreach($tablica_memory_free as $klucz_memory_free => $wartosc_memory_free) 
		{
			if($wartosc_memory_free > '100.00')
			{
				$tablica_memory_free2[$klucz_memory_free] = $wartosc_memory_free;
			}
		}
 
		$tablica_memory_usage2= array();
		foreach($tablica_memory_usage as $klucz_memory_usage => $wartosc_memory_usage) 
		{
			if($wartosc_memory_usage < '1900.00')
			{
				$tablica_memory_usage2[$klucz_memory_usage] = $wartosc_memory_usage;
			}
		}
 
		$tablica_cpu_usage2= array();
		foreach($tablica_cpu_usage as $klucz_cpu_usage => $wartosc_cpu_usage) 
		{
			if($wartosc_cpu_usage < '90.00')
			{
				$tablica_cpu_usage2[$klucz_cpu_usage] = $wartosc_cpu_usage;
			}
		}
 
		unset($tablica_load);
		unset($tablica_upload);
		unset($tablica_download);
		unset($tablica_memory_free);
		unset($tablica_memory_usage);
		unset($tablica_cpu_usage);
 
		echo '<b>Serwery, które nie przekraczają określonych wartości:</b> <br />';
		print_r($tablica_load2);
		echo '<br />';
		print_r($tablica_upload2);
		echo '<br />';
		print_r($tablica_download2);
		echo '<br />';
		print_r($tablica_memory_free2);
		echo '<br />';
		print_r($tablica_memory_usage2);
		echo '<br />';
		print_r($tablica_cpu_usage2);
		echo '<br /><br /><br /><br />';
 
 
		// wybieramy najmniejsze wartości z tych serwerów które nie przekroczyły wartości maksymalnych
 		// od najmniejszej do największej
		function cmp($a, $b) 
		{
			if ($a == $b) 
			{
					return 0;
			}
			return ($a < $b) ? -1 : 1;
		}
		// od największej do najmniejszej
 		function cmp2($a, $b) 
		{
			if ($a == $b) 
			{
					return 0;
			}
			return ($a > $b) ? +1 : 1;
		}
		// najmniejsza wartość
		uasort($tablica_load2, 'cmp');
		uasort($tablica_upload2, 'cmp');
		uasort($tablica_download2, 'cmp');
		uasort($tablica_memory_free2, 'cmp2');
		uasort($tablica_memory_usage2, 'cmp');
		uasort($tablica_cpu_usage2, 'cmp');
 
		echo '<b>Serwery posortowane według najmniejszego obciażenia:</b> <br />';
		print_r($tablica_load2);
		echo '<br />';
		print_r($tablica_upload2);
		echo '<br />';
		print_r($tablica_download2);
		echo '<br />';
		print_r($tablica_memory_free2);
		echo '<br />';
		print_r($tablica_memory_usage2);
		echo '<br />';
		print_r($tablica_cpu_usage2);
		echo '<br /><br /><br /><br />';
 
 
		// wybieranie wartości z najmniej obciazonych serwerów
		list ($klucz_load, $wartosc_load) = each ($tablica_load2);
		$serwer_load = $klucz_load;
 
		list ($klucz_uplaod, $wartosc_upload) = each ($tablica_upload2);
		$serwer_upload = $klucz_uplaod;
 
		list ($klucz_download, $wartosc_download) = each ($tablica_download2);
		$serwer_download = $klucz_download;
 
		list ($klucz_memory_free, $wartosc_memory_free) = each ($tablica_memory_free2);
		$serwer_memory_free = $klucz_memory_free;
 
		list ($klucz_memory_usage, $wartosc_memory_usage) = each ($tablica_memory_usage2);
		$serwer_memory_usage = $klucz_memory_usage;
 
		list ($klucz_cpu_usage, $wartosc_cpu_usage) = each ($tablica_cpu_usage2);
		$serwer_cpu_usage = $klucz_cpu_usage;
 
 
		// tablica najmniej obciążonych serwerów
		$tablica_najmniej_obciazone = array($serwer_load, $serwer_upload, $serwer_download, $serwer_memory_free, $serwer_memory_usage, $serwer_cpu_usage);
 
		echo '<b>Tablicza najmniej obciazonych serwerow:</b> <br />';
		print_r($tablica_najmniej_obciazone);
		echo '<br /><br />';
 
		// zliczanie wystepowania
		$tablica_najczesciej_wystepuje = array_count_values($tablica_najmniej_obciazone);
 
				echo '<b>Najczesciej wystepujace:</b> <br />';
		print_r($tablica_najczesciej_wystepuje);
 
		// pobieranie 1 klucz
		list ($klucz_serwer, $wartosc_serwer) = each ($tablica_najczesciej_wystepuje);
		$serwer = $klucz_serwer;
 
		echo '<br /><b>Wreszcie koniec. Ten serwer jest najmniej obciazony: '.$serwer.'</b>';
[PHP] pobierz, plaintext 

Wiem, że da się to zawrzeć o połowę mniej kodu ale cóż. Pierwsza wersja jest.

Radzę poczytać o możliwościach php w kwestii zabawy z tablicami bo Twój kod to masakra poczytaj też o min(), max()

Dlatego właśnie jest to najlepszy algorytm do tego celu.