数据结构(C#)_排序算法(插入排序)

这两周也比较忙一些，今天继续我们的系列，将排序算法中的插入排序（包括了直接插入排序和希尔排序），我发现这本电子版的数据结构问题不少，很多代码都是有错误的，不能运行，不知道作者是怎么运行出结果的。而且还配有插图，同时在校对的时候也不是很严格，相同的一个函数，在不同的页中出现，会有变量名不相同的情况。下面我们介绍一下基本的概念：
插入排序：该排序是一种简单的排序方法，基本操作就是将一个记录插入已经排好序的有序表中，从而得到一个新的，记录数增加一的有序表。
希尔排序：又称缩小增量排序(Diminishing Increment Sort),属于插入排序类的一种排序，在时间复杂度上有较大的改进。基本思想是先将整个待排序记录序列分成若干个子序列分别进行直接插入排序，当整个序列基本有序，再对全部记录进行一次直接插入排序。

  1 namespace  Sorting
  2 {
  3    class SortingAlgorithms
  4    {
  5        private int[] arr;
  6        private int upper;
  7        private int numElement;
  8
  9        //初始化数组
 10        public SortingAlgorithms(int size)
 11        {
 12            arr = new int[size];
 13            upper = size - 1;
 14            numElement = 0;
 15        }
 16
 17        //给数组插入元素
 18        public void Insert(int item)
 19        {
 20            arr[numElement] = item;
 21            numElement++;
 22        }
 23
 24        //打印数组元素
 25        public void DisplayElement()
 26        {
 27            for (int i = 0; i <= upper; i++)
 28            {
 29                Console.Write(arr[i] + " ");
 30            }
 31            Console.ReadLine();
 32        }
 33
 34        public void CleaArry()
 35        {
 36            for (int i = 0; i <= upper; i++)
 37            {
 38                arr[i] = 0;
 39                numElement = 0;
 40            }
 41        }
 42
 43        //选择排序，数据量大的时候效率较高
 44        public void SelectionSort()
 45        {
 46            int Min, Temp;
 47            for (int Outer = 0; Outer <= upper; Outer++)
 48            {
 49                Min = Outer;
 50                for (int Inner = Outer + 1; Inner <= upper; Inner++)
 51                {
 52                    if (arr[Inner] < arr[Min])
 53                    {
 54                        Min = Inner;
 55
 56                    }
 57                    Temp = arr[Outer];
 58                    arr[Outer] = arr[Min];
 59                    arr[Min] = Temp;
 60
 61                }
 62            }
 63        }
 64
 65
 66        //插入排序(版本一)
 67        //插入排序当数据量较大的时候效率不高
 68        public void InsertionSort()
 69        {
 70            int Inner, Temp;
 71            for (int Outer = 1; Outer <= upper; Outer++)
 72            {
 73                Temp = arr[Outer];
 74                Inner = Outer;
 75                while (Inner > 0 && (arr[Inner - 1] >= Temp))
 76                {
 77                    arr[Inner] = arr[Inner - 1];//向后移动二者较大的元素
 78                    Inner -= 1;
 79
 80                }
 81                arr[Inner] = Temp;
 82            }
 83        }
 84
 85        //这个版本是和我们的C语言版的数据结构课本上的的类似
 86        //插入排序(版本二)
 87        public void InserSort()
 88        {
 89            int Inner, Temp;
 90            for (int Outer = 1; Outer <= upper; Outer++)
 91            {
 92                //将每一趟比较的哨兵元素复制给Temp
 93                Temp = arr[Outer];
 94                for (Inner = Outer; (Inner > 0 && arr[Inner - 1] > Temp); Inner--)
 95                {
 96                    //向后移动大的元素
 97                    arr[Inner] = arr[Inner - 1];
 98                }
 99                //将哨兵赋值
100                arr[Inner] = Temp;
101            }
102        }
103
104
105        //希尔排序(原书代码，有问题)
106        /**//*public void ShellSorts()
107        {
108            int Inner, Temp;
109            int h = 1;
110            while (h <= (numElement / 3))
111            {
112                h = h * 3 + 1;
113                while(h>0)
114                {
115                    for (int Outer = h; Outer <= numElement - 1; h++)
116                    {
117                        Temp = arr[Outer];
118                        Inner = Outer;
119
120                        while ((Inner > h-1 ) && arr[Inner - h] >= Temp)
121                        {
122                            arr[Inner] = arr[Inner - h];
123                            Inner -= h;
124                        }
125                        arr[Inner] = Temp;
126                      
127                    }
128                    h = (h - 1) / 3;
129                }
130            }
131            
132        }
133        */
134
135
136        //希尔排序
137        public void ShellSortingAlgorithms()
138        {
139            int Temp; 
140            //初始增量序列
141            int Increment = upper / 2; 
142            while (Increment != 0)
143            {
144                for (int i = Increment; i <= upper; i++)
145                {
146                    int j;
147                    Temp = arr[i];
148                    for (j = i; j >= Increment; j = j - Increment)  //同子序列的插入排序
149                    {
150                        if (Temp < arr[j - Increment])
151                            arr[j] = arr[j - Increment]; //如果后面的小于前面的,交换位置
152                        else
153                            break;
154                    }
155                    arr[j] = Temp;            //插入      
156                }
157                //减小增量序列
158                Increment /= 2;
159            }
160
161        } 
162
163
164}

调用算法的过程：

 1 static   void  Main( string [] args)
 2          {
 3            SortingAlgorithms MyArray = new SortingAlgorithms(10);
 4            Random rnd = new Random(100);
 5
 6            long Ticks = DateTime.Now.Ticks;
 7            for (int i = 0; i < 10; i++)
 8            {
 9                MyArray.Insert((int)(rnd.NextDouble() * 100));
10            }
11
12            Console.WriteLine("Before Sorting:");
13            MyArray.DisplayElement();
14            //选择排序
15            //MyArray.SelectionSort();
16
17            //插入排序
18            //MyArray.InsertionSort();
19            //MyArray.InserSort();
20
21            //希尔排序
22            MyArray.ShellSortingAlgorithms();
23            Console.WriteLine("After sorting");
24            //打印排序后的元素
25            MyArray.DisplayElement();
26
27        }