数据结构学习笔记一：简单排序与查询算法

 

 

很悲剧，写的好多东西，到源代码那儿想改个属性的，结果没了一大半，就这样了凑合着吧

选择排序的原理

        public void SelectionSort(int[] arr)
        {
            int temp;
            int min;
            for (int outer = 0; outer <= arr.GetUpperBound(0); outer++)
            { 
                min=outer;
                for (int inner = outer + 1; inner <= arr.GetUpperBound(0); inner++)
                {
                    if (arr[min] > arr[inner])
                    {
                        temp = arr[min];
                        arr[min] = arr[inner];
                        arr[inner] = temp;
                    }
                }
            }
        }

 

冒泡排序的原理：

（1）比较arr[0],arr[1]，如果arr[0]>arr[1]，则交换

（2）比较arr[i-1],arr[i]，如果arr[i-1]>arr[i]，则交换直到i=n-1，这样最大的一个数就在最右边a[n-1]中了

（3）重复（1）（2）到n-i

        public void BubbleSort(int[] arr)
        {
            int temp;
            for (int outer = arr.GetUpperBound(0); outer >= 1; outer--)
            {
                for (int inner = 0; inner < outer; inner++)
                { 
                    if(arr[inner]>arr[inner+1])
                    {
                        temp = arr[inner];
                        arr[inner] = arr[inner + 1];
                        arr[inner + 1] = temp;
                    }
                }
            }
        }

插入排序的原理：与冒泡和选择排序不同，插入排序主要是移动，打过斗地主的都知道，首先手上有一张牌准备插入第二张是，要按照大小顺序排序，一旦插入，就是一个已排序的序列，难的是该插在哪儿，所以要一个个的比较然后移动到合适位置插入。

        public void InsertionSort(int[] arr)
        {
            int temp;
            int inner;
            for (int outer = 1; outer <= arr.GetUpperBound(0); outer++)
            {
                inner = outer;
                temp = arr[outer];
                while (inner > 0 && temp < arr[inner - 1])
                {
                    arr[inner] = arr[inner - 1];
                    inner--;
                }
                arr[inner] = temp;
            }
        }

 

两种简单的查找算法：

顺序查找：适合未排序的数列

        public int LinearSearch(int[] arr, int elem)
        {
            for (int i = 0; i <= arr.GetUpperBound(0); i++)
            {
                if (arr[i] == elem)
                    return i;
            }
            return -1;
        }

 

二分查找：适合已排好序的

（1）递归方式

        public int BinarySearch(int[] arr, int elem,int low,int high)
        {
            int mid = (low + high) / 2;
            if (low > high) return -1;
            else
            {
                if (arr[mid] > elem)
                    return  BinarySearch(arr, elem, low, mid - 1);
                else if (arr[mid] < elem)
                    return  BinarySearch(arr, elem, mid + 1, high);
                else
                    return mid;
            }
        }

 

（2）迭代方式

        public int BinarySearch(int[] arr,int elem)
        { 
            int low=0;
            int high=arr.GetUpperBound(0);
            int mid;
            while (low <= high)
            { 
                mid=(low+high)/2;
                if (arr[mid] == elem)
                    return mid;
                if (arr[mid] > elem)
                    high = mid - 1;
                if (arr[mid] < elem)
                    low = mid + 1;
            }
            return -1;
        }

 

递归与迭代：迭代（一般循环实现）效率更高，递归（调用自己）的层次性更强，让读者更容易理解，但速度不敢恭维。

总结：了解递归和迭代，基础排序和查找算法，为以后的高级算法做准备。