排序算法[转]

笔者最近学习算法，学了很久也只弄懂了几个排序算法，在这里晒一下下，作为以后参考之用。

一、为什么要研究排序问题

许多计算机科学家认为，排序算法是算法学习中最基本的问题，原因有以下几点：

l  有时候应用程序本身需要对信息进行排序，如为了准备客户账目，银行需要对支票账号进行排序

l  很多算法将排序作为关键子程序

l  现在已经有很多排序算法，它们采用各种技术

l  排序时一个可以证明其非平凡下界的问题，并可以利用排序问题的下界证明其他问题的下界

l  在实现排序算法是很多工程问题即浮出水面

二、排序问题的形式化定义

输入：由n个数组成的一个序列<a1,a2,……,an>

输出：对输入序列的一个排列（重排）<a1’,a2’,……,an’>,使得a1’ ≤a2’ ≤……≤an’

【说明】在实际中，待排序的数很少是孤立的值，它们通常是成为激励的数据集的一个部分，每个记录有一个关键字key,是待排序的值，其他数据位卫星数据，它们通常以key为中心传递。

三、相关概念

1.         排序的稳定性：在待排序的文件中，若存在多个关键字相同的记录，经过排序后这些具有相同关键字的记录之间的相对次序保持不变，该排序方法是稳定的；若具有相同关键字的记录之间的相对次序发生变化，则称这种排序方法是不稳定的。

A.       稳定排序：插入排序、冒泡排序、鸡尾酒排序、计数排序、合并交换排序、归并排序、基数排序、桶排序、鸽巢排序

B.        不稳定排序：选择排序、堆排序、希尔排序、快速排序

2.         内部、外部排序：在排序过程中，若整个文件都是放在内存中处理，排序时不涉及数据的内、外存交换，则称之为内部排序(简称内排序)；反之，若排序过程中要进行数据的内、外存交换，则称之为外部排序。

3.     待排文件的常用存储方式：

A.     顺序表：对记录本身进行物理重排（即通过关键字之间的比较判定，将记录移到合适的位置

B.     链表：无须移动记录，仅需修改指针

C.     用顺序的方式存储待排序的记录，但同时建立一个辅助表：对辅助表的表目进行物理重排（即只移动辅助表的表目，而不移动记录本身）。

4.     影响排序效果的因素

A.     待排序的记录数目n

B.     记录的大小(规模)

C.     关键字的结构及其初始状态

D.    对稳定性的要求

E.     语言工具的条件

F.     存储结构

G.    时间和辅助空间复杂度等

四、排序算法的分类（内部排序）

1.         比较类排序：排序结果中各元素的次序基于输入元素间的比较

A.       比较排序算法的下界

比较排序可以被抽象为决策树。一棵决策树是一棵满二叉树，表示某排序算法作用于给定输入所做的所有比较，而忽略控制结构和数据移动。

在决策树中，对每个节点都注明i，j（1≤i，j≤n），决策树对每个叶节点都注明排列<π(1), π(2),……, π(n)>。排序算法的执行对应于遍历一条从根到叶节点的路径。在每个内节点作比较ai≤aj，其左子树决定ai≤aj之后的比较，其右子树决定ai＞aj之后的比较。当到达一个叶节点时排序算法就已经确定了顺序。要使排序算法能正确的工作，其必要条件是n个元素的n!种排列都要作为决策树的一个叶节点出现。在决策树中，从根到任意一个可达叶节点之间最长路径的长度（决策树的高度）表示对应的排序算法中最坏情况下的比较次数。对于一棵高度为h，具有l个可达叶节点的决策树有n! ≤l≤2h，则有h≥lg(n!)=Ω(nlgn)

B.        常见的比较类排序

a)         选择类排序：选择排序、堆排序

b)        插入类排序：插入排序、二叉插入、两路插入、希尔排序

c)         交换类排序：冒泡排序、鸡尾酒排序、合并交换排序、快速排序

d)        归并排序

2.         非比较类排序：计数排序、基数排序、桶排序、鸽巢排序

五、常用的排序算法 

1.         比较类排序

A.       选择类排序

a)         选择排序（Selection Sort）——原地排序、不稳定排序

【思路】首先找出A中最小元素，并将其与A[0]中元素交换；接着找出A中次最小元素，并将其与A[1]中元素交换；对A中头n-1个元素继续这一过程

【代码】

        #region 选择排序

/// <summary>
/// 选择排序
/// 最差时间复杂度 Θ(n²) 
/// 最优时间复杂度 Θ(n²) 
/// 平均时间复杂度 Θ(n²) 
/// 原地排序
/// 【排序过程】
/// 1、首先在未排序序列中找到最小元素，存放到排序序列的起始位置
/// 2、然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾
/// 3、以此类推，直到所有元素均排序完毕。
/// </summary>
/// <param name="Array">待排序的数组</param>
        public static void SelectionSort(int[] Array)
        {
for (int i = 0; i < Array.Length; i++)
            {
for (int j = i + 1; j < Array.Length; j++)
                {
if (Array[j] < Array[i])
                    {
                        Swap(ref Array[i], ref Array[j]);//交换数据
                    }
                }
            }
        }

#endregion

　　

【时间复杂度分析】选择排序的比较操作为n(n − 1) / 2次，交换操作介于0和n(n − 1) / 2次之间，故其时间复杂度为Θ(n2)

b)         堆排序（Heap Sort）

 六、代码

【二叉堆】（二叉）堆数据结构是一种数组对象，可以被视为一棵完全二叉树。二叉堆有两种：大顶堆和小顶堆（最大堆和最小堆）。大顶堆中每个节点的值不大于其父节点的值，这样，堆中最大的元素就存放在根节点中。

 二叉堆

 

【思路】首先将输入数组构造成大顶堆；由于数组中最大元素为A[0]，将其与A[n]交换使其达到最终正确位置；在堆中除去A[n]，并将A[1…n]保持为大顶堆；重复上述过程，直到堆大小降为2。

堆排序

【代码】由思路知堆排序中应包含构造大顶堆和保持大顶堆子程序。MaxHeapify方法被用来保持大顶堆，其时间复杂度为O(lgn)

保持堆

        /// <summary>
/// 调整数组,保持大顶堆性质
/// </summary>
/// <param name="Array">待保持大顶堆的数组</param>
/// <param name="i">大顶堆的根</param>
/// <param name="HeapSize">堆的大小</param>
        private static void MaxHeapify(int[] Array, int i, int HeapSize)
        {
int left = i * 2;
int right = left + 1;
int largest;
if (left < HeapSize && Array[left] > Array[right])
            {
                largest = left;
            }
else
            {
                largest = i;
            }
if (right < HeapSize && Array[right] > Array[largest])
            {
                largest = right;
            }
if (largest != i)
            {
                Swap(ref Array[i], ref Array[largest]);
                MaxHeapify(Array, largest, HeapSize);
            }
        }

/// <summary>
/// 调整数组,保持大顶堆性质(迭代实现)
/// </summary>
/// <param name="Array">待保持大顶堆的数组</param>
/// <param name="i">大顶堆的根</param>
/// <param name="HeapSize">堆的大小</param>
        private static void MaxHeapifyWithoutRecursive(int[] Array, int i, int HeapSize)
        {
while (i <= HeapSize)
            {
int left = i * 2;
int right = left + 1;
int largest;
if (left < HeapSize && Array[left] > Array[right])
                {
                    largest = left;
                }
else
                {
                    largest = i;
                }
if (right < HeapSize && Array[right] > Array[largest])
                {
                    largest = right;
                }
if (largest != i)
                {
                    Swap(ref Array[i], ref Array[largest]);
                    i = largest;
                }
else
                {
return;
                }
            }
        }

　　

        /// <summary>
/// 构造大顶堆
/// </summary>
/// <param name="Array">待构造大顶堆的数组</param>
        private static void BuildMaxHeapify(int[] Array)
        {
int HeapSize = Array.Length;
for (int i = (Array.Length - 1) / 2; i >= 0; i--)
            {
// MaxHeapify(Array, i, HeapSize);              //递归实现
                MaxHeapifyWithoutRecursive(Array, i, HeapSize); //迭代实现
            }
        }

　　

堆排序代码如下： 

 【时间复杂度分析】调用BuildMaxHeap时间为O(n)，n-1次调用MaxHeapify，每次时间为O(lgn)，故堆排序时间复杂度为O(nlgn)   

using System;namespace Algorithms
{public class Sort{static Random random = new Random();#region 交换数据/// <summary>/// 交换数据/// </summary>/// <param name="a">待交换值a</param>/// <param name="b">待交换值b</param>/// <returns>是否成功</returns>public static bool Swap(ref int a, ref int b){if (!Equals(a, b)){a ^= b;b ^= a;a ^= b;return true;}else{return false;}}#endregion#region 交换类排序#region 冒泡排序/// <summary>/// 冒泡排序（Bubble Sort）/// </summary>/// 最坏时间复杂度 O(n²)/// 最优时间复杂度 O(n)/// 平均时间复杂度 O(n²)/// 原地排序/// 不稳定排序/// 【排序过程】/// 1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。/// 2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 /// 3、针对所有的元素重复以上的步骤，除了最后一个。 /// 4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 /// <param name="Array">待排序的数组</param>public static void BubbleSort(int[] Array){for (int i = 0; i < Array.Length; i++){for (int j = Array.Length - 1; j > i; --j){if (Array[j] < Array[j - 1]){Swap(ref Array[j], ref Array[j - 1]);}}}}#endregion#region 快速排序/// <summary>/// 快速排序划分/// </summary>/// <param name="Array">待分划的数组</param>/// <param name="p">待分划数组下界</param>/// <param name="r">待分划数组上界</param>/// <returns>分划元素位置</returns>private static int Partition(int[] Array, int p, int r){int x = Array[r];int i = p - 1;for (int j = p; j < r; j++){if (Array[j] <= x){++i;Swap(ref  Array[i], ref Array[j]);}}Swap(ref Array[i + 1], ref Array[r]);return i + 1;}/// <summary>/// 快速排序/// </summary>/// 最差时间复杂度 Θ(n²) /// 最优时间复杂度 Θ(nlogn) /// 平均时间复杂度 Θ(nlogn) /// 原地排序/// 非稳定排序/// 【排序过程】/// 1、从数列中挑出一个元素，称为 "基准"， /// 2、分割：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。 /// 3、递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。 /// <param name="Array">待排序的数组</param>/// <param name="p">待排序数组下界</param>/// <param name="r">待排序数组上界</param>public static void QuickSort(int[] Array, int p, int r){if (p < r){int q = Partition(Array, p, r);QuickSort(Array, p, q - 1);QuickSort(Array, q, r);}}/// <summary>/// 快速排序划分(随机化)/// </summary>/// <param name="Array">待分划的数组</param>/// <param name="p">待分划数组下界</param>/// <param name="r">待分划数组上界</param>/// <returns>分划元素位置</returns>private static int RandomizedPartition(int[] Array, int p, int r){int i = random.Next(p, r + 1);Swap(ref Array[r], ref Array[i]);return Partition(Array, p, r);}/// <summary>/// 快速排序(随机化)/// </summary>/// <param name="Array">待排序的数组</param>/// <param name="p">待排序数组下界</param>/// <param name="r">待排序数组上界</param>public static void RandomizedQuickSort(int[] Array, int p, int r){if (p < r){int q = RandomizedPartition(Array, p, r);RandomizedQuickSort(Array, p, q - 1);RandomizedQuickSort(Array, q, r);}}/// <summary>/// Hoare划分/// </summary>/// <param name="Array">待分划的数组</param>/// <param name="p">待分划数组下界</param>/// <param name="r">待分划数组上界</param>/// <returns>分划元素位置</returns>private static int HoarePartition(int[] Array, int p, int r){int x = Array[p];int i = p - 1;int j = r + 1;while (true){do{--j;} while (Array[j] <= x);do{++i;} while (Array[i] >= x);if (i < j){int t = Array[i];Array[i] = Array[j];Array[j] = t;}else{return j;}}}#endregion#endregion#region 选择类排序#region 选择排序/// <summary>/// 选择排序/// 最差时间复杂度 О(n²) /// 最优时间复杂度 О(n²) /// 平均时间复杂度 О(n²) /// 原地排序/// 【排序过程】/// 1、首先在未排序序列中找到最小元素，存放到排序序列的起始位置/// 2、然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾/// 3、以此类推，直到所有元素均排序完毕。/// </summary>/// <param name="Array">待排序的数组</param>public static void SelectionSort(int[] Array){for (int i = 0; i < Array.Length; i++){for (int j = i + 1; j < Array.Length; j++){if (Array[j] < Array[i]){Swap(ref Array[i], ref Array[j]);}}}}#endregion#region 堆排序/// <summary>/// 调整数组,保持大顶堆性质/// </summary>/// <param name="Array">待保持大顶堆的数组</param>/// <param name="i">大顶堆的根</param>/// <param name="HeapSize">堆的大小</param>private static void MaxHeapify(int[] Array, int i, int HeapSize){int left = i * 2;int right = left + 1;int largest;if (left < HeapSize && Array[left] > Array[right]){largest = left;}else{largest = i;}if (right < HeapSize && Array[right] > Array[largest]){largest = right;}if (largest != i){Swap(ref Array[i], ref Array[largest]);MaxHeapify(Array, largest, HeapSize);}}/// <summary>/// 调整数组,保持大顶堆性质(迭代实现)/// </summary>/// <param name="Array">待保持大顶堆的数组</param>/// <param name="i">大顶堆的根</param>/// <param name="HeapSize">堆的大小</param>private static void MaxHeapifyWithoutRecursive(int[] Array, int i, int HeapSize){while (i <= HeapSize){int left = i * 2;int right = left + 1;int largest;if (left < HeapSize && Array[left] > Array[right]){largest = left;}else{largest = i;}if (right < HeapSize && Array[right] > Array[largest]){largest = right;}if (largest != i){Swap(ref Array[i], ref Array[largest]);i = largest;}else{return;}}}/// <summary>/// 构造大顶堆/// </summary>/// <param name="Array">待构造大顶堆的数组</param>private static void BuildMaxHeapify(int[] Array){int HeapSize = Array.Length;for (int i = (Array.Length - 1) / 2; i >= 0; i--){// MaxHeapify(Array, i, HeapSize);MaxHeapifyWithoutRecursive(Array, i, HeapSize);}}/// <summary>/// 堆排序/// 最差时间复杂度 O(nlogn) /// 最优时间复杂度 O(nlogn)/// 平均时间复杂度 Θ(nlogn)/// 原地排序/// 不稳定排序/// 【排序过程】/// 1、建立一个大顶堆/// 2、把堆首（最大值）和堆尾互换 /// 3、把堆的尺寸缩小1，并保持大顶堆/// 4、重复2号步骤，直到堆的尺寸为1 /// </summary>/// <param name="Array">待排序的数组</param>public static void HeapSort(int[] Array){int HeapSize = Array.Length;BuildMaxHeapify(Array);for (int i = Array.Length - 1; i > 0; i--){int t;t = Array[0];Array[0] = Array[i];Array[i] = t;MaxHeapifyWithoutRecursive(Array, 0, --HeapSize);//MaxHeapify(Array, 0, --HeapSize);}}#endregion#endregion#region 插入类排序#region 插入排序/// <summary>/// 插入排序(非递归算法)/// 平均时间复杂度 Θ(n²) /// 原地排序/// 稳定排序/// 【排序过程】/// 1、从第一个元素开始，该元素可以认为已经被排序 /// 2、取出下一个元素，在已经排序的元素序列中从后向前扫描 /// 3、如果该元素（已排序）大于新元素，将该元素移到下一位置 /// 4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 /// 5、将新元素插入到该位置中 /// 6、重复步骤2 /// </summary>/// <param name="Array">待排序的数组</param>public static void InsertionSort(int[] Array){for (int j = 1; j < Array.Length; j++){int key = Array[j];int i = j - 1;while (i >= 0 && Array[i] > key){Array[i + 1] = Array[i];--i;}Array[i + 1] = key;}}/// <summary>/// 插入排序(递归算法)/// </summary>/// <param name="Array">待排序的数组</param>/// <param name="length">要排序的长度</param>public static void InsertionSort(int[] Array, int length){if (length == 0){return;}else{InsertionSort(Array, length - 1);}int key = Array[length];while (Array[length] >= key){Array[length + 1] = Array[length];--length;}Array[length] = key;}#endregion#region Shell排序/// <summary>/// Shell排序（递减增量排序）/// </summary>/// 【排序过程】/// 1、取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。/// 2、先在各组内进行直接插入排序；/// 3、然后，取第二个增量d2＜d1重复上述的分组和排序，直至所取的增量dt=1(dt＜dt-1＜…＜d2＜d1)为止。/// <param name="Array">待排序的数组</param>public static void shellsort(int[] Array){int temp;int increment; //增量 int length = Array.Length;for (increment = length / 2; increment > 0; increment /= 2){for (int i = increment; i < length; ++i){int j;temp = Array[i];for (j = i; j >= increment; j -= increment){if (temp < Array[j - increment])Array[j] = Array[j - increment];elsebreak;}Array[j] = temp;}}}#endregion#endregion#region 归并类排序#region 归并排序/// <summary>/// 归并数组(使用哨兵)/// <para>归并数组Array[lower,mid]与Array[mid+1,upper]</para>/// </summary>/// <param name="Array">待归并的数组</param>/// <param name="lower">待归并数组下界</param>/// <param name="mid">待归并数组分界</param>/// <param name="upper">待归并数组上界</param>private static void MergeWithSentinel(int[] Array, int lower, int mid, int upper){int n1 = mid - lower + 1;int n2 = upper - mid;int[] L = new int[n1 + 1];int[] R = new int[n2 + 1];int i = 0;int j = 0;for (i = 0; i < n1; i++){L[i] = Array[lower + i];}for (i = 0; i < n2; i++){R[i] = Array[mid + i + 1];}L[n1] = R[n2] = int.MaxValue;i = 0;for (int k = lower; k < upper; k++){if (L[i] < R[j]){Array[k] = L[i++];}else{Array[k] = R[j++];}}}/// <summary>/// 归并数组(不使用哨兵)/// <para>归并数组Array[lower,mid]与Array[mid+1,upper]</para>/// </summary>/// <param name="Array">待归并的数组</param>/// <param name="lower">待归并数组下界</param>/// <param name="mid">待归并数组分界</param>/// <param name="upper">待归并数组上界</param>private static void Merge(int[] Array, int lower, int mid, int upper){int n1 = mid - lower + 1;int n2 = upper - mid;int[] L = new int[n1];int[] R = new int[n2];int i = 0;int j = 0;for (i = 0; i < n1; i++){L[i] = Array[lower + i];}for (i = 0; i < n2; i++){R[i] = Array[mid + i + 1];}i = 0;for (int k = lower; k < upper; k++){if (L[i] < R[j]){Array[k] = L[i++];}else{Array[k] = R[j++];}if (i == n1){while (j < n2){Array[++k] = R[j++];}}if (j == n2){while (i < n1){Array[++k] = L[i++];}}}}/// <summary>/// 归并排序/// </summary>/// 最差时间复杂度 Θ(nlogn) /// 最优时间复杂度 Θ(n) /// 平均时间复杂度 Θ(nlogn)/// 非原地排序/// 稳定排序/// 【排序过程】/// 1、申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 /// 2、设定两个指针，最初位置分别为两个已经排序序列的起始位置 /// 3、比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置 /// 4、重复步骤3直到某一指针达到序列尾 /// 5、将另一序列剩下的所有元素直接复制到合并序列尾 /// <param name="Array">待排序的数组</param>/// <param name="lower">待排序数组下界</param>/// <param name="upper">待排序数组上界</param>public static void MergeSort(int[] Array, int lower, int upper){if (lower < upper){int mid = (lower + upper) / 2;MergeSort(Array, lower, mid);MergeSort(Array, mid + 1, upper);Merge(Array, lower, mid, upper);}}#endregion#endregion#region 非比较类排序#region 计数排序/// <summary>/// 获取数组最大数/// </summary>/// <param name="Array">要取最大数的数组</param>/// <returns>数组最大数</returns>private static int GetLargest(int[] Array){int largest = 0;foreach (var i in Array){if (largest < i){largest = i;}}return largest;}/// <summary>/// 计数排序/// </summary>/// <param name="Array">待排序的数组</param>public static void CountingSort(int[] Array){int largest = GetLargest(Array) + 1;int[] B = new int[Array.Length];int[] C = new int[largest];for (int i = 0; i < largest; i++){C[i] = 0;}for (int j = 0; j < Array.Length; j++){++C[Array[j]];}for (int i = 1; i < largest; i++){C[i] += C[i - 1];}for (int j = Array.Length - 1; j >= 0; --j){B[C[Array[j]] - 1] = Array[j];C[Array[j]] = C[Array[j]] - 1;}for (int i = 0; i < Array.Length; i++){Array[i] = B[i];}}#endregion#endregion}
}

原文链接：http://www.cnblogs.com/kingwolfofsky/archive/2011/07/23/2115129.html

附：自己的一个随机排序

// 随机排序一维数组

private void RandomSort(Integer[] arr) {
int temp = 0;
int rand = 0;
int tempLen = arr.length;
// 将数组进行随机排序
        for (int i = 0; i < tempLen; i++) {
            rand = (int) (Math.random() * tempLen) + i;
if (rand >= tempLen) {
                rand = tempLen - 1;
            }
            temp = arr[i];
            arr[i] = arr[rand];
            arr[rand] = temp;
        }  
}

　　

　　

转载于:https://www.cnblogs.com/08shiyan/archive/2011/07/24/2115536.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/267702.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

linux 搜索 文件 内容,Linux 文件查找及文件内容查找

linux 搜索 文件 内容,Linux 文件查找及文件内容查找

使用grep搜索文件内容——快捷、方便(1) 在当前目录下的所有文件的文件内容中查找哪个文件的内容中有findcontents(大小写不敏感&#xff0c;列出findcontents所在文件的所在行)——适合于当前目录下的文件及目录数目比较少&#xff0c;如果查找后列出内容过多&#xff0c;将会…
阅读更多...
sonar做代码检测时如何忽略一些代码文件

sonar做代码检测时如何忽略一些代码文件

1、管理员登录sonar 2、如图 一条规则配置一个&#xff0c;不要填写逗号或者分号分割的多个规则 转载于:https://www.cnblogs.com/shengulong/p/8324764.html
阅读更多...
回车符和换行符

回车符和换行符

2019独角兽企业重金招聘Python工程师标准>>> 首先转一段关于回车和换行的历史。 回车和换行 关于“回车”&#xff08;carriage return&#xff09;和“换行”&#xff08;line feed&#xff09;这两个概念的来历和区别。 在计算机还没有出现之前&#xff0c;有一种…
阅读更多...
linux新建好文件后怎么编译,使用autoconf生成Makefile并编译工程的步骤

linux新建好文件后怎么编译,使用autoconf生成Makefile并编译工程的步骤

前言在Linux下&#xff0c;编译和链接需要用Makefile&#xff0c;而写好一个Makefile可不容易&#xff0c;写出一个规范的Makefile更是麻烦。我们可以利用autoconf来生成一个Makefile&#xff0c;尤其在大型工程里&#xff0c;能省去很多麻烦。这里我会用一个工程来说明怎么做&…
阅读更多...
前端跨域的那些事

前端跨域的那些事

这一节&#xff0c;我们来讲一讲&#xff0c;前端跨域的那些事&#xff0c;主要分成这样的几部分来讲解&#xff0c; 一、为什么要跨域&#xff1f; 二、常见的几种跨域与使用场景 2.1 JSONP跨域 2.2 iframe跨域 2.3 window.name 跨域 2.4 document.domain 跨域 2.5 cookie跨域…
阅读更多...
VC++学习（15）：多线程

VC++学习（15）：多线程

1. 程序,进程,线程 A: 程序是计算机指令的集合,它以文件的形式存储在磁盘上,而进程通常被定义为一个正在运行的程序的实例,是一个程序在其自身的地址空间中的一次执行活动.一个程序可以对应多个进程. 进程是资源申请,高度和独立运行的单位,因此,它使用系统中的运行资源,而…
阅读更多...
在linux中500g怎么分区,500G的硬盘，怎么分区比较合理？

在linux中500g怎么分区,500G的硬盘，怎么分区比较合理？

该楼层疑似违规已被系统折叠 隐藏此楼查看此楼个人电脑怎么分&#xff1f;希望大家给我规范一下另外&#xff0c;我的/dev/sda2用的是xfs&#xff0c;/dev/sda9用的是reiser4draplaterDrapl ~ $ sudo fdisk -l密码&#xff1a;Disk /dev/sda: 160.0 GB, 160041885696 bytes255 …
阅读更多...
CSS宽高背景介绍

CSS宽高背景介绍

本萌新还未毕业&#xff0c;在一家外包公司干了一个月&#xff0c;因烦恼日常琐事任务&#xff0c;深感外包之坑&#xff0c;以及上班路途艰辛&#xff0c;特转战erp实施&#xff0c;继写日常随笔&#xff0c;望来日屌丝逆袭&#xff0c;走上人生巅峰。 若有错误&#xff0c;请…
阅读更多...
linux交叉编译生成的是什么,静态链接util-linux – 交叉编译(生成动态链接文件)...

linux交叉编译生成的是什么,静态链接util-linux – 交叉编译(生成动态链接文件)...

我一直试图交叉编译util-linux for arm但我一直以动态链接的可执行文件结束,我不知道为什么会这样.我的目标是静态的.我在使用类似步骤的不同工具之前进行了交叉编译,并且它一直有效,所以这次我不知道我做错了什么.我正在使用Ubuntu 16.04.以下是我正在运行的命令&#xff1a;e…
阅读更多...
维护SAP帮助信息（WEB）

维护SAP帮助信息（WEB）

维护SAP帮助信息&#xff08;WEB&#xff09; 1、首先进入000 Client &#xff0c;然后scc4修改000的模式 2、spro 3、 4、 5、注意 服务器为&#xff1a;http://help.sap.com 路径为&#xff1a;saphelp_erp60_sp/helpdata 转载于:https://blog.51cto.com/anhwei/626111
阅读更多...
读jQuery之十二（删除事件核心方法）

读jQuery之十二（删除事件核心方法）

使用jQuery删除事件&#xff08;或称解除事件绑定&#xff09;有三个函数&#xff1a;unbind、die和undelegate。这三个方法都依赖于未公开的jQuery.event.remove&#xff08;后续使用remove简写&#xff09;。此为删除事件的核心方法。remove 所作的事情与上一篇提到的.add 刚…
阅读更多...
像Excel一样使用python进行数据分析（1）

像Excel一样使用python进行数据分析（1）

&#xff08;虽然是转载&#xff0c;但是是我每块都测试过得&#xff0c;容易出问题的地方我会添加一些自己的经验&#xff0c;仅供参考&#xff09; 像Excel一样使用python进行数据分析&#xff08;2&#xff09; 像Excel一样使用python进行数据分析&#xff08;3&#xff09;…
阅读更多...
linux svn 自动部署,linux下svn安装和自动部署

linux svn 自动部署,linux下svn安装和自动部署

liunx系统下安装svn并自动更新到项目中三部分&#xff1a;【1.安装 2.建立svn库 3.配置文件】html查看是否安装了svn 【svn –version】若是安装了svn能够先进行卸载 【sudo apt-get remove –purge subversion】接下来进行安装 【sudo apt-get install subversion】当安装成功…
阅读更多...
css优先级

css优先级

很经典的文章啊 [转]CSS的优先级特性Specificity 如果同个元素有两个或以上冲突的CSS规则&#xff0c;浏览器有一些基本的规则来决定哪一个非常特殊而胜出。它可能不像其它那么重要&#xff0c;大部分案例你不需要担心冲突&#xff0c;但大型而且复杂的CSS文件&#xff0c;或有…
阅读更多...
linux编译准备,Linux 下编译指南

linux编译准备,Linux 下编译指南

该楼层疑似违规已被系统折叠 隐藏此楼查看此楼首先&#xff0c;我们需要获取最新的源码。使用如下命令即可&#xff1a;git clone -b master --depth1 https://github.com/CleverRaven/Cataclysm-DDA.git这条命令会只获取 master 分支下最新的代码。对于普通玩家来说这已经足够…
阅读更多...
ServletConfig的详解

ServletConfig的详解

一、Servlet的作用 servlet是在servlet容器内运行的程序&#xff0c;有时需要访问容器外部或借助容器访问外部资源。所以可以通过web.xml文件中为某个servlet配置的名称和参数等信息传递给servlet。 这样做的好处是&#xff1a;如果将重要的信息、编码方式等配置信息放在web.xm…
阅读更多...
You can't specify target table 'tablename' for update in FROM clause的解决方法

You can't specify target table 'tablename' for update in FROM clause的解决方法

在执行下面的sql时报错 DELETE FROM temp WHERE id IN (SELECT a.id FROM t_user t JOIN temp a ON t.email a.email); 这种写法在sqlserver或者oracle中是支持的&#xff0c;但是mysql目前是不支持的&#xff0c;在mysql中不能同时查询一个表的数据再同时进行删除&#xff0…
阅读更多...
linux缓存代码,Linux使用的缓存

linux缓存代码,Linux使用的缓存

Linux使用的缓存6.7.1 Linux使用的缓存不管在硬件设计还是软件设计中&#xff0c;高速缓存是获得高性能的常用手段。Linux 使用了多种和内存管理相关的高速缓存。1&#xff0e; 缓冲区高速缓存&#xff1a;缓冲区高速缓存中包含了由块设备使用的数据缓冲区。这些缓冲区中包含了…
阅读更多...
Linux查看文件夹大小du

Linux查看文件夹大小du

du命令参数详解见&#xff1a; http://baike.baidu.com/view/43913.htm 下面我们只对其做简单介绍&#xff1b; 查看linux文件目录的大小和文件夹包含的文件数 统计总数大小 du -sh filename&#xff08;其实我们经常用du -sh *&#xff0c;显示当前目录下所有的文件及其大小&a…
阅读更多...
cursor: mutex S等待事件

cursor: mutex S等待事件

cursor: mutex * events等待事件 cursor: mutex * events等待事件用于Cursor Parent 和 Cursor stats类型的操作&#xff1a; ‘Cursor: Mutex S’ &#xff0c; 某个进程以SHRD S mode申请一个Mutex&#xff0c; 而该Mutex要么被其他进程已EXCL X mode所持有&#xff0c;要么其…
阅读更多...
最新文章

Copyright @ 2022~2023