History of Scotland

# When did the Clan system begin and end?

###### Wiki User

###### 2009-07-06 06:45:34

The Clan system, by which Highland society was divided into

tribal groups led by autocratic chiefs, can be traced back to the

12th century, when Clans were already known to wear the chequered

wool cloth later called Tartan. After the Battle of Culloden (1746)

the Clan lands belonging to Chiefs who supported the Jacobites were

forfeited to the Crown and sold off. The feudal power and

jurisdiction over their lands was removed from the Chiefs under the

Abolition of Heritable Jurisdiction act of 1747 with only those

Chiefs who had supported the Government compensated. The wearing of

tartan in the Highlands (but not the lowlands or the military) was

banned for 35 years from 1747 to 1782.

## Related Questions

###### Asked in Halo

### What is a clan in halo?

A clan in halo is a gaming group, comprised of a leader, a
second in command, and; varying from clan to clan; other
ranks/classes. A clan may be competitive, social, *creative,
**based upon something, etc. A clan may have a website/homepage
which may/may not require you to join to be in the clan.
*- Forge, Machinima, Screenshots, etc.
**- An all elite (Sangheili) clan which follows the same ranking
system as seen in the story.

###### Asked in C Programming

### What is quick sort in c language?

Quicksort in any programming language is an algorithm for
sorting data sequences. It is typically implemented as follows
(example demonstrates a quicksort of an array of type int). Note
that a half-open range, [begin:end), includes the one-past-the-end
of the range and is the conventional means of defining a range of
contiguous array values. When begin==end, the range is deemed
empty.
// forward declarations
void qsort (int* unsigned); // this is the function you will
actually invoke
void qsort_rec (int*, int*); // recursive function
int* partition (int*, int*); // utility functions...
int* select_pivot (int*, int*);
void swap (int*, int*);
int count (int*, int*);
// sort a data sequence of length size
void qsort (int* data, unsigned size) {
qsort_rec (data, data + size);
}
// recursively sort the half-open range [begin:end)
void qsort_rec (int* begin, int* end) {
if (count (begin, end) < 2) return; // end point of
recursion
int* pivot = partition (begin, end);
qsort_rec (begin, pivot);
qsort_rec (++pivot, end);
}
// divide the half-open range [begin:end) into two around a
pivot value
int* partition (int* begin, int* end) {
if (count (begin, end) < 2) return begin;
int* pivot = select_pivot (begin, end);
swap (begin, pivot);
--end;
while (begin != end) {
while (*(begin) <= *pivot && begin != end)
++begin;
while (*pivot < *(end) && begin != end) --end;
if (begin!=end) swap (begin, end);
}
assert (begin==end); // sanity check!
swap (pivot, begin);
return begin;
}
// select the median of three from a half-open range
[begin:end)
int* select_pivot (int* begin, int* end) {
int* mid = begin + (count (begin, end) / 2);
if (*end<*begin) swap (begin, end);
if (*mid<*begin) swap (begin, mid);
if (*end<*mid) swap (mid, end);
return end;
}
// swap the values referred to by p and q
void swap (int* p, int* q) {
if (!p !q) return; // sanity check!
int t = *p;
*p = *q;
*q = t;
}
// count the elements in the half-closed range [begin:end)
int count (int* begin, int* end) {
int cnt = 0;
int add;
if (begin>end) { // swap pointers if the range is
reversed
int* t = begin;
begin = end;
end = t;
add = -1; // count will be negative
} else {
add = 1; // count will be positive
}
while (begin++!=end) cnt+=add;
return cnt;
}