一些常用算法[数组全排列算法，单链表反转（递归实现），字符串反转，桶排序]

using System;
using System.Collections;
using System.Collections.Generic;

namespace Arrange
{
class Program
{
static void Main(string[] args)
{

#region 1。全排列算法
//string[] teststring = new string[] { "a", "b", "c", "d" };

//Arrage(teststring, 0, teststring.Length);

//Console.ReadLine();
#endregion

#region 2。单链表反转（递归）

//LinkList<int> lk = new LinkList<int>();
//lk.Append(1);
//lk.Append(2);
//lk.Append(3);
//lk.Append(4);
//lk.Append(6);
//lk.Append(7);
//lk.Append(8);
//lk.Append(9);

//Node<int> head = lk.Head;
//while (head != null)
//{
//    Console.Write(string.Format("{0},", head.Data));
//    head = head.Next;
//}
//head = lk.Head;
//Console.WriteLine();

//Node<int> reservedlink = Reserve(head);
//while (reservedlink != null)
//{
//    Console.Write(string.Format("{0},", reservedlink.Data));
//    reservedlink = reservedlink.Next;
//}
//Console.WriteLine();

//Console.ReadLine();

//return;
#endregion

#region 3。字符串反转
//string a = "abc";

//Console.WriteLine(a);
//a = ReserverString(a);
//Console.WriteLine(a);

//Console.ReadLine();
#endregion

#region 4. QuickSort
////int[] intarr = new int[] { 11, 22, 2, 3, 1, 4, 6, 8 };
//int[] intarr = new int[] { 3, 5, 1, 2, 4, 8, 6, 7, 9, 10, 19, 17, 18, 14, 15, 16, 20, 11, 12, 13 };
//QuickSort(intarr, 0, intarr.Length - 1);

//for (int i = 0; i < intarr.Length; i++)
//{
//    Console.Write(intarr[i].ToString() + ",");
//}

#endregion

#region 5.桶排序

int maxnum = 20;
int nullvalue = 0; //一个标记，确保数组中任何元素的值都不等于这个值。
int[] intarr = new int[] { 3, 5, 1, 2, 4, 8, 6, 7, 9, 10, 19, 17, 18, 14, 15, 16, 20, 11, 12, 13 };
TongSort(intarr, maxnum, nullvalue);
for (int i = 0; i < intarr.Length; i++)
{
Console.Write(intarr[i].ToString() + ",");
}

#endregion

Console.ReadLine();
}

#region 1。全排列算法

/// <summary>
/// 交换
/// </summary>
/// <param name="arr"></param>
/// <param name="i"></param>
/// <param name="j"></param>
static void Swap(string[] arr, int i, int j)
{
if (i != j)
{
string tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}

/// <summary>
/// 排列/打印
/// </summary>
/// <param name="arr"></param>
/// <param name="str"></param>
/// <param name="m"></param>
static void Arrage(string[] arr, int str, int m)
{
if (str == m - 1)
{
//print
foreach (string t in arr)
Console.Write(string.Format("{0},", t));
Console.WriteLine();
}
else
{
for (int i = str; i < m; i++)
{
Swap(arr, str, i);
Arrage(arr, str + 1, m);
Swap(arr, str, i);
}
}
}

#endregion

#region 2。单链表反转（递归）

#region 反转算法（递归）
static Node<int> Reserve(Node<int> singlelink)
{
if (singlelink.Next == null)
return singlelink;

Node<int> l = Reserve(singlelink.Next);
singlelink.Next.Next = singlelink;
singlelink.Next = null;
return l;
}
#endregion

#region 单链表结构定义

//定义单链表的结点
//结点存储数据和下一个结点的地址(引用).这里用一个类表示.
public class Node<T>
{
private T data;  //数据
private Node<T> next; //引用

//构造器
public Node(T val, Node<T> p)
{
data = val;
next = p;
}

//构造器2
public Node(Node<T> p)
{
next = p;
}

//构造器3
public Node(T val)
{
data = val;
next = null;
}

//构造器4
public Node()
{
data = default(T);
next = null;
}

//数据域属性
public T Data
{
get
{
return data;
}
set
{
data = value;
}
}

//引用域属性
public Node<T> Next
{
get { return next; }
set { next = value; }
}
}

//单链表类--定义操作结点的一些方法(如删除, 插入等).
//IList<T>是.net自带的一个接口. 这里实现了这个接口.
public class LinkList<T>
{
private Node<T> head;  //单链表的头引用

//头引用 属性
public Node<T> Head
{
get { return head; }
set { head = value; }
}

//构造器
public LinkList()
{
head = null;
}

///<summary>
///求单链表的长度
///需要从表头开始, 一个结点一个结点遍历,直到表的末尾.
///</summary>

public int GetLength()
{
Node<T> p = head;

int len = 0;
while (p != null)
{
++len;
p = p.Next;
}

return len;
}

///<summary>
/// 清空单链表
/// head=null即可.
/// 单链表清空后,原来结点所占用的空间不会一直保留, 而由垃圾回收器进行回收.
///</summary>
public void Clear()
{
head = null;
}

///<summary>
/// 判断单链表是否为空
/// head==null,即为空
///</summary>
public bool IsEmpty()
{
if (head == null)
{
return true;
}
else
{
return false;
}
}

///<summary>
///附加操作
///在单链表的末尾添加新元素
/// </summary>
public void Append(T item)
{
Node<T> q = new Node<T>(item);
Node<T> p = new Node<T>();

if (head == null)
{
head = q;
return;
}

p = head;
while (p.Next != null)
{
p = p.Next;
}

p.Next = q;
}

//在单链表的第 i 个结点位置前插入一个值为 item 的结点.
public void Insert(T item, int i)
{
if (IsEmpty() || i < 1)
{
Console.WriteLine("List is empty or Position is error!");
return;
}

//就一个head元素.(插入到head前即可)
if (i == 1)
{
Node<T> q = new Node<T>(item);
q.Next = head;
return;
}

//非head(中间某一元素前插入P)
Node<T> p = head;
Node<T> r = new Node<T>();
int j = 1;

while (p.Next != null && j < i)
{
r = p;
p = p.Next;
++j;
}

if (j == i)
{
Node<T> q = new Node<T>(item);
q.Next = p;
r.Next = q;
}

}

//在单链表的第 i 个结点的位置后插入一个值为 item的结点.
public void InsertPost(T item, int i)
{
if (IsEmpty() || i < 1)
{
Console.WriteLine("List is empty or Position is error!");
return;
}

if (i == 1)
{
Node<T> q = new Node<T>(item);
q.Next = head.Next;
head.Next = q;
return;
}

Node<T> p = head;
int j = 1;

while (p != null && j < i)
{
p = p.Next;
++j;
}

if (j == i)
{
Node<T> q = new Node<T>(item);
q.Next = p.Next;
p.Next = q;
}
}

//删除单链表的第 i 个结点
public T Delete(int i)
{
if (IsEmpty() || i < 0)
{
Console.WriteLine("Link is empty or Position is error!");
return default(T);
}

Node<T> q = new Node<T>();
if (i == 1)
{
q = head;
head = head.Next;
return q.Data;
}

Node<T> p = head;
int j = 1;

//从头一直找到 i 所在的位置
//条件是: (1).单链表没有到末尾, (2).还没有到 i 所在的位置 ( j< i).
while (p.Next != null && j < i)
{
++j;
q = p;
p = p.Next;
}

if (j == i)
{
q.Next = p.Next;
return p.Data;
}
else
{
Console.WriteLine("The item node is not exist!");
return default(T);
}
}

//获得单链表的第 i 个数据元素
public T GetElem(int i)
{
if (IsEmpty())
{
Console.WriteLine("List is empty!");
return default(T);
}

Node<T> p = new Node<T>();
p = head;
int j = 1;

while (p.Next != null & j < i)
{
++j;
p = p.Next;
}

if (j == i)
{
return p.Data;  //找到了.
}
else
{
Console.WriteLine("The item node is not exist!");
return default(T);
}
}

///<summary>
///在单链表中查找值为 value 的结点
///</summary>
public int Locate(T value)
{
if (IsEmpty())
{
Console.WriteLine("List is Empty!");
return -1;
}

Node<T> p = new Node<T>();
p = head;
int i = 1;
while (!p.Data.Equals(value) && p.Next != null)
{
p = p.Next;
++i;
}

return i;
}
}
#endregion

#endregion

#region 3。字符串反转
static string ReserverString(string str)
{
int n = str.Length;
System.Text.StringBuilder sb = new System.Text.StringBuilder(str);

for (int i = 0; i < n / 2; i++)
{
char c = sb[i];
sb[i] = sb[n - i - 1];
sb[n - i - 1] = c;
}
return sb.ToString();
}
#endregion

#region 4. QuickSort
static void QuickSort(int[] arr, int low, int high)
{
if (low < high)
{
int partition = PartitionArr(arr, low, high);
QuickSort(arr, low, partition - 1);
QuickSort(arr, partition + 1, high);
}
}

static int PartitionArr(int[] arr, int low, int high)
{
int partition = arr[low];

while (low < high)
{
while (high > low)
{
if (arr[high] < partition)
{
arr[low] = arr[high];
low++;
break;
}
else
{
high--;
}
}
while (low < high)
{
if (arr[low] > partition)
{
arr[high] = arr[low];
high--;
break;
}
else
{
low++;
}
}
}
arr[low] = partition;
return low;
}

#endregion

#region 5.桶排序

static void TongSort(int[] arr, int maxnum, int nullvalue)
{
int[] t = new int[maxnum + 1];
//初始化
if (nullvalue != 0)
for (int i = 0; i < t.Length; i++)
t[i] = nullvalue;

for (int i = 0; i < arr.Length; i++)
{
t[arr[i]] = arr[i];
}

int idx = 0;
for (int i = 0; i < t.Length; i++)
{
if (t[i] != nullvalue)
{
arr[idx++] = t[i];
}
}
}

#endregion
}

}