当前位置: 澳门新濠3559 > 编程 > 正文

i++){  // 外层循环控制趟数,System.out.println("冒泡

时间:2019-11-08 23:18来源:编程
#include "stdafx.h" //暴力法求最大子数组和问题 int _tmain(int argc, _TCHAR* argv[]) { int A[8] = { -6, 10, -5, -3, -7, -1, -1 }; int array_length = sizeof(A) / sizeof(A[0]);//数组大小 int sum = -10000;//记录子数组的和

#include "stdafx.h"
//暴力法求最大子数组和问题
int _tmain(int argc, _TCHAR* argv[])
{
int A[8] = { -6, 10, -5, -3, -7, -1, -1 };
int array_length = sizeof(A) / sizeof(A[0]);//数组大小
int sum = -10000;//记录子数组的和
int low;//记录子数组的底
int height;//记录子数组的高
for (int i = 0; i < array_length; i++)
{
for (int j = i ; j < array_length; j++)
{
int subarraysum=0;//所遍历出来的子数组的和
//计算遍历的子数组之和
for (int k = i; k <= j; k++)
{
subarraysum += A[k];
}
//找出最大的子数组
if (subarraysum>sum)
{
sum = subarraysum;
low = i;
height = j;
}
}
}
printf("%d %d %d", low, height,sum);//将结果打印出来
getchar();
return 0;
}

分支结构

1、    对以下一组数据进行降序排序(冒泡排序)。“24,80,35,8,9,54,76,45,5,63”

 

if(a>b){

int array[10] = {24, 17, 85, 13, 9, 54, 76, 45, 5, 63};

 

printf("你真美n");

int num = sizeof(array)/sizeof(int);

package dxpx;

}else{

for(int i = 0; i < num-1; i++) {

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Random;
import java.util.Set;

printf("你真帅n");

for(int j = 0; j < num - 1 - i; j++) {

public class asd {

}

if(array[j] < array[j+1]) {

public static void main(String[] args) {
int[] arr = new int[10];
init(arr);

========================================================

int tmp = array[j];

System.err.println("原数组:");
print(arr);

循环

array[j] = array[j+1];

System.out.println("堆排序:");

for(int i= 0;i< 100;i++)i++{

array[j+1] = tmp;

print(heapSort(arr.clone()));

int temp = i + 1;

}

System.out.println("归并排序");

printf("%d",temp);

}

print(mergeSort(arr.clone(), 0, arr.length - 1));

}

}

System.out.println("基数排序");

例:  1--100之间7的倍数

for(int i = 0; i < num; i++) {

print(radixSort(arr.clone(), 3));

for(int i = 0;i <100;i++){

printf("%d", array[i]);

System.out.println("快速排序");

     if(i  % 7 ==0){

if(i == num-1) {

print(quickSort(arr.clone(), 0, arr.length - 1));

    printf("%d",i);

printf("n");

System.out.println("冒泡排序:");

}

}

print(bubleSort(arr.clone()));

}

else {

System.out.println("拓扑排序:");
new TopoSortB().demo();

======================================================

printf(" ");

System.out.println("插入排序:");

多层循环的嵌套

}

print(insertionSort(arr.clone()));

for(int i = 1; i < 4; I++){

}

System.out.println("希尔排序(优化的插入排序):");

for (int j = 1;j < 4;j++){

2、    对以下一组数据进行升序排序(选择排序)。

print(shellSort(arr.clone()));

printf("n";)

void sort(int a[],int n)

System.out.println("选择排序:");

}

{

print(selectSort(arr.clone()));

}

int i, j, index;

System.out.println("鸽巢排序:");

例: /*         1 2 3

for(i = 0; i < n - 1; i++) {

print(pigeonholeSort(arr.clone()));

                  1 2

index = i;

System.err.println("原数组:");
print(arr);

                  1        */

for(j = i + 1; j < n; j++) {

System.out.println("系统排序");

for(int i = 1; i < 4;i++){  // 外层循环控制趟数

if(a[index] > a[j]) {

Arrays.sort(arr);

     for(int j = i; j <= 4 - 1; j++){ //内层循环表示每行有几个数 j = 1 代表第一个数是1

index = j;

System.out.println(Arrays.toString(arr));

           printf("%d",j);//外层循环一次内层循环一遍,外层循环在进行下一次,

}

}

}

}

/**
* 希尔排序
*
* @param array
* 需要被排序的数组
* @return 排序完成的数组
*/
private static int[] shellSort(int[] array) {
int d = array.length;
while (true) {
d = d / 2;
for (int x = 0; x < d; x++) {
for (int i = x + d; i < array.length; i = i + d) {
int temp = array[i];
int j;
for (j = i - d; j >= 0 && array[j] > temp; j = j - d) {
array[j + d] = array[j];
}
array[j + d] = temp;
}
}
if (d == 1) {
break;
}
}

printf("n");

if(index != i) {

return array;
}

}

int temp = a[i];

/**
* 插入排序法
*
* @param array
* 需要被排序的数组
* @return 排序完成的数组
*/
private static int[] insertionSort(int[] array) {
for (int i = 0; i < array.length; i++) {// 遍历整个数组
for (int j = i; j > 0; j--) {//
if (array[j] < array[j - 1]) {
swap(array, j - 1, j);
}
}
}
return array;
}

======================================================

a[i] = a[index];

/**
* 鸽巢排序
*
* @param array
* 需要排序的数组
* @return 排序好的数组
*/
public static int[] pigeonholeSort(int[] array) {
int max = array[0];
for (int i = 0; i < array.length; i++) {
if (max < array[i]) {
max = array[i];
}
}

while循环----理解为分解版的for循环(未知次数但有循环条件)

a[index] = temp;

int[] countArray = new int[max + 1];// 创建一个数组,统计重复数据个数(计数)
for (int i = 0; i < array.length; i++) {

1,设置循环变量

}

countArray[array[i]]++;// 数组当下表,统计重复数据的个数,a1中保存元素重复次数(-1即可),a1下标即对应的元素
} // 此时不仅找到了元素的重复个数,同时完成了从小到大排序,下边要做的就是把数依次放到原数组中去了

int i = 0;

}

for (int i = 0, k = 0; i < max + 1; i++)// 注意是max+1
for (int j = 0; j < countArray[i]; j++)
array[k++] = i;
return array;
}

2,开始while

}

/**
* 基数排序,又称 桶排序
*
* @param array
* 要排序的数组
* @param d
* 数组中元素有几位数就填几,1就
* @return 排序好的数组
*/
private static int[] radixSort(int[] array, int d) {
int numberBit = 1;// 数组元素中的最大值
for (int i = 0; i < d; i++) {
numberBit *= 10;
}
int n = 1;// 代表位数对应的数:1,10,100 ...
int k = 0;// 保存每一位排序后的结果用于下一位的排序输入
int length = array.length;
// 排序桶用于保存每次排序后的结果,这一位与一排序结果相同的数字放在同一个桶里
int[][] bucket = new int[10][length];
// 用于保存每个桶里有多少个数字
int[] order = new int[length];

while(i < 100) {

int main(int argc, const char * argv[]) {

while (n < numberBit) {
for (int num : array) {
int digit = (num / n) % 10;

    printf("%d",i+1);

int numArr[10] = {86, 37, 56, 29, 92, 73, 15, 63, 30, 8};

bucket[digit][order[digit]] = num;

3,设置循环增量

sort(numArr, 10);

order[digit]++;
}

    i++

for (int i = 0; i < 10; i++) {

for (int i = 0; i < length; i++) {
// 将前一个循环生成的桶里的数据覆盖到原数组中用于保存这一位的排序结果
if (order[i] != 0) {
// 这个桶里有数据,从上到下遍历这个桶并将数据保存到原数组中
for (int j = 0; j < order[i]; j++) {
array[k] = bucket[i][j];
k++;
}
}
order[i] = 0;// 将桶里计数器置0,用于下一次排序
}
n *= 10;
k = 0;// 将k置0,用于下一轮保存位排序结果
}
return array;
}

}

printf("%d, ", numArr[i]);

/**
* 快速排序
*
* @param array
* 要排序的数组
* @param start
* 数组开始下标值
* @param end
* 数组结束下标值
* @return 排序好的数组
*/
private static int[] quickSort(int[] array, int start, int end) {
if (start >= end) {// 递归停止的开关
return null;
}

例: 10亿每天花一半,花多少天

}

int temp = array[start];// temp是基准数,可以在数组范围内随便取,这里取数组第一位
int i = start; // 数组的第一位的下标
int j = end;// 数组最后一位的下标

long money = 100000000;

printf("n");

while (i != j) {
// 要先从右边往左边找
while (array[j] >= temp && i < j) {
j--;
}
// 然后从左往右边找
while (array[i] <= temp && i < j) {
i++;
}
// 交换两个数在数组中的位置
if (i < j) {
swap(array, i, j);
}
}
// 把基准数归位
swap(array, start, i);

int   day = 0;

return 0;

quickSort(array, start, i - 1);// 继续处理左边的半边数组
quickSort(array, i + 1, end); // 继续处理右边的半边数组
return array;
}

while(money != 0){

}

/**
* 堆排序
*
* @param array
* @return
*/
private static int[] heapSort(int[] array) {
for (int i = 0; i < array.length; i++) {
createMaxHeap(array, array.length - 1 - i);
swap(array, 0, array.length - 1 - i);
}
return array;
}

     day++;

3、    快速排序算法

/**
* 创建最大值堆
*
* @param array
* @param lastIndex
*/
private static void createMaxHeap(int[] array, int lastIndex) {
for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
// 保存正在判断的节点
int k = i;
// 若当前节点的子节点存在
while (2 * k + 1 <= lastIndex) {
// biggerIndex总是记录较大节点的值,先赋值为当前判断节点的左子节点
int biggerIndex = 2 * k + 1;
if (biggerIndex < lastIndex) {
// 若右子节点存在,否则此时biggerIndex应该等于 lastIndex
if (array[biggerIndex] < array[biggerIndex + 1]) {

     money = money / 2;

void sort(int *a, int left, int right) {

biggerIndex++;
}
}
if (array[k] < array[biggerIndex]) {
// 若当前节点值比子节点最大值小,则交换两者的值,然后将biggerIndex赋值给k
swap(array, k, biggerIndex);
k = biggerIndex;
} else {
break;
}
}
}

}

if(left >= right) {

}

printf("%d",day);

return ;

/**
* 直接选择排序法
*
* @param a
* @return
*/
private static int[] selectSort(int[] a) {
for (int i = 0; i < a.length; i++) {
int minIndex = i;// 记录最小的索引
for (int j = minIndex

======================================================

}

  • 1; j < a.length; j++) {
    if (a[j] < a[minIndex]) {// 如果有比当前值小的值,则交换下标
    minIndex = j;
    }
    }
    if (minIndex != i) {// 如果上一次循环交换了下标,则交换数组元素值
    swap(a, i, minIndex);
    }
    }
    return a;
    }

    /**
    * 归并排序
    *
    * @param a
    * @param low
    * @param high
    * @return
    */
    public static int[] mergeSort(int[] a, int low, int high) {
    int mid = (low + high) / 2;
    if (low < high) {
    // 左边
    mergeSort(a, low, mid);
    // 右边
    mergeSort(a, mid + 1, high);
    // 左右归并
    merge(a, low, mid, high);
    // System.out.println(Arrays.toString(a));
    }
    return a;
    }

    /**
    * 归并
    *
    * @param a
    * @param low
    * @param mid
    * @param high
    */
    public static void merge(int[] a, int low, int mid, int high) {
    int[] tmp = new int[high - low + 1];
    int i = low;
    int j = mid + 1;
    int k = 0;
    // 把较小的数先移到新数组中
    while (i <= mid && j <= high) {
    if (a[i] < a[j]) {
    tmp[k++] = a[i++];
    } else {
    tmp[k++] = a[j++];
    }
    }
    // 把左边剩余的数移入数组
    while (i <= mid) {
    tmp[k++] = a[i++];
    }
    // 把右边剩余的数移入数组
    while (j <= high) {
    tmp[k++] = a[j++];
    }

    for (int k2 = 0; k2 < tmp.length; k2++) {
    a[k2 + low] = tmp[k2];
    }
    }

    /**
    * 冒泡排序
    *
    * @param intArray
    * 需要排序的数组
    * @return 排序完成的数组
    */
    private static int[] bubleSort(int[] intArray) {
    for (int i = 0; i < intArray.length - 1; i++) {
    for (int j = i + 1; j < intArray.length; j++) {
    if (intArray[i] > intArray[j]) {
    swap(intArray, i, j);
    }
    }
    }
    return intArray;
    }

    /**
    * 输出一个数组
    *
    * @param arr
    */
    public static void print(final int[] arr) {

break 关键字

int i = left;

System.out.println(Arrays.toString(arr));
}

在循环中一旦执行到break,就会结束离他最近一层循环

int j = right;

/**
* 初始化数组
*
* @param arr
* @return
*/
private static int[] init(int[] arr) {
Random random = new Random();
for (int i = 0; i < arr.length; i++) {
arr[i] = random.nextInt(1000);
}
return arr;
}

for(int i = 0; i < 30; i++){

int key = a[left];

/**
* 交换两个数字的值
*
* @param a
* @param b
*/
private static void swap(int[] arr, int a, Integer b) {
if (arr[a] == arr[b]) {
return;
}
arr[a] += arr[b];
arr[b] = arr[a] - arr[b];
arr[a] = arr[a] - arr[b];
}

 if (i == 10){

while (i < j) {

}

 printf("一往而生");

while (i < j && key >= a[j]) {

/**
* 拓扑排序,当前方案并没有在节点类中加入过多的内容 但是在图类中加入了边的集合adjaNode
*/
class TopoSortB {
/**
* 启动一个小demo
*/
public void demo() {
Node A = new Node("A");
Node B = new Node("B");
Node C = new Node("C");
Node D = new Node("D");
Node E = new Node("E");
Node F = new Node("F");

 break;

j--;

Graph graph = new Graph();
graph.addNode(A, B);
graph.addNode(B, C);
graph.addNode(B, D);
graph.addNode(D, C);
graph.addNode(E, C);
graph.addNode(C, F);

}

}

KahnTopo topo = new KahnTopo(graph);

printf("情不知所起");

a[i] = a[j];

topo.process();
for (Node temp : topo.getResult()) {

}

while (i < j && key <= a[i]) {

System.out.print(temp.val.toString() + "-->");
}

======================================================

i++;

System.out.println();
}

continue 一旦碰到此关键字,会跳过本次循环,继续下一次循环

}

/**
* 拓扑排序节点类
*/
private static class Node {
public Object val;
public int pathIn = 0; // 入链路数量

for (int i = 1; i < 10;i++) {

a[j] = a[i];

public Node(Object val) {
this.val = val;
}
}

       if(i = =3){

}

/**
* 拓扑图类
*/
private static class Graph {
// 图中节点的集合
public Set<Node> vertexSet = new HashSet<Node>();
// 相邻的节点,纪录边
public Map<Node, Set<Node>> adjaNode = new HashMap<Node, Set<Node>>();

       printf("把这个扔了继续下一个");

a[i] = key;

// 将节点加入图中
public boolean addNode(Node start, Node end) {
if (!vertexSet.contains(start)) {

       continue;

sort(a, left, i-1);

vertexSet.add(start);
}
if (!vertexSet.contains(end)) {

sort(a, i+1, right);

vertexSet.add(end);
}
if (adjaNode.containsKey(start) && adjaNode.get(start).contains(end)) {
return false;
}
if (adjaNode.containsKey(start)) {

      printf("吃地%d个包子");

4、    归并排序

adjaNode.get(start).add(end);
} else {
Set<Node> temp = new HashSet<Node>();

}

void merge(int sourceArr[], int tempArr[], int startIndex, int midIndex, int endIndex) {

temp.add(end);
adjaNode.put(start, temp);
}
end.pathIn++;
return true;
}
}

======================================================

int i = startIndex;

// Kahn算法
private static class KahnTopo {
private List<Node> result; // 用来存储结果集
private Queue<Node> setOfZeroIndegree; // 用来存储入度为0的顶点
private Graph graph;

开关语句

int j = midIndex + 1;

// 构造函数,初始化
public KahnTopo(Graph di) {
this.graph = di;
this.result = new ArrayList<Node>();
this.setOfZeroIndegree = new LinkedList<Node>();
// 对入度为0的集合进行初始化
for (Node iterator : this.graph.vertexSet) {
if (iterator.pathIn == 0) {

int tel = 608;

int k = startIndex;

this.setOfZeroIndegree.add(iterator);
}
}
}

switch (tel) {

while (i != midIndex + 1 && j != endIndex + 1) {

// 拓扑排序处理过程
private void process() {
while (!setOfZeroIndegree.isEmpty()) {
Node v = setOfZeroIndegree.poll();

    case  605:

if (sourceArr[i] >= sourceArr[j]) {

// 将当前顶点添加到结果集中
result.add(v);

   printf("欢迎致电市场部");

tempArr[k++] = sourceArr[j++];

if (this.graph.adjaNode.keySet().isEmpty()) {
return;
}

   break;

} else {

// 遍历由v引出的所有边
for (Node w : this.graph.adjaNode.get(v)) {
// 将该边从图中移除,通过减少边的数量来表示
w.pathIn--;
if (0 == w.pathIn) // 如果入度为0,那么加入入度为0的集合
{

   case  606:

tempArr[k++] = sourceArr[i++];

setOfZeroIndegree.add(w);
}
}

   printf("欢迎致电调研部");

}

this.graph.vertexSet.remove(v);

   break;

}

this.graph.adjaNode.remove(v);
}

   case  607:

while (i != midIndex + 1) {

// 如果此时图中还存在边,那么说明图中含有环路
if (!this.graph.vertexSet.isEmpty()) {
throw new IllegalArgumentException("Has Cycle !");
}
}

  printf("欢迎致电教学部");

tempArr[k++] = sourceArr[i++];

// 结果集
public Iterable<Node> getResult() {
return result;
}
}
}

  break;

}

default:

while (j != endIndex + 1) {

printf("亲,你走错了");

tempArr[k++] = sourceArr[j++];

break;

}

}

for (i = startIndex; i <= endIndex; i++) {

======================================================

sourceArr[i] = tempArr[i];

格式化输入函数

}

int  s;

}

printf("请输入一个数字:");

void sort(int souceArr[], int tempArr[], int startIndex, int endIndex) {

scant("%d".&s);

int midIndex;

======================================================

if (startIndex < endIndex) {

数组:快速创建多个变量,缺点数组中只能存储相同类型的数据,

midIndex = (startIndex + endIndex) / 2;

数据类型: 数组名[元素个数] = {值1,值2,值3.....}

sort(souceArr, tempArr, startIndex, midIndex);

注意: 数组的元素个数只能为整形常量 不要写变量

sort(souceArr, tempArr, midIndex + 1, endIndex);

int array[5] = {2,4,5,6,7};

merge(souceArr, tempArr, startIndex, midIndex, endIndex);

char a[3] = {'t','i','v'};

}

可以不设置数组个数,系统会按照数组赋值自行分配

}

short  b[] = {2,4,6,7};

int main(int argc, const char * argv[]) {

函数sizeof()可以帮助计算变量在内存中占得字节数

int numArr[10] = {86, 37, 56, 29, 92, 73, 15, 63, 30, 8};

lu (unsigned long)无符号长整型

int tempArr[10];

printf("%lun",sizeof(array));

sort(numArr, tempArr, 0, 9);

指定数组元素个数,所给数组赋的值得个数必须小于等于元素个数

for (int i = 0; i < 10; i++) {

int c[5] = {22,3,4,5,43,34};

printf("%d, ", numArr[i]);

//数组的下标

}

//从0开始,最大下标是元素个数减一,

printf("n");

//意义:帮助准确找到某个元素

return 0;

//使用原则:数组名[元素下标]

}

printf("%d",array[2]); // 第三个元素

5、    实现二分查找算法(编程语言不限)

array[0] = 222; //改值直接重新赋值

int bsearchWithoutRecursion(int array[],int low,int high,int target) {

//数组的输出依赖循环

while(low <= high) {

//通过循环遍历数组的每一个下标,来取出数组中的每一个元素

int mid = (low + high) / 2;

//注意  初始化变量的值要从0开始

if(array[mid] > target)

for (int i = 0; i < sizeof(array) / 4;i++){

high = mid - 1;

printf("%d",array[i]);

else if(array[mid] < target)

}

low = mid + 1;

//随机数----arc4random()

else //findthetarget

//    int num1 = arc4random() % 101;

return mid;

//    printf("取出的随机数的数值为:%dn",num1);

}

//闭合区间 [10 -- 20]

//the array does not contain the target

int num2 = arc4random() % (20 - 10 + 1) + 10;

return -1;

printf("取出的随机数的数值为:%dn",num2);

}

练习 :定义整形数组,包含10个元素,元素的范围是[30 ,70]数组初始值为0,给数组随机赋值,并且求出元素的和以及平均值


int numArray[10] = {};

递归实现

int sum = 0;

int binary_search(const int arr[],int low,int high,int key)

for (int i = 0; i < 10;i++){

{

numArray[i] = arc4random() % (70 - 30 +1) +30;

int mid=low + (high - low) / 2;

sum += numArray[i];

if(low > high)

}

return -1;

printf("数组的和为:%d,平均值为:%.2fn",sum,sum / 10);

else{

练习3:定义元素个数为10�的整形数组,元素赋值随机范围[30,70],求数组中的最小值和最大值.

if(arr[mid] == key)

int arr3[10] = {0};

return mid;

int max = 0; // 0---29都可以用来存储最大值

else if(arr[mid] > key)

int min = 71; //71以上的数都可以,用来存储最小值

return binary_search(arr, low, mid-1, key);

for (int i = 0; i< 10; i++) {

else

arr3[i] = arc4random() % (70 - 30 + 1) + 30;

return binary_search(arr, mid+1, high, key);

//将随机的每一个值相比较

}

//取最大

}

if(max < arr3[i]){

6、    如何实现链表翻转(链表逆序)?

max = arr3[i];

思路:每次把第二个元素提到最前面来。

}

#include

//取最小

#include

min = min > arr3[i] ? min :arr3[i];

typedef struct NODE {

}

struct NODE *next;

printf("最大值为:%d, 最小值为%d",max,min);

int num;

练习4: 定义俩个整形数组,元素个数为10,数组取值范围随机[20,60],将这俩个数组的元素放入一个新的数组中

}node;

int arr4[10] = {0},arr5[10] = {0},arr6[20] = {0};

node *createLinkList(int length) {

for (int i = 0; i < 10; i++) {

if (length <= 0) {

arr4[i] = arc4random() % (60 - 20 + 1) + 20;

return NULL;

arr5[i] = arc4random() % (60 - 20 + 1) + 20;

}

//俩个元素同时赋值给第三个数组

node *head,*p,*q;

arr6[i] = arr4[i];

int number = 1;

arr6[i + 10] = arr5[i];

head = (node *)malloc(sizeof(node));

printf("%d,%dn",arr4[i],arr5[i]);

head->num = 1;

}

head->next = head;

for (int i = 0; i < 20; i++) {

p = q = head;

printf("新数组为:%dn",arr6[i]);

while (++number <= length) {

}

p = (node *)malloc(sizeof(node));

======================================================

p->num = number;

//冒牌排序

p->next = NULL;

//需要双层循环,外层控制循环趟数,内层控制循环次数

q->next = p;

//提高效率而言外层趟数为元素个数-1,内层循环处于递减状态,为元素个数-1-i,

q = p;

//内层循环必须设置元素个数-1的操作,要防止下标越界.

}

int f[6]= {23,4,54,66,33,43};

return head;

for(int i = 0; i < 6 - 1;i++){

}

for (int j = 0; j <  6 - 1 - i; j++) {

void printLinkList(node *head) {

//升序

if (head == NULL) {

if (f[j] > f[j+1]) {

return;

//前者大于后者的话  就交换位置

}

int temp = f[j];

node *p = head;

f[j] = f[j+1];

while (p) {

f[j+1] = temp;

printf("%d ", p->num);

}

p = p -> next;

}

}

}

printf("n");

for(int i = 0; i <6;i++ ){

}

printf("%d",f[i]);

node *reverseFunc1(node *head) {

}

if (head == NULL) {

======================================================

return head;

//字符数组,存储字符的数组

}

char str1[7] = {'t','y','f','g','k','s'};

node *p,*q;

//打印下标为3的字符

p = head;

printf("%cn",str1[3]);

q = NULL;

//将小写的g改成大写的

while (p) {

str1[4] = 'G';

node *pNext = p -> next;

printf("%sn",str1);

p -> next = q;

//定义字符串-------

q = p;

//字符串本身就是字符数组,只是字符串的结尾是以结尾的,如果在字符数组中也设置了,那么此字符数组也可以当做字符串来输出

p = pNext;

char str2[] = "hello world";

}

printf("%sn",str2);

return q;

//列举字符串情况

}

//1,设置的元素个数,大于实际元素个数

int main(int argc, const char * argv[]) {

char str3[9] = {'u','l','o'};

node *head = createLinkList(7);

printf("%sn",str3);

if (head) {

//手动设置

printLinkList(head);

char str4[] = {'h','i',''};

node *reHead = reverseFunc1(head);

printf("%sn",str4);

printLinkList(reHead);

//********____字符串操作函数

free(reHead);

//计算字符串长度,以结束的biaoshi

}

char string[] = "you are beautiful";

free(head);

//注意长度属于计算类型,值是 >= 0 的

return 0;

unsigned long strLenght = strlen(string); //strlen 字符串长度

}

printf("%lun",strLenght);

7、    实现一个字符串“how are you”的逆序输出(编程语言不限)。如给定字符串为“hello world”,输出结果应当为“world hello”。

//字符串拼接,讲一个字符串拼接到另一个字符串

int spliterFunc(char *p) {

char string2[30] = "hello";

char c[100][100];

char string3[] = "world";

int i = 0;

strcat(string2, string3); // 将字符串3拼接到字符串2后面

int j = 0;

printf("%sn",string2);  //strcat 拼接

while (*p != '') {

//字符串拼接字符串拷贝 需要注意变量内存问题

if (*p == ' ') {

//字符串拷贝

i++;

strcpy(string2, "hahahah");//strcpy 拷贝

j = 0;

printf("%sn",string2);

} else {

//字符串比较,比较俩个字符串对应位置的字符,比较的是字符串整数值,对应位置的值相减,结果不为0就结束比较

c[i][j] = *p;

/*

j++;

char s1[] = "abcd";

}

char s2[] = "abcde";

p++;

int result = strcmp(s1, s2); // strcmp 差值

}

printf("差值为:%dn",result);

for (int k = i; k >= 0; k--) {

======================================================

printf("%s", c[k]);

//宏定义 纯大写  作用 给一个值起一个新名字,在程序中可以把相同的值宏定义,方便后期查阅和修改

if (k > 0) {

//命名规则:纯大写  或者 k+驼峰

printf(" ");

//宏定义相当于常量,前者代替后者,所以不要加分号

} else {

#define COLORTYPE "red"

printf("n");

#define kColorType "red"

}

#define NUM 89

}

#define A int

return 0;

#define  B A

}

#define MAXVALUE(a,b) a > b ? a :

8、    给定一个字符串,输出本字符串中只出现一次并且最靠前的那个字符的位置?如“abaccddeeef”,字符是b,输出应该是2。

======================================================

char *strOutPut(char *);

//函数允许嵌套调用,但不允许嵌套定义

int compareDifferentChar(char, char *);

//函数 声明---定义---调用

int main(int argc, const char * argv[]) {

//声明 分号结尾  //函数声明可写可不写

char *inputStr = "abaccddeeef";

// 练习求俩个数的最大值

char *outputStr = strOutPut(inputStr);

.h文件声明

printf("%c n", *outputStr);

int twoMaxValue(int a,int b);

return 0;

// 形参  形式参数  起占位以及提示作用

}

.m文件实现

char *strOutPut(char *s) {

int twoMaxValue(int a,int b){

char str[100];

return a > b ? a : b;

char *p = s;

}

int index = 0;

main函数里调用

while (*s != '') {

int m = twoMaxValue(89,9);

if (compareDifferentChar(*s, p) == 1) {

printf("%d",m);

str[index] = *s;

练习1:定义函数,功能为输入字符,返回字符对应的整数值

index++;

int getCharValue (char a){

}

return a;

s++;

}

}

练习:将char s[] = "asdyfsg"反向输出

return &str;

void printChar(char str[],int count){

}

//如果参数列表中没有count参数,我们可以使用strlen 计算字符串长度

int compareDifferentChar(char c, char *s) {

unsigned long length = strlen(str); // 字符串的长度

int i = 0;

for (int i = 0; i < length / 2; i++){

while (*s != '' && i<= 1) {

//交换前后字母

if (*s == c) {

char s = str[i];

i++;

str[i] = str[length - 1 - i];

}

str[length - 1 - i] = s;

s++;

}

}

printf("%sn",str);

if (i == 1) {

}

return 1;

练习3:定义函数,功能为输出某一个数的所有约数

} else {

void yueshu(int a){

return 0;

for (int i = 1; i <= a; i++) {

}

if (a % i == 0) {

}

//能整除  是约数

9、    二叉树的先序遍历为FBACDEGH,中序遍历为:ABDCEFGH,请写出这个二叉树的后序遍历结果。

printf("%d ",i);

ADECBHGF

}

先序+中序遍历还原二叉树:先序遍历是:ABDEGCFH 中序遍历是:DBGEACHF

}

首先从先序得到第一个为A,就是二叉树的根,回到中序,可以将其分为三部分:

}

左子树的中序序列DBGE,根A,右子树的中序序列CHF

练习4:定义函数,功能为找出三个整数的中间值,并返回

接着将左子树的序列回到先序可以得到B为根,这样回到左子树的中序再次将左子树分割为三部分:

int mid(int a, int b,int c){

左子树的左子树D,左子树的根B,左子树的右子树GE

int f[3] = {a,b,c};

同样地,可以得到右子树的根为C

for (int i = 0; i < 3 - 1; i++) {

类似地将右子树分割为根C,右子树的右子树HF,注意其左子树为空

for (int j = 0; j < 3 - 1 - i ; j++) {

如果只有一个就是叶子不用再进行了,刚才的GE和HF再次这样运作,就可以将二叉树还原了。

if (f[j] > f[j + 1]) {

10、    打印2-100之间的素数。

int temp = f[j];

int main(int argc, const char * argv[]) {

f[j] = f[j+1];

for (int i = 2; i < 100; i++) {

f[j+1] = temp;

int r = isPrime(i);

}

if (r == 1) {

}

printf("%ld ", i);

}

}

int k = (sizeof(f) / 4 + 1) / 2;

}

printf("888888888%dn", k);

return 0;

return f[(sizeof(f) / 4 - 1) / 2];

}

}

int isPrime(int n)

练习5:      //数组名 以及 数组元素个数不一致

{

                 //封装冒泡排序(写一个冒泡函数)就需要把不一样的值暴露

int i, s;

void sortArray(int array[],int count){

for(i = 2; i <= sqrt(n); i++)

for (int i = 0 ; i < count - 1; i++) {

if(n % i == 0)  return 0;

for (int j = 0; j < count - 1 - i; j++) {

return 1;

if (array[j] > array[j + 1]) {

}

int temp = array[j];

11、    求两个整数的最大公约数。

array[j] = array[j + 1];

int gcd(int a, int b) {

array[j + 1] = temp;

int temp = 0;

}

if (a < b) {

}

temp = a;

}

a = b;

//输出

b = temp;

for(int i = 0; i < count;i++){

}

printf("%d ",array[i]);

while (b != 0) {

}

temp = a % b;

}

a = b;

//**********************************************

b = temp;

//    int temp = getCharValue('a');

}

//    printf("字符对应的整数值:%dn",temp);

return a;

//*********************************************

1、给出一个由小写字母组成的字符串,把所有连续出现的2个a替换成bb(2个b),但是对于超过两个连续的a,那么这些字符都不作替换。例如:

//    changeValue(23, 67);

bad -> bad(一个a,不替换)

//*********************************************

baad -> bbbd(替换成bb)

//    yueshu(20);

baaad -> baaad(连续三个a,不替换)

//*********************************************

apaapaaapaa -> apbbpaaapbb(这里连续的a出现了4次,只有第二段和最后一段被替换)

//  int m = mid(25, 78, 39);

- (NSString*)replace:(NSString*)str {// CODE HERENSMutableString*retString = [NSMutableStringstringWithString:str];// 准备替换的字符串NSString*replaceString =@"bb";// 正则表达式 (^a{2}[^a]) 以aa(第三个字母不是a)开头,([^a]a{2}[^a]) 字符串中间的aa(前后都不是a),([^a]a{2}$) 以aa结尾(倒数第三个字母不是a)NSRegularExpression*regular = [[NSRegularExpressionalloc] initWithPattern:@"(^a{2}[^a])|([^a]a{2}[^a])|([^a]a{2}$)"options:NSMatchingReportProgresserror:nil];NSRangerange;do{        range = [regular rangeOfFirstMatchInString:retString options:NSMatchingReportProgressrange:NSMakeRange(0, retString.length)];if(range.length ==4) {// 替换中间的aa[retString replaceCharactersInRange:NSMakeRange(range.location +1,2) withString:replaceString];        }elseif(range.length >0) {if(range.location ==0) {// 替换开头的aa[retString replaceCharactersInRange:NSMakeRange(range.location,2) withString:replaceString];            }else{// 替换结尾的aa[retString replaceCharactersInRange:NSMakeRange(retString.length -2,2) withString:replaceString];            }        }    }while(range.length >0);returnretString;}

//  printf("中间值为:%dn", m);

2、给出一个字符串,其中只包含括号(大中小括号“()[]{}”),括号可以任意嵌套。如果同样的左右括号成对出现并且嵌套正确,那么认为它是匹配的。例如:()  ->  TRUE(匹配)

//*********************************************

[()]  ->  TRUE(匹配,括号可以嵌套)

//int arr[4] ={34,5,65,7};

()()   ->  TRUE(匹配,括号可以并列排列)

//注意  调用函数

({}([]))  ->  TRUE(匹配,括号可以任意嵌套,大括号不必在外)

//array 是要求我们放数组的地址  数组名就是该数组的地址

)   ->  FALSE(不匹配,缺少左括号)

//sortArray(arr, 4);

(}   ->  FALSE(不匹配,左右括号不一样)

char s[] = "dhjfhlk";

{)(}   ->  FALSE(不匹配,左右括号相反)

printChar(s, 7);

- (BOOL)isMatch:(NSString *)str {// CODE HERE// 采用进站出站的思想,遍历完字符串时如果array为空则匹配成功,否则失败NSMutableArray *array = [NSMutableArray array];for(inti =0; i < str.length; i++) {inttag = [selfcreateTagWithString:[strsubstringWithRange:NSMakeRange(i,1)]];if(tag !=0) {intlastTag = [[array lastObject] intValue];if((lastTag + tag) ==0) {                [array removeLastObject];            }else{                [arrayaddObject:@(tag)];            }        }    }returnarray.count ==0;}- (int)createTagWithString:(NSString *)str {if([strisEqualToString:@"("]) {return-1;    }elseif([strisEqualToString:@")"]) {return1;    }elseif([strisEqualToString:@"["]) {return-2;    }elseif([strisEqualToString:@"]"]) {return2;    }elseif([strisEqualToString:@"{"]) {return-3;    }elseif([strisEqualToString:@"}"]) {return3;    }return0;}

//布尔  也是整形

3、写一个函数,找出一个数组中出现次数超过一半的数字,如果数字不存在,则返回-1。例如:

BOOL d = YES; //可以赋数字也可以是yes 或者no

[0, 1, 2]             -->     -1(每个数字只出现1次)

printf("%dn",d);

[0, 1, 2, 1]         -->-1(1出现了2次,刚好一半)

[0, 1, 2, 1, 1]     -->     1(1出现了3次,超过一半)

(注:数组不是按从小到达排序的,也许排序之后更容易找到这个数,但是有没有更好、更快的方法在不重新调整顺序的情况得到结果?)

- (int)mode:(NSArray*)array {// CODE HERE// 将集合中得数字转存到字典中,数字做key,对应出现的次数做valueNSMutableDictionary*modeMap = [NSMutableDictionarydictionary];    [array enumerateObjectsUsingBlock:^(idobj,NSUIntegeridx,BOOL*stop) {NSString*key = obj;idcount = modeMap[key];inti = [(NSNumber*)count intValue];        [modeMap setObject:@(i +1) forKey:key];    }];    __blockintretInt =-1;// 遍历字典,找出其中value大于集合一半的key并返回[modeMap.allKeys enumerateObjectsUsingBlock:^(idobj,NSUIntegeridx,BOOL*stop) {NSString*key = obj;intmode = [modeMap[key] intValue];if(mode > array.count /2) {            retInt = key.intValue;            *stop =YES;        }    }];returnretInt;}

编辑:编程 本文来源:i++){  // 外层循环控制趟数,System.out.println("冒泡

关键词:

  • 上一篇:没有了
  • 下一篇:没有了