How can I sort an array of strings?

Question

I have a comma separated list of input words. I want to sort these words alphabetically and by length. How can I do this without using the built-in sorting functions?

Answer 1

Good question!! Sorting is probably the most important concept for learning as a promising computer scientist.

In fact, there are many different algorithms for sorting a list.

When you destroy all these algorithms, the most fundamental operation is to compare the two elements in the list that define their “natural order”.

For example, to sort a list of integers, I need a function that tells me, given any two integers X and Y, if X is less than, equal to or greater than Y.

For your strings you will need the same thing: a function that tells you which of the strings has a value of "lesser" or "greater", or whether they are equal.

Traditionally, these comparator functions look something like this:

int CompareStrings(String a, String b) { if (a < b) return -1; else if (a > b) return 1; else return 0; } 

I did not consider some details (for example, as you calculate, less or more than b? Clue: iterating over characters), but this is the main skeleton of any comparison function. It returns a value less than zero if the first element is less, and a value greater than zero if the first element is greater, returns zero if the elements have the same value.

But what does this have to do with sorting?

Sort routing will call this function for pairs of items in your list, using the result of the function to figure out how to reorder items in the sorted list. The comparison function defines the "natural order", and the "sorting algorithm" determines the logic of the call and response to the results of the comparison function.

Each algorithm is similar to the strategy of a large picture, guaranteeing the correct sorting of ANY input. Here are a few algorithms that you probably want to know about:

Bubble Sort:

Go through the list by calling the comparison function for all adjacent pairs of elements. Whenever you get a result greater than zero (this means that the first element is larger than the second), replace the two values. Then move on to the next pair. When you get to the end of the list, if you did not need to replace ANY couples, then congratulations, the list is sorted! If you need to perform any swaps, go back to the beginning and start. Repeat this process until there are no more swaps.

NOTE. This is usually not a very efficient way to sort the list, because in the worst case scenario, you may need to scan the entire list as many as N times, for a list with N items.

Merge Sort:

This is one of the most popular separation and control algorithms for sorting a list. The basic idea is that if you have two lists already sorted, it's easy to merge them. Just start at the beginning of each list and remove the first element in which the list has the smallest initial value. Repeat this process until you use all the items from both lists, and then you're done!

 1 4 8 10 2 5 7 9 ------------ becomes ------------> 1 2 4 5 7 8 9 10 

But what if you don't have two sorted lists? What if you have only one list, and its elements in random order?

This is the smart thing about merge sorting. You can break any single list into smaller fragments, each of which is either an unsorted list, or a sorted list, or one element (which, if you know this, is actually a sorted list with length = 1).

So, the first step in the merge sort algorithm is to split your general list into smaller and smaller sub-lists. At the smallest levels (where each list contains only one or two elements), they are very easy to sort. And after sorting, it is easy to combine any two adjacent sorted lists into a larger sorted list containing all the elements of two subscriptions.

NOTE. This algorithm is much better than the bubble sorting method described above in terms of the efficiency of its worst case scenario. I won’t go into a detailed explanation (which includes a pretty trivial math, but it will take some time to explain), but a quick reason to increase the efficiency is that this algorithm breaks its problem into pieces of perfect size and then combines the results of these pieces. The bubble sorting algorithm solves everything at once, so it does not get the divide and win benefits.

---

These are just two algorithms for sorting the list, but there are many other interesting techniques, each of which has its advantages and disadvantages: Quick Sort, Radix Sort, Sort Selection, Sort Heap, Sort Angles and Sort Bucket.

The Internet is full of interesting sorting information. Here is a good place to start:

http://en.wikipedia.org/wiki/Sorting_algorithms

Answer 2

Create a console application and paste it into Program.cs as the class body.

 public static void Main(string[] args) { string [] strList = "a,b,c,d,e,f,a,a,b".Split(new [] { ',' }, StringSplitOptions.RemoveEmptyEntries); foreach(string s in strList.Sort()) Console.WriteLine(s); } public static string [] Sort(this string [] strList) { return strList.OrderBy(i => i).ToArray(); } 

Please note that I use the built-in OrderBy method. As the other answers indicate, there are many different sorting algorithms that you can implement there, and I think that my code snippet does everything for you except the actual sorting algorithm.

Some special c # sorting lessons

Answer 3

There is a whole field of research built around sorting algorithms . You can choose a simple one and implement it.

Although this will not be the most effective, you will not need too much time to create the creation of bubbles .

Answer 4

If you do not want to use the built-in functions, you need to create it yourself. I would recommend Bubble sort or some similar algorithm. Bubble is not an efficient algorithm, but it does all the work done and is easy to understand.

You will find a lot of good reading on wikipedia .

Answer 5

I would recommend doing a wiki for quick sorting.

Not sure why you don’t want to use the inline view?

Answer 6

A bladder variety damages the brain.

Sorting an insert is at least as easy to understand and code, and actually useful in practice (for very small datasets and almost sorted data). It works as follows:

Suppose that the first n elements are already in order (you can start with n = 1, since, obviously, one thing itself is "in the correct order").

Take the (n + 1) th element in your array. Call it pivot. Starting from the nth element and working down:
- if it is larger than the pivot point, move it to the right (to create a “space” to its left).
- otherwise, leave it in place, put the “turn” one place to the right of it (that is, in the “space” if you move something, or where it started if you didn't move anything) and stops.

Now the first n + 1 elements in the array are ordered, because the bar to the right of everything smaller than it, and to the left of everything larger than it. Since you started with n elements in order, this progress.

Repeat when n increases by 1 at each step until you process the entire list.

This corresponds to one of the ways in which you can physically place a series of folders in a storage cabinet in order: put it; then put the other in the correct position, pressing everything that belongs to him, one space to make room; repeat to the end. Nobody ever sorts physical objects using bubble sorting, so for me it's a mystery why this is considered "simple."

All that remains now is that you need to be able to work, given the two lines: is the first greater than the second. I'm not quite sure what you mean by “alphabet and length”: the alphabetical order is done by comparing one character at a time from each line. If there is not the same as your order. If they are the same, look at the following if you are not from the characters in one of the lines, in which case the one that is "smaller".

Answer 7

Use NSort

I came across the NSort library several times in the book Windows Developer Tools . The NSort library implements a number of sorting algorithms. The main advantage of using something like NSort over writing your own sort is that it has already been tested and optimized.

Answer 8

Posting a link to a quick line sort code in C #:

http://www.codeproject.com/KB/cs/fast_string_sort.aspx

Another point: The proposed comparator above is not recommended for non-English languages:

int CompareStrings (String a, String b) {
if (a <b) return -1; else if (a> b)
return 1; rest
return 0; }

Checkout this link for non-English:

http://msdn.microsoft.com/en-us/goglobal/bb688122

And as already mentioned, use nsort for really gigantic arrays that don't fit into memory.