使用JavaScript和C#实现常用算法

原文地址http://www.cnblogs.com/taomylife/p/3429240.html,感谢分享!!!

1、快速排序（QuickSort）

JavaScript:

首先，从要排序的序列中先选取一个中间元素作为基准元素，遍历序列中的每一个元素，小于基准元素的放入一个新序列，否则放入另一个新序列；然后，使用递归方式处理每一个得到的新序列，直到得到的新序列不可再分割；最后，将每一层递归得到的新序列和基准元素进行连接。

<script type="text/javascript">
            function quickSort(arr) {
                if(arr.length <= 1) {
                    return arr;
                }
                /*选取一个基准元素*/
                var pivotIndex = Math.floor(arr.length / 2);
                var pivot = arr.splice(pivotIndex, 1)[0];
                /*****************/
                var left = [];
                var right = [];

                for(var i=0; i<arr.length; i++) {
                    if(arr[i] < pivot) {
                        left.push(arr[i]);
                    }
                    else {
                        right.push(arr[i]);
                    }
                }

                return quickSort(left).concat(pivot, quickSort(right));
            }

            alert(quickSort([12,1,4,8,2]).join(','));//'1,2,4,8,12'
        </script>

c#

首先，从要排序的序列中先选取一个中间元素作为基准元素，从序列起始处开始向后循环，循环条件是序列元素小于基准元素，再从序列结尾处向前循环，循环条件是序列元素大于基准元素，将上述循环结束时的元素进行左右交换，这样小于基准元素的元素都在其左边，否则在其右边；然后使用递归用前述方式循环基准元素左右两边的新序列。

namespace TestApp
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int>() { 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1 };
            QuickSort(ref list, 0, list.Count - 1);
            foreach (int item in list)
            {
                System.Console.WriteLine(item.ToString());
            }
            System.Console.ReadKey();
        }

        private static void QuickSort(ref List<int> list, int left, int right)
        {
            if (left < right)
            {
                int i = left;
                int j = right;
                int middle = list[(left + right) / 2];
                while (true)
                {
                    while (i < right && list[i] < middle) { i++; }
                    while (j > 0 && list[j] > middle) { j--; }
                    if (i == j) break;
                    list[i] = list[i] + list[j];
                    list[j] = list[i] - list[j];
                    list[i] = list[i] - list[j];
                    if (list[i] == list[j]) j--;
                }

                QuickSort(ref list, left, i);
                QuickSort(ref list, i + 1, right);
            }
        }
    }
}

2、归并排序（merge sort）

JavaScript

<script type="text/javascript">
            //合并两个已经排好序的数组
            function mergeSortedList(left, right) {
                var result = [];
                var il = 0;
                var ir = 0;

                while(il < left.length && ir < right.length) {
                    if(left[il] < right[ir]) {
                        result.push(left[il++]);
                    }
                    else {
                        result.push(right[ir++]);
                    }
                }

                return result.concat(left.slice(il)).concat(right.slice(ir));
            }

            function mergeSort(list) {
                if(list.length < 2) {
                    return list;
                }

                var middle = Math.floor(list.length / 2),
                    left = list.slice(0, middle),
                    right = list.slice(middle),
                    params = mergeSortedList(mergeSort(left), mergeSort(right));

                //在params头部插入的这两个元素为调用splice方法时传入第一、二个参数
                params.unshift(0, params.length);
                list.splice.apply(list, params);

                return list;
            }

            var arr = [1,4,87,2,1,4,6,9,2,0];

            alert(mergeSort([1,4,87,2,1,4,6,9,2,0]).join(','));
            //使用自带sort方法进行排序
            alert(arr.sort(function(a, b) {return a - b; }).join(','));
        </script>

3、插入排序

JavaScript

1、从逻辑上考虑将序列分成两部分（已排好序的和没排好序的两部分），假定已排好序的为A序列，未排好序的为B序列，排序开始前A序列为空，B序列为整个序列；

2、设置两层for循环，外层按下标从小到大遍历B序列，内层按下标从大到小遍历A序列，A序列的最后一个元素始终是B序列第一个元素的前一个；

3、外层循环每一次遍历时取出一个值compareValue作为B中第一个元素，内层循环从A序列的最后一个开始（currentlyValue）与compareValue进行比较，当currentlyValue大于compareValue时，将currentlyValue赋值给其下一个元素。

<script type="text/javascript">
            function insertationSort(items) {
                var len = items.length,
                    value, //当前要比较的值
                    i, //无序区域下标
                    j; //有序区域下标

                for(i = 0; i < len; i++) {
                    value = items[i];

                    for(j = i - 1; j > -1 && items[j] > value; j--) {
                        items[j + 1] = items[j];
                    }

                    items[j + 1] = value;
                }

                return items;
            }

            alert(insertationSort([5, 2, 4, 6, 0, 1]).join(','));
        </script>

4、选择排序

原理：选定序列中的任意一个元素，将其看成是最小的一个元素，然后和其它元素一一比较，若发现其它元素比较其更小，则交换二者，然后该更小的元素看成是最小元素，再次进行比较，直到序列中每一个元素都进行比较后排序结束。

<script type="text/javascript">
            function swapItem(items, firstIndex, secondIndex) {
                var temp = items[firstIndex];
                items[firstIndex] = items[secondIndex];
                items[secondIndex] = temp;
            }

            function selectionSort(items) {
                var minIndex;

                for(var i = 0; i < items.length; i++) {
                    minIndex = i;
                    for(var j = i + 1; j < items.length; j++) {
                        if(items[j] < items[minIndex]) {
                            minIndex = j;
                        }
                    }

                    if(i != minIndex) {
                        swapItem(items, i, minIndex);
                    }
                }

                return items;
            }

            alert(selectionSort([5,4,2,6,1,0]).join(','));
        </script>

5、冒泡排序

原理：从序列的起始处或结尾处开始，每相邻两个元素进行比较，若前者大于后者，则交换二者，直到比较到序列最后或最前，找到一个最大元素放在最后。每一次对序列遍历都取出一个最大元素（下一次遍历会将上次遍历取出的最大值排除）。

<script type="text/javascript">
            function swap(items, firstIndex, secondIndex){
                var temp = items[firstIndex];
                items[firstIndex] = items[secondIndex];
                items[secondIndex] = temp;
            }

            function bubbleSort1(items) {
                var len = items.length, i, j, stop;

                for(i = 0; i < len; i++) {
                    for(j = 0, stop = len - i; j < stop; j++) {
                        if(items[j] > items[j + 1]) {
                            swap(items, j, j + 1);
                        }
                    }
                }

                return items;
            }

            function bubbleSort2(items) {
                var len = items.length, i, j;

                for(i = len - 1; i  >= 0; i--) {
                    for(j = len - i; j >= 0; j--) {
                        if(items[j] < items[j - 1]) {
                            swap(items, j, j - 1);
                        }
                    }
                }

                return items;
            }

            alert(bubbleSort1([3, 2, 4, 5, 1]).join(','));
            alert(bubbleSort2([3, 2, 4, 5, 1]).join(','));
        </script>